diff --git a/conf/pytest_parallel_infinity_conf.toml b/conf/pytest_parallel_infinity_conf.toml
index f5efd734fe..50e5cc0038 100644
--- a/conf/pytest_parallel_infinity_conf.toml
+++ b/conf/pytest_parallel_infinity_conf.toml
@@ -17,6 +17,7 @@ persistence_dir          = "/var/infinity/persistence"
 [buffer]
 buffer_manager_size      = "8GB"
 temp_dir                 = "/var/infinity/tmp"
+result_cache_mode       = "on"
 
 [wal]
 wal_dir                  = "/var/infinity/wal"
diff --git a/conf/pytest_parallel_infinity_vfs_off.toml b/conf/pytest_parallel_infinity_vfs_off.toml
index 08af3aa21b..2c1dc889af 100644
--- a/conf/pytest_parallel_infinity_vfs_off.toml
+++ b/conf/pytest_parallel_infinity_vfs_off.toml
@@ -17,6 +17,7 @@ data_dir                 = "/var/infinity/data"
 [buffer]
 buffer_manager_size      = "8GB"
 temp_dir                 = "/var/infinity/tmp"
+result_cache_mode       = "on"
 
 [wal]
 wal_dir                  = "/var/infinity/wal"
diff --git a/src/common/default_values.cppm b/src/common/default_values.cppm
index 4816dd9e43..73f8ba172f 100644
--- a/src/common/default_values.cppm
+++ b/src/common/default_values.cppm
@@ -198,6 +198,9 @@ export {
 
     constexpr SizeT INSERT_BATCH_ROW_LIMIT = 8192;
 
+    constexpr std::string_view DEFAULT_RESULT_CACHE_MODE = "off";
+    constexpr SizeT DEFAULT_CACHE_RESULT_NUM = 10000;
+
     // default persistence parameter
     constexpr std::string_view DEFAULT_PERSISTENCE_DIR = "/var/infinity/persistence"; // Empty means disabled
     constexpr std::string_view DEFAULT_PERSISTENCE_OBJECT_SIZE_LIMIT_STR = "128MB"; // 128MB
@@ -257,6 +260,8 @@ export {
     constexpr std::string_view LRU_NUM_OPTION_NAME = "lru_num";
     constexpr std::string_view TEMP_DIR_OPTION_NAME = "temp_dir";
     constexpr std::string_view MEMINDEX_MEMORY_QUOTA_OPTION_NAME = "memindex_memory_quota";
+    constexpr std::string_view RESULT_CACHE_MODE_OPTION_NAME = "result_cache_mode";
+    constexpr std::string_view CACHE_RESULT_NUM_OPTION_NAME = "cache_result_num";
 
     constexpr std::string_view WAL_DIR_OPTION_NAME = "wal_dir";
     constexpr std::string_view WAL_COMPACT_THRESHOLD_OPTION_NAME = "wal_compact_threshold";
diff --git a/src/executor/explain_physical_plan.cpp b/src/executor/explain_physical_plan.cpp
index 1ab3bd24dc..8296e18d1e 100644
--- a/src/executor/explain_physical_plan.cpp
+++ b/src/executor/explain_physical_plan.cpp
@@ -820,7 +820,7 @@ void ExplainPhysicalPlan::Explain(const PhysicalKnnScan *knn_scan_node, SharedPt
     result->emplace_back(MakeShared<String>(table_name));
 
     // Table index
-    String table_index = String(intent_size, ' ') + " - table index: #" + std::to_string(knn_scan_node->knn_table_index_);
+    String table_index = String(intent_size, ' ') + " - table index: #" + std::to_string(knn_scan_node->table_index());
     result->emplace_back(MakeShared<String>(table_index));
 
     KnnExpression *knn_expr_raw = knn_scan_node->knn_expression_.get();
@@ -2368,7 +2368,7 @@ void ExplainPhysicalPlan::Explain(const PhysicalMergeKnn *merge_knn_node,
     result->emplace_back(MakeShared<String>(explain_header_str));
 
     // Table index
-    String table_index = String(intent_size, ' ') + " - table index: #" + std::to_string(merge_knn_node->knn_table_index());
+    String table_index = String(intent_size, ' ') + " - table index: #" + std::to_string(merge_knn_node->table_index());
     result->emplace_back(MakeShared<String>(table_index));
 
     // Output columns
@@ -2600,6 +2600,56 @@ void ExplainPhysicalPlan::Explain(const PhysicalMergeMatchTensor *merge_match_te
     }
 }
 
+void ExplainPhysicalPlan::Explain(const PhysicalMergeMatchSparse *merge_match_sparse_node,
+                                  SharedPtr<Vector<SharedPtr<String>>> &result,
+                                  i64 intent_size) {
+    String explain_header_str;
+    if (intent_size != 0) {
+        explain_header_str = String(intent_size - 2, ' ') + "-> MERGE MatchSparse ";
+    } else {
+        explain_header_str = "MERGE MatchSparse ";
+    }
+    explain_header_str += "(" + std::to_string(merge_match_sparse_node->node_id()) + ")";
+    result->emplace_back(MakeShared<String>(explain_header_str));
+
+    // Table alias and name
+    String table_name = String(intent_size, ' ') + " - table name: " + merge_match_sparse_node->TableAlias() + "(";
+
+    table_name += *merge_match_sparse_node->table_collection_ptr()->GetDBName() + ".";
+    table_name += *merge_match_sparse_node->table_collection_ptr()->GetTableName() + ")";
+    result->emplace_back(MakeShared<String>(table_name));
+
+    // Table index
+    String table_index = String(intent_size, ' ') + " - table index: #" + std::to_string(merge_match_sparse_node->table_index());
+    result->emplace_back(MakeShared<String>(table_index));
+
+    String match_sparse_expression =
+        String(intent_size, ' ') + " - MatchSparse expression: " + merge_match_sparse_node->match_sparse_expr()->ToString();
+    result->emplace_back(MakeShared<String>(std::move(match_sparse_expression)));
+
+    String top_n_expression = String(intent_size, ' ') + " - Top N: " + std::to_string(merge_match_sparse_node->GetTopN());
+    result->emplace_back(MakeShared<String>(std::move(top_n_expression)));
+
+    // Output columns
+    String output_columns = String(intent_size, ' ') + " - output columns: [";
+    SizeT column_count = merge_match_sparse_node->GetOutputNames()->size();
+    if (column_count == 0) {
+        String error_message = "No column in PhysicalMergeMatchSparse node.";
+        UnrecoverableError(error_message);
+    }
+    for (SizeT idx = 0; idx < column_count - 1; ++idx) {
+        output_columns += merge_match_sparse_node->GetOutputNames()->at(idx) + ", ";
+    }
+    output_columns += merge_match_sparse_node->GetOutputNames()->back();
+    output_columns += "]";
+    result->emplace_back(MakeShared<String>(output_columns));
+
+    if (merge_match_sparse_node->left() == nullptr) {
+        String error_message = "PhysicalMergeMatchSparse should have child node!";
+        UnrecoverableError(error_message);
+    }
+}
+
 void ExplainPhysicalPlan::Explain(const PhysicalFusion *fusion_node, SharedPtr<Vector<SharedPtr<String>>> &result, i64 intent_size) {
     String explain_header_str;
     if (intent_size != 0) {
diff --git a/src/executor/explain_physical_plan.cppm b/src/executor/explain_physical_plan.cppm
index 9da3b82aaf..41f1483f7f 100644
--- a/src/executor/explain_physical_plan.cppm
+++ b/src/executor/explain_physical_plan.cppm
@@ -62,6 +62,7 @@ import physical_merge_top;
 import physical_merge_sort;
 import physical_merge_knn;
 import physical_merge_match_tensor;
+import physical_merge_match_sparse;
 import physical_match;
 import physical_match_tensor_scan;
 import physical_fusion;
@@ -176,6 +177,8 @@ public:
 
     static void Explain(const PhysicalMergeMatchTensor *merge_match_tensor_node, SharedPtr<Vector<SharedPtr<String>>> &result, i64 intent_size = 0);
 
+    static void Explain(const PhysicalMergeMatchSparse *merge_match_sparse_node, SharedPtr<Vector<SharedPtr<String>>> &result, i64 intent_size = 0);
+
     static void Explain(const PhysicalFusion *fusion_node, SharedPtr<Vector<SharedPtr<String>>> &result, i64 intent_size = 0);
 
     static void Explain(const PhysicalMergeAggregate *fusion_node, SharedPtr<Vector<SharedPtr<String>>> &result, i64 intent_size = 0);
diff --git a/src/executor/operator/physical_command.cpp b/src/executor/operator/physical_command.cpp
index 7df5da871d..776139ad14 100644
--- a/src/executor/operator/physical_command.cpp
+++ b/src/executor/operator/physical_command.cpp
@@ -143,6 +143,23 @@ bool PhysicalCommand::Execute(QueryContext *query_context, OperatorState *operat
                     Config* config = query_context->global_config();
                     GlobalOptionIndex config_index = config->GetOptionIndex(set_command->var_name());
                     switch(config_index) {
+                        case GlobalOptionIndex::kResultCacheMode: {
+                            if (set_command->value_type() != SetVarType::kString) {
+                                Status status = Status::DataTypeMismatch("String", set_command->value_type_str());
+                                RecoverableError(status);
+                            }
+                            if (set_command->value_str() == "on") {
+                                config->SetCacheResult("on");
+                                return true;
+                            }
+                            if (set_command->value_str() == "off") {
+                                config->SetCacheResult("off");
+                                return true;
+                            }
+                            Status status = Status::SetInvalidVarValue("cache result", "on, off");
+                            RecoverableError(status);
+                            break;
+                        }
                         case GlobalOptionIndex::kLogLevel: {
                             if (set_command->value_type() != SetVarType::kString) {
                                 Status status = Status::DataTypeMismatch("String", set_command->value_type_str());
diff --git a/src/executor/operator/physical_fusion.cpp b/src/executor/operator/physical_fusion.cpp
index 1260ff4194..4a4ceed336 100644
--- a/src/executor/operator/physical_fusion.cpp
+++ b/src/executor/operator/physical_fusion.cpp
@@ -55,6 +55,7 @@ import mlas_matrix_multiply;
 import physical_match_tensor_scan;
 import physical_knn_scan;
 import physical_merge_knn;
+import physical_read_cache;
 
 namespace infinity {
 
@@ -230,7 +231,8 @@ void PhysicalFusion::ExecuteRRFWeighted(const Map<u64, Vector<UniquePtr<DataBloc
                 child_op = right();
             else
                 child_op = other_children_[i - 2].get();
-            switch (child_op->operator_type()) {
+            auto child_type = child_op->operator_type();
+            switch (child_type) {
                 case PhysicalOperatorType::kKnnScan: {
                     PhysicalKnnScan *phy_knn_scan = static_cast<PhysicalKnnScan *>(child_op);
                     min_heaps[i] = phy_knn_scan->IsKnnMinHeap();
@@ -249,6 +251,11 @@ void PhysicalFusion::ExecuteRRFWeighted(const Map<u64, Vector<UniquePtr<DataBloc
                     min_heaps[i] = true;
                     break;
                 }
+                case PhysicalOperatorType::kReadCache: {
+                    PhysicalReadCache *phy_read_cache = static_cast<PhysicalReadCache *>(child_op);
+                    min_heaps[i] = phy_read_cache->is_min_heap();
+                    break;
+                }
                 default: {
                     String error_message = fmt::format("Cannot determine heap type of operator {}", int(child_op->operator_type()));
                     UnrecoverableError(error_message);
diff --git a/src/executor/operator/physical_read_cache.cpp b/src/executor/operator/physical_read_cache.cpp
index 8c99fedc63..f6c1251f3c 100644
--- a/src/executor/operator/physical_read_cache.cpp
+++ b/src/executor/operator/physical_read_cache.cpp
@@ -22,6 +22,42 @@ import column_vector;
 
 namespace infinity {
 
+PhysicalReadCache::PhysicalReadCache(u64 id,
+                                     LogicalNodeType origin_type,
+                                     SharedPtr<BaseTableRef> base_table_ref,
+                                     SharedPtr<CacheContent> cache_content,
+                                     Vector<SizeT> column_map,
+                                     SharedPtr<Vector<LoadMeta>> load_metas,
+                                     bool is_min_heap)
+    : PhysicalOperator(PhysicalOperatorType::kReadCache, nullptr, nullptr, id, load_metas), base_table_ref_(base_table_ref),
+      cache_content_(cache_content), column_map_(column_map), is_min_heap_(is_min_heap) {
+    switch (origin_type) {
+        case LogicalNodeType::kMatch: {
+            origin_type_ = PhysicalOperatorType::kMatch;
+            break;
+        }
+        case LogicalNodeType::kKnnScan: {
+            origin_type_ = PhysicalOperatorType::kKnnScan;
+            break;
+        }
+        case LogicalNodeType::kMatchSparseScan: {
+            origin_type_ = PhysicalOperatorType::kMatchSparseScan;
+            break;
+        }
+        case LogicalNodeType::kMatchTensorScan: {
+            origin_type_ = PhysicalOperatorType::kMatchTensorScan;
+            break;
+        }
+        case LogicalNodeType::kIndexScan: {
+            origin_type_ = PhysicalOperatorType::kIndexScan;
+            break;
+        }
+        default: {
+            UnrecoverableError("Not implemented");
+        }
+    }
+}
+
 bool PhysicalReadCache::Execute(QueryContext *query_context, OperatorState *operator_state) {
     auto *read_cache_state = static_cast<ReadCacheState *>(operator_state);
     Vector<UniquePtr<DataBlock>> &data_block_array = read_cache_state->data_block_array_;
diff --git a/src/executor/operator/physical_read_cache.cppm b/src/executor/operator/physical_read_cache.cppm
index fbd7a79952..5af44326f2 100644
--- a/src/executor/operator/physical_read_cache.cppm
+++ b/src/executor/operator/physical_read_cache.cppm
@@ -22,18 +22,19 @@ import data_type;
 import result_cache_manager;
 import physical_operator_type;
 import load_meta;
+import logical_node_type;
 
 namespace infinity {
 
 export class PhysicalReadCache : public PhysicalOperator {
 public:
     PhysicalReadCache(u64 id,
+                      LogicalNodeType origin_type,
                       SharedPtr<BaseTableRef> base_table_ref,
                       SharedPtr<CacheContent> cache_content,
                       Vector<SizeT> column_map,
-                      SharedPtr<Vector<LoadMeta>> load_metas)
-        : PhysicalOperator(PhysicalOperatorType::kReadCache, nullptr, nullptr, id, load_metas), base_table_ref_(base_table_ref),
-          cache_content_(cache_content), column_map_(column_map) {}
+                      SharedPtr<Vector<LoadMeta>> load_metas,
+                      bool is_min_heap);
 
     void Init() override {};
 
@@ -45,14 +46,25 @@ public:
 
     SharedPtr<Vector<SharedPtr<DataType>>> GetOutputTypes() const override;
 
+    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
+        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
+    }
+
+
     const BaseTableRef *base_table_ref() const { return base_table_ref_.get(); }
 
+    PhysicalOperatorType origin_type() const { return origin_type_; }
+
+    bool is_min_heap() const { return is_min_heap_; }
+
 private:
     SharedPtr<BaseTableRef> base_table_ref_;
 
     SharedPtr<CacheContent> cache_content_;
 
+    PhysicalOperatorType origin_type_;
     Vector<SizeT> column_map_; // result column id -> cache column id
+    bool is_min_heap_;
 };
 
 } // namespace infinity
diff --git a/src/executor/operator/physical_scan/physical_filter_scan_base.cppm b/src/executor/operator/physical_scan/physical_filter_scan_base.cppm
index 8fd1616b64..18c4793188 100644
--- a/src/executor/operator/physical_scan/physical_filter_scan_base.cppm
+++ b/src/executor/operator/physical_scan/physical_filter_scan_base.cppm
@@ -32,10 +32,12 @@ public:
                            PhysicalOperatorType type,
                            UniquePtr<PhysicalOperator> left,
                            UniquePtr<PhysicalOperator> right,
+                           u64 table_index,
                            SharedPtr<BaseTableRef> base_table_ref,
                            SharedPtr<CommonQueryFilter> common_query_filter,
                            SharedPtr<Vector<LoadMeta>> load_metas)
-        : PhysicalScanBase(id, type, std::move(left), std::move(right), base_table_ref, load_metas), common_query_filter_(common_query_filter) {}
+        : PhysicalScanBase(id, type, std::move(left), std::move(right), table_index, base_table_ref, load_metas),
+          common_query_filter_(common_query_filter) {}
 
     bool CalculateFilterBitmask(SegmentID segment_id, BlockID block_id, BlockOffset row_count, Bitmask &bitmask) const;
 
diff --git a/src/executor/operator/physical_scan/physical_index_scan.cpp b/src/executor/operator/physical_scan/physical_index_scan.cpp
index 4a4db6fbc0..facb0d00a0 100644
--- a/src/executor/operator/physical_scan/physical_index_scan.cpp
+++ b/src/executor/operator/physical_scan/physical_index_scan.cpp
@@ -38,6 +38,7 @@ import fast_rough_filter;
 import roaring_bitmap;
 import filter_value_type_classification;
 import physical_scan_base;
+import result_cache_manager;
 
 namespace infinity {
 
@@ -49,8 +50,9 @@ PhysicalIndexScan::PhysicalIndexScan(const u64 id,
                                      SharedPtr<Vector<LoadMeta>> load_metas,
                                      SharedPtr<Vector<String>> output_names,
                                      SharedPtr<Vector<SharedPtr<DataType>>> output_types,
-                                     const bool add_row_id)
-    : PhysicalScanBase(id, PhysicalOperatorType::kIndexScan, nullptr, nullptr, std::move(base_table_ref), std::move(load_metas)),
+                                     const bool add_row_id,
+                                     bool cache_result)
+    : PhysicalScanBase(id, PhysicalOperatorType::kIndexScan, nullptr, nullptr, 0, std::move(base_table_ref), std::move(load_metas), cache_result),
       index_filter_(std::move(index_filter)), index_filter_evaluator_(std::move(index_filter_evaluator)),
       fast_rough_filter_evaluator_(std::move(fast_rough_filter_evaluator)), output_names_(std::move(output_names)),
       output_types_(std::move(output_types)), add_row_id_(add_row_id) {
@@ -182,6 +184,11 @@ void PhysicalIndexScan::ExecuteInternal(QueryContext *query_context, IndexScanOp
             // Finished
             index_scan_operator_state->SetComplete();
         }
+
+        ResultCacheManager *cache_mgr = query_context->storage()->result_cache_manager();
+        if (cache_result_ && cache_mgr != nullptr) {
+            AddCache(query_context, cache_mgr, output_data_blocks);
+        }
     };
     // check FastRoughFilter
     const auto &fast_rough_filter = *segment_entry->GetFastRoughFilter();
diff --git a/src/executor/operator/physical_scan/physical_index_scan.cppm b/src/executor/operator/physical_scan/physical_index_scan.cppm
index 03dfe8e0c2..5deab52ee2 100644
--- a/src/executor/operator/physical_scan/physical_index_scan.cppm
+++ b/src/executor/operator/physical_scan/physical_index_scan.cppm
@@ -59,7 +59,8 @@ public:
                                SharedPtr<Vector<LoadMeta>> load_metas,
                                SharedPtr<Vector<String>> output_names,
                                SharedPtr<Vector<SharedPtr<DataType>>> output_types,
-                               bool add_row_id = true);
+                               bool add_row_id = true,
+                               bool cache_result = false);
 
     ~PhysicalIndexScan() final = default;
 
@@ -78,11 +79,6 @@ public:
 
     Vector<SharedPtr<Vector<GlobalBlockID>>> PlanBlockEntries(i64) const override;
 
-    // for InputLoad
-    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
-        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
-    }
-
     Vector<UniquePtr<Vector<SegmentID>>> PlanSegments(u32 parallel_count) const;
 
     inline String table_alias() const { return base_table_ref_->alias_; }
diff --git a/src/executor/operator/physical_scan/physical_knn_scan.cppm b/src/executor/operator/physical_scan/physical_knn_scan.cppm
index 2fee15848b..d2a424d70a 100644
--- a/src/executor/operator/physical_scan/physical_knn_scan.cppm
+++ b/src/executor/operator/physical_scan/physical_knn_scan.cppm
@@ -44,9 +44,15 @@ public:
                              SharedPtr<Vector<SharedPtr<DataType>>> output_types,
                              u64 knn_table_index,
                              SharedPtr<Vector<LoadMeta>> load_metas)
-        : PhysicalFilterScanBase(id, PhysicalOperatorType::kKnnScan, nullptr, nullptr, base_table_ref, common_query_filter, load_metas),
-          knn_expression_(std::move(knn_expression)), output_names_(std::move(output_names)), output_types_(std::move(output_types)),
-          knn_table_index_(knn_table_index) {}
+        : PhysicalFilterScanBase(id,
+                                 PhysicalOperatorType::kKnnScan,
+                                 nullptr,
+                                 nullptr,
+                                 knn_table_index,
+                                 base_table_ref,
+                                 common_query_filter,
+                                 load_metas),
+          knn_expression_(std::move(knn_expression)), output_names_(std::move(output_names)), output_types_(std::move(output_types)) {}
 
     ~PhysicalKnnScan() override = default;
 
@@ -72,10 +78,6 @@ public:
 
     SizeT TaskletCount() override;
 
-    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
-        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
-    }
-
     inline bool IsKnnMinHeap() const { return knn_expression_->IsKnnMinHeap(); }
 
 private:
@@ -91,7 +93,6 @@ public:
 
     SharedPtr<Vector<String>> output_names_{};
     SharedPtr<Vector<SharedPtr<DataType>>> output_types_{};
-    u64 knn_table_index_{};
 
     Vector<Pair<u32, u32>> block_parallel_options_;
     u32 block_column_entries_size_ = 0; // need this value because block_column_entries_ will be moved into KnnScanSharedData
diff --git a/src/executor/operator/physical_scan/physical_match_sparse_scan.cpp b/src/executor/operator/physical_scan/physical_match_sparse_scan.cpp
index 5cb68c12ea..b9d42c1a4e 100644
--- a/src/executor/operator/physical_scan/physical_match_sparse_scan.cpp
+++ b/src/executor/operator/physical_scan/physical_match_sparse_scan.cpp
@@ -70,8 +70,15 @@ PhysicalMatchSparseScan::PhysicalMatchSparseScan(u64 id,
                                                  SharedPtr<MatchSparseExpression> match_sparse_expression,
                                                  const SharedPtr<CommonQueryFilter> &common_query_filter,
                                                  SharedPtr<Vector<LoadMeta>> load_metas)
-    : PhysicalFilterScanBase(id, PhysicalOperatorType::kMatchSparseScan, nullptr, nullptr, base_table_ref, common_query_filter, load_metas),
-      table_index_(table_index), match_sparse_expr_(std::move(match_sparse_expression)) {}
+    : PhysicalFilterScanBase(id,
+                             PhysicalOperatorType::kMatchSparseScan,
+                             nullptr,
+                             nullptr,
+                             table_index,
+                             base_table_ref,
+                             common_query_filter,
+                             load_metas),
+      match_sparse_expr_(std::move(match_sparse_expression)) {}
 
 void PhysicalMatchSparseScan::Init() { search_column_id_ = match_sparse_expr_->column_expr_->binding().column_idx; }
 
diff --git a/src/executor/operator/physical_scan/physical_match_sparse_scan.cppm b/src/executor/operator/physical_scan/physical_match_sparse_scan.cppm
index 2883c0ee7c..3743b752df 100644
--- a/src/executor/operator/physical_scan/physical_match_sparse_scan.cppm
+++ b/src/executor/operator/physical_scan/physical_match_sparse_scan.cppm
@@ -59,8 +59,8 @@ public:
 
     Vector<SharedPtr<Vector<SegmentID>>> PlanWithIndex(Vector<SharedPtr<Vector<GlobalBlockID>>> &block_groups, i64 parallel_count);
 
-    u64 table_index() const {
-        return table_index_;
+    SharedPtr<MatchSparseExpression> match_sparse_expr() const {
+        return match_sparse_expr_;
     }
 
 private:
@@ -84,7 +84,6 @@ private:
     ExecuteInnerT(DistFunc *dist_func, MergeHeap *merge_heap, QueryContext *query_context, MatchSparseScanOperatorState *match_sparse_scan_state);
 
 private:
-    u64 table_index_ = 0;
     SharedPtr<MatchSparseExpression> match_sparse_expr_;
 
     // column to search
diff --git a/src/executor/operator/physical_scan/physical_match_tensor_scan.cpp b/src/executor/operator/physical_scan/physical_match_tensor_scan.cpp
index b21473fed6..f4e3a82eb1 100644
--- a/src/executor/operator/physical_scan/physical_match_tensor_scan.cpp
+++ b/src/executor/operator/physical_scan/physical_match_tensor_scan.cpp
@@ -75,6 +75,7 @@ import logical_match_tensor_scan;
 import simd_functions;
 import knn_expression;
 import search_options;
+import result_cache_manager;
 
 namespace infinity {
 
@@ -89,10 +90,17 @@ PhysicalMatchTensorScan::PhysicalMatchTensorScan(u64 id,
                                                  SharedPtr<MatchTensorExpression> match_tensor_expression,
                                                  const SharedPtr<CommonQueryFilter> &common_query_filter,
                                                  u32 topn,
-                                                 const MatchTensorScanIndexOptions &index_options,
+                                                 const SharedPtr<MatchTensorScanIndexOptions> &index_options,
                                                  SharedPtr<Vector<LoadMeta>> load_metas)
-    : PhysicalFilterScanBase(id, PhysicalOperatorType::kMatchTensorScan, nullptr, nullptr, base_table_ref, common_query_filter, load_metas),
-      table_index_(table_index), src_match_tensor_expr_(std::move(match_tensor_expression)), topn_(topn), index_options_(index_options) {
+    : PhysicalFilterScanBase(id,
+                             PhysicalOperatorType::kMatchTensorScan,
+                             nullptr,
+                             nullptr,
+                             table_index,
+                             base_table_ref,
+                             common_query_filter,
+                             load_metas),
+      src_match_tensor_expr_(std::move(match_tensor_expression)), topn_(topn), index_options_(index_options) {
     search_column_id_ = std::numeric_limits<ColumnID>::max();
 }
 
@@ -297,11 +305,11 @@ void PhysicalMatchTensorScan::ExecuteInner(QueryContext *query_context, MatchTen
                                                                          segment_entry,
                                                                          block_index,
                                                                          begin_ts,
-                                                                         index_options_.emvb_centroid_nprobe_,
-                                                                         index_options_.emvb_threshold_first_,
-                                                                         index_options_.emvb_n_doc_to_score_,
-                                                                         index_options_.emvb_n_doc_out_second_stage_,
-                                                                         index_options_.emvb_threshold_final_);
+                                                                         index_options_->emvb_centroid_nprobe_,
+                                                                         index_options_->emvb_threshold_first_,
+                                                                         index_options_->emvb_n_doc_to_score_,
+                                                                         index_options_->emvb_n_doc_out_second_stage_,
+                                                                         index_options_->emvb_threshold_final_);
                 std::visit(Overload{[segment_id, &function_data](const Tuple<u32, UniquePtr<f32[]>, UniquePtr<u32[]>> &index_result) {
                                         const auto &[result_num, score_ptr, row_id_ptr] = index_result;
                                         for (u32 i = 0; i < result_num; ++i) {
@@ -354,11 +362,11 @@ void PhysicalMatchTensorScan::ExecuteInner(QueryContext *query_context, MatchTen
                                                       segment_entry,
                                                       block_index,
                                                       begin_ts,
-                                                      index_options_.emvb_centroid_nprobe_,
-                                                      index_options_.emvb_threshold_first_,
-                                                      index_options_.emvb_n_doc_to_score_,
-                                                      index_options_.emvb_n_doc_out_second_stage_,
-                                                      index_options_.emvb_threshold_final_);
+                                                      index_options_->emvb_centroid_nprobe_,
+                                                      index_options_->emvb_threshold_first_,
+                                                      index_options_->emvb_n_doc_to_score_,
+                                                      index_options_->emvb_n_doc_out_second_stage_,
+                                                      index_options_->emvb_threshold_final_);
                     for (u32 i = 0; i < result_num; ++i) {
                         function_data.result_handler_->AddResult(0, score_ptr[i], RowID(segment_id, row_id_ptr[i]));
                     }
@@ -427,6 +435,11 @@ void PhysicalMatchTensorScan::ExecuteInner(QueryContext *query_context, MatchTen
             ++output_block_row_id;
         }
         output_block_ptr->Finalize();
+
+        ResultCacheManager *cache_mgr = query_context->storage()->result_cache_manager();
+        if (cache_result_ && cache_mgr != nullptr) {
+            AddCache(query_context, cache_mgr, operator_state->data_block_array_);
+        }
         operator_state->SetComplete();
     }
 }
diff --git a/src/executor/operator/physical_scan/physical_match_tensor_scan.cppm b/src/executor/operator/physical_scan/physical_match_tensor_scan.cppm
index fac99d8c9e..a03eed63db 100644
--- a/src/executor/operator/physical_scan/physical_match_tensor_scan.cppm
+++ b/src/executor/operator/physical_scan/physical_match_tensor_scan.cppm
@@ -44,7 +44,7 @@ public:
                                      SharedPtr<MatchTensorExpression> match_tensor_expression,
                                      const SharedPtr<CommonQueryFilter> &common_query_filter,
                                      u32 topn,
-                                     const MatchTensorScanIndexOptions &index_options,
+                                     const SharedPtr<MatchTensorScanIndexOptions> &index_options,
                                      SharedPtr<Vector<LoadMeta>> load_metas);
 
     void Init() override;
@@ -65,24 +65,19 @@ public:
 
     SizeT TaskletCount() override;
 
-    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
-        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
-    }
-
     [[nodiscard]] inline String TableAlias() const { return base_table_ref_->alias_; }
 
     [[nodiscard]] inline TableEntry *table_collection_ptr() const { return base_table_ref_->table_entry_ptr_; }
 
-    [[nodiscard]] inline u64 table_index() const { return table_index_; }
-
-    [[nodiscard]] inline MatchTensorExpression *match_tensor_expr() const { return src_match_tensor_expr_.get(); }
+    [[nodiscard]] inline const SharedPtr<MatchTensorExpression> &match_tensor_expr() const { return src_match_tensor_expr_; }
 
     [[nodiscard]] inline const CommonQueryFilter *common_query_filter() const { return common_query_filter_.get(); }
 
     [[nodiscard]] inline u32 GetTopN() const { return topn_; }
 
+    const SharedPtr<MatchTensorScanIndexOptions> &index_options() const { return index_options_; }
+
 private:
-    u64 table_index_ = 0;
     SharedPtr<MatchTensorExpression> src_match_tensor_expr_;
 
     // real MatchTensorExpression used in calculation
@@ -92,7 +87,7 @@ private:
 
     // extra options from match_tensor_expr_
     u32 topn_ = 0;
-    MatchTensorScanIndexOptions index_options_;
+    SharedPtr<MatchTensorScanIndexOptions> index_options_;
 
     // column to search
     ColumnID search_column_id_ = 0;
diff --git a/src/executor/operator/physical_scan/physical_merge_knn.cppm b/src/executor/operator/physical_scan/physical_merge_knn.cppm
index ad3ae437cd..de95b0600c 100644
--- a/src/executor/operator/physical_scan/physical_merge_knn.cppm
+++ b/src/executor/operator/physical_scan/physical_merge_knn.cppm
@@ -43,11 +43,13 @@ public:
                               SharedPtr<Vector<String>> output_names,
                               SharedPtr<Vector<SharedPtr<DataType>>> output_types,
                               SharedPtr<KnnExpression> knn_expr,
+                              SharedPtr<BaseExpression> filter_expression,
                               u64 knn_table_index,
-                              SharedPtr<Vector<LoadMeta>> load_metas)
-        : PhysicalScanBase(id, PhysicalOperatorType::kMergeKnn, std::move(left), nullptr, table_ref, load_metas),
-          output_names_(std::move(output_names)), output_types_(std::move(output_types)), knn_table_index_(knn_table_index),
-          knn_expression_(std::move(knn_expr)) {}
+                              SharedPtr<Vector<LoadMeta>> load_metas,
+                              bool cache_result)
+        : PhysicalScanBase(id, PhysicalOperatorType::kMergeKnn, std::move(left), nullptr, knn_table_index, table_ref, load_metas, cache_result),
+          output_names_(std::move(output_names)), output_types_(std::move(output_types)), knn_expression_(std::move(knn_expr)),
+          filter_expression_(std::move(filter_expression)) {}
 
     ~PhysicalMergeKnn() override = default;
 
@@ -65,8 +67,6 @@ public:
         return 0;
     }
 
-    inline u64 knn_table_index() const { return knn_table_index_; }
-
     inline bool IsKnnMinHeap() const { return knn_expression_->IsKnnMinHeap(); }
 
 private:
@@ -76,10 +76,10 @@ private:
 private:
     SharedPtr<Vector<String>> output_names_{};
     SharedPtr<Vector<SharedPtr<DataType>>> output_types_{};
-    u64 knn_table_index_{};
 
 public:
     SharedPtr<KnnExpression> knn_expression_{};
+    SharedPtr<BaseExpression> filter_expression_{};
 };
 
 } // namespace infinity
diff --git a/src/executor/operator/physical_scan/physical_merge_match_sparse.cpp b/src/executor/operator/physical_scan/physical_merge_match_sparse.cpp
index 2f9829b283..ed1a14b852 100644
--- a/src/executor/operator/physical_scan/physical_merge_match_sparse.cpp
+++ b/src/executor/operator/physical_scan/physical_merge_match_sparse.cpp
@@ -38,6 +38,7 @@ import logical_type;
 import knn_result_handler;
 import merge_knn;
 import match_sparse_scan_function_data;
+import result_cache_manager;
 
 namespace infinity {
 
@@ -46,9 +47,11 @@ PhysicalMergeMatchSparse::PhysicalMergeMatchSparse(u64 id,
                                                    u64 table_index,
                                                    SharedPtr<BaseTableRef> base_table_ref,
                                                    SharedPtr<MatchSparseExpression> match_sparse_expr,
-                                                   SharedPtr<Vector<LoadMeta>> load_metas)
-    : PhysicalScanBase(id, PhysicalOperatorType::kMergeMatchSparse, std::move(left), nullptr, base_table_ref, load_metas), table_index_(table_index),
-      match_sparse_expr_(std::move(match_sparse_expr)) {}
+                                                   SharedPtr<BaseExpression> filter_expression,
+                                                   SharedPtr<Vector<LoadMeta>> load_metas,
+                                                   bool cache_result)
+    : PhysicalScanBase(id, PhysicalOperatorType::kMergeMatchSparse, std::move(left), nullptr, table_index, base_table_ref, load_metas, cache_result),
+      match_sparse_expr_(std::move(match_sparse_expr)), filter_expression_(std::move(filter_expression)) {}
 
 void PhysicalMergeMatchSparse::Init() { left_->Init(); }
 
diff --git a/src/executor/operator/physical_scan/physical_merge_match_sparse.cppm b/src/executor/operator/physical_scan/physical_merge_match_sparse.cppm
index d40463d0e3..e42abd6079 100644
--- a/src/executor/operator/physical_scan/physical_merge_match_sparse.cppm
+++ b/src/executor/operator/physical_scan/physical_merge_match_sparse.cppm
@@ -26,6 +26,7 @@ import base_table_ref;
 import data_type;
 import physical_scan_base;
 import match_sparse_expr;
+import base_expression;
 
 namespace infinity {
 struct LoadMeta;
@@ -37,7 +38,9 @@ public:
                              u64 table_index,
                              SharedPtr<BaseTableRef> base_table_ref,
                              SharedPtr<MatchSparseExpression> match_sparse_expr,
-                             SharedPtr<Vector<LoadMeta>> load_metas);
+                             SharedPtr<BaseExpression> filter_expression,
+                             SharedPtr<Vector<LoadMeta>> load_metas,
+                             bool cache_result);
 
     void Init() override;
 
@@ -49,6 +52,12 @@ public:
 
     SizeT TaskletCount() override;
 
+    const SharedPtr<MatchSparseExpression> &match_sparse_expr() const { return match_sparse_expr_; }
+
+    const SharedPtr<BaseExpression> &filter_expression() const { return filter_expression_; }
+
+    i64 GetTopN() const { return match_sparse_expr_->topn_; }
+
 private:
     template <template <typename, typename> typename C>
     void ExecuteInner(QueryContext *query_context, MergeMatchSparseOperatorState *operator_state);
@@ -57,8 +66,8 @@ private:
     void ExecuteInner(QueryContext *query_context, MergeMatchSparseOperatorState *operator_state);
 
 private:
-    u64 table_index_ = 0;
     SharedPtr<MatchSparseExpression> match_sparse_expr_;
+    SharedPtr<BaseExpression> filter_expression_{};
 };
 
 } // namespace infinity
diff --git a/src/executor/operator/physical_scan/physical_merge_match_tensor.cpp b/src/executor/operator/physical_scan/physical_merge_match_tensor.cpp
index 68b9c30861..90eb5c1583 100644
--- a/src/executor/operator/physical_scan/physical_merge_match_tensor.cpp
+++ b/src/executor/operator/physical_scan/physical_merge_match_tensor.cpp
@@ -30,6 +30,8 @@ import default_values;
 import data_block;
 import value;
 import column_vector;
+import cached_match_scan;
+import result_cache_manager;
 
 namespace infinity {
 
@@ -58,10 +60,14 @@ PhysicalMergeMatchTensor::PhysicalMergeMatchTensor(const u64 id,
                                                    const u64 table_index,
                                                    SharedPtr<BaseTableRef> base_table_ref,
                                                    SharedPtr<MatchTensorExpression> match_tensor_expr,
+                                                   SharedPtr<BaseExpression> filter_expression,
                                                    const u32 topn,
-                                                   SharedPtr<Vector<LoadMeta>> load_metas)
-    : PhysicalOperator(PhysicalOperatorType::kMergeMatchTensor, std::move(left), nullptr, id, load_metas), table_index_(table_index),
-      base_table_ref_(std::move(base_table_ref)), match_tensor_expr_(std::move(match_tensor_expr)), topn_(topn) {}
+                                                   const SharedPtr<MatchTensorScanIndexOptions> &index_options,
+                                                   SharedPtr<Vector<LoadMeta>> load_metas,
+                                                   bool cache_result)
+    : PhysicalOperator(PhysicalOperatorType::kMergeMatchTensor, std::move(left), nullptr, id, load_metas, cache_result), table_index_(table_index),
+      base_table_ref_(std::move(base_table_ref)), match_tensor_expr_(std::move(match_tensor_expr)), filter_expression_(std::move(filter_expression)),
+      topn_(topn), index_options_(index_options) {}
 
 void PhysicalMergeMatchTensor::Init() { left()->Init(); }
 
@@ -175,6 +181,30 @@ void PhysicalMergeMatchTensor::ExecuteInner(QueryContext *query_context, MergeMa
             output_data_block_array.push_back(std::move(data_block));
         }
         operator_state->SetComplete();
+
+        ResultCacheManager *cache_mgr = query_context->storage()->result_cache_manager();
+        if (cache_result_ && cache_mgr != nullptr) {
+            AddCache(query_context, cache_mgr, operator_state->data_block_array_);
+        }
+    }
+}
+
+void PhysicalMergeMatchTensor::AddCache(QueryContext *query_context,
+                                        ResultCacheManager *cache_mgr,
+                                        const Vector<UniquePtr<DataBlock>> &output_data_blocks) const {
+    Txn *txn = query_context->GetTxn();
+    TableEntry *table_entry = base_table_ref_->table_entry_ptr_;
+    TxnTimeStamp query_ts = std::min(txn->BeginTS(), table_entry->max_commit_ts());
+    Vector<UniquePtr<DataBlock>> data_blocks(output_data_blocks.size());
+    for (SizeT i = 0; i < output_data_blocks.size(); ++i) {
+        data_blocks[i] = output_data_blocks[i]->Clone();
+    }
+    auto cached_node = MakeUnique<CachedMatchTensorScan>(query_ts, this);
+    bool success = cache_mgr->AddCache(std::move(cached_node), std::move(data_blocks));
+    if (!success) {
+        LOG_WARN(fmt::format("Add cache failed for query: {}", txn->BeginTS()));
+    } else {
+        LOG_INFO(fmt::format("Add cache success for query: {}", txn->BeginTS()));
     }
 }
 
diff --git a/src/executor/operator/physical_scan/physical_merge_match_tensor.cppm b/src/executor/operator/physical_scan/physical_merge_match_tensor.cppm
index 05a58f294e..349cc5600a 100644
--- a/src/executor/operator/physical_scan/physical_merge_match_tensor.cppm
+++ b/src/executor/operator/physical_scan/physical_merge_match_tensor.cppm
@@ -24,9 +24,14 @@ import table_entry;
 import match_tensor_expression;
 import base_table_ref;
 import data_type;
+import base_expression;
+import logical_match_tensor_scan;
 
 namespace infinity {
+
 struct LoadMeta;
+class ResultCacheManager;
+class DataBlock;
 
 export class PhysicalMergeMatchTensor final : public PhysicalOperator {
 public:
@@ -35,8 +40,11 @@ public:
                              u64 table_index,
                              SharedPtr<BaseTableRef> base_table_ref,
                              SharedPtr<MatchTensorExpression> match_tensor_expr,
+                             SharedPtr<BaseExpression> filter_expression,
                              u32 topn,
-                             SharedPtr<Vector<LoadMeta>> load_metas);
+                             const SharedPtr<MatchTensorScanIndexOptions> &index_options,
+                             SharedPtr<Vector<LoadMeta>> load_metas,
+                             bool cache_result);
 
     void Init() override;
 
@@ -58,17 +66,27 @@ public:
 
     [[nodiscard]] inline u64 table_index() const { return table_index_; }
 
-    [[nodiscard]] inline MatchTensorExpression *match_tensor_expr() const { return match_tensor_expr_.get(); }
+    [[nodiscard]] inline const BaseTableRef *base_table_ref() const { return base_table_ref_.get(); }
+
+    [[nodiscard]] inline const SharedPtr<MatchTensorExpression> &match_tensor_expr() const { return match_tensor_expr_; }
+
+    [[nodiscard]] inline const SharedPtr<BaseExpression> &filter_expression() const { return filter_expression_; }
 
     [[nodiscard]] inline u32 GetTopN() const { return topn_; }
 
+    const SharedPtr<MatchTensorScanIndexOptions> &index_options() const { return index_options_; }
+
+    void AddCache(QueryContext *query_context, ResultCacheManager *cache_mgr, const Vector<UniquePtr<DataBlock>> &output_data_blocks) const;
+
 private:
     u64 table_index_ = 0;
     SharedPtr<BaseTableRef> base_table_ref_;
     SharedPtr<MatchTensorExpression> match_tensor_expr_;
+    SharedPtr<BaseExpression> filter_expression_{};
     // extra options
     // inited by Init()
     u32 topn_ = 0;
+    SharedPtr<MatchTensorScanIndexOptions> index_options_;
 
     void ExecuteInner(QueryContext *query_context, MergeMatchTensorOperatorState *operator_state) const;
 };
diff --git a/src/executor/operator/physical_scan/physical_scan_base.cpp b/src/executor/operator/physical_scan/physical_scan_base.cpp
index 47037095da..c0ae54f118 100644
--- a/src/executor/operator/physical_scan/physical_scan_base.cpp
+++ b/src/executor/operator/physical_scan/physical_scan_base.cpp
@@ -35,6 +35,18 @@ import block_column_entry;
 import logger;
 import column_vector;
 import query_context;
+import txn;
+import cached_node_base;
+import cached_match_scan;
+import cached_index_scan;
+import physical_knn_scan;
+import physical_match_sparse_scan;
+import physical_match_tensor_scan;
+import physical_merge_knn;
+import physical_merge_match_sparse;
+import physical_merge_match_tensor;
+import physical_index_scan;
+import result_cache_manager;
 
 namespace infinity {
 
@@ -55,7 +67,7 @@ Vector<SharedPtr<Vector<GlobalBlockID>>> PhysicalScanBase::PlanBlockEntries(i64
     Vector<SharedPtr<Vector<GlobalBlockID>>> result(parallel_count, nullptr);
     for (SizeT task_id = 0, global_block_id = 0, residual_idx = 0; (i64)task_id < parallel_count; ++task_id) {
         result[task_id] = MakeShared<Vector<GlobalBlockID>>();
-        auto& task_result = result[task_id];
+        auto &task_result = result[task_id];
         task_result->reserve(block_per_task);
 
         for (u64 block_id_in_task = 0; block_id_in_task < block_per_task; ++block_id_in_task) {
@@ -136,6 +148,63 @@ void PhysicalScanBase::SetOutput(const Vector<char *> &raw_result_dists_list,
         }
     }
     output_block_ptr->Finalize();
+
+    ResultCacheManager *cache_mgr = query_context->storage()->result_cache_manager();
+    if (cache_result_ && cache_mgr != nullptr) {
+        AddCache(query_context, cache_mgr, operator_state->data_block_array_);
+    }
+}
+
+void PhysicalScanBase::AddCache(QueryContext *query_context,
+                                ResultCacheManager *cache_mgr,
+                                const Vector<UniquePtr<DataBlock>> &output_data_blocks) const {
+    Txn *txn = query_context->GetTxn();
+    TableEntry *table_entry = base_table_ref_->table_entry_ptr_;
+    TxnTimeStamp query_ts = std::min(txn->BeginTS(), table_entry->max_commit_ts());
+    Vector<UniquePtr<DataBlock>> data_blocks(output_data_blocks.size());
+    for (SizeT i = 0; i < output_data_blocks.size(); ++i) {
+        data_blocks[i] = output_data_blocks[i]->Clone();
+        if (data_blocks[i].get() == nullptr) {
+            data_blocks.resize(i);
+            break;
+        }
+    }
+    UniquePtr<CachedNodeBase> cached_node;
+    switch (operator_type_) {
+        case PhysicalOperatorType::kKnnScan: {
+            cached_node = MakeUnique<CachedKnnScan>(query_ts, static_cast<const PhysicalKnnScan *>(this));
+            break;
+        }
+        case PhysicalOperatorType::kMergeKnn: {
+            cached_node = MakeUnique<CachedKnnScan>(query_ts, static_cast<const PhysicalMergeKnn *>(this));
+            break;
+        }
+        case PhysicalOperatorType::kMatchSparseScan: {
+            cached_node = MakeUnique<CachedMatchSparseScan>(query_ts, static_cast<const PhysicalMatchSparseScan *>(this));
+            break;
+        }
+        case PhysicalOperatorType::kMergeMatchSparse: {
+            cached_node = MakeUnique<CachedMatchSparseScan>(query_ts, static_cast<const PhysicalMergeMatchSparse *>(this));
+            break;
+        }
+        case PhysicalOperatorType::kMatchTensorScan: {
+            cached_node = MakeUnique<CachedMatchTensorScan>(query_ts, static_cast<const PhysicalMatchTensorScan *>(this));
+            break;
+        }
+        case PhysicalOperatorType::kIndexScan: {
+            cached_node = MakeUnique<CachedIndexScan>(query_ts, static_cast<const PhysicalIndexScan *>(this));
+            break;
+        }
+        default: {
+            UnrecoverableError("Unsupported operator type for cache");
+        }
+    }
+    bool success = cache_mgr->AddCache(std::move(cached_node), std::move(data_blocks));
+    if (!success) {
+        LOG_WARN(fmt::format("Add cache failed for query: {}", txn->BeginTS()));
+    } else {
+        LOG_INFO(fmt::format("Add cache success for query: {}", txn->BeginTS()));
+    }
 }
 
 } // namespace infinity
diff --git a/src/executor/operator/physical_scan/physical_scan_base.cppm b/src/executor/operator/physical_scan/physical_scan_base.cppm
index 6b0eb84967..d311080afc 100644
--- a/src/executor/operator/physical_scan/physical_scan_base.cppm
+++ b/src/executor/operator/physical_scan/physical_scan_base.cppm
@@ -26,18 +26,25 @@ import load_meta;
 import internal_types;
 import operator_state;
 import query_context;
+import table_entry;
 
 namespace infinity {
 
+class ResultCacheManager;
+class DataBlock;
+
 export class PhysicalScanBase : public PhysicalOperator {
 public:
     PhysicalScanBase(const u64 id,
                      const PhysicalOperatorType type,
                      UniquePtr<PhysicalOperator> left,
                      UniquePtr<PhysicalOperator> right,
+                     u64 table_index,
                      SharedPtr<BaseTableRef> base_table_ref,
-                     SharedPtr<Vector<LoadMeta>> load_metas)
-        : PhysicalOperator(type, std::move(left), std::move(right), id, std::move(load_metas)), base_table_ref_(std::move(base_table_ref)) {}
+                     SharedPtr<Vector<LoadMeta>> load_metas,
+                     bool cache_result = false)
+        : PhysicalOperator(type, std::move(left), std::move(right), id, std::move(load_metas), cache_result), table_index_(table_index),
+          base_table_ref_(std::move(base_table_ref)) {}
 
     virtual Vector<SharedPtr<Vector<GlobalBlockID>>> PlanBlockEntries(i64 parallel_count) const;
 
@@ -45,6 +52,16 @@ public:
 
     virtual BlockIndex *GetBlockIndex() const;
 
+    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
+        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
+    }
+
+    u64 table_index() const { return table_index_; }
+
+    [[nodiscard]] inline String TableAlias() const { return base_table_ref_->alias_; }
+
+    [[nodiscard]] inline TableEntry *table_collection_ptr() const { return base_table_ref_->table_entry_ptr_; }
+
 protected:
     void SetOutput(const Vector<char *> &raw_result_dists_list,
                    const Vector<RowID *> &row_ids_list,
@@ -53,7 +70,10 @@ protected:
                    QueryContext *query_context,
                    OperatorState *operator_state);
 
+    void AddCache(QueryContext *query_context, ResultCacheManager *cache_mgr, const Vector<UniquePtr<DataBlock>> &output_data_blocks) const;
+
 public:
+    u64 table_index_ = 0;
     SharedPtr<BaseTableRef> base_table_ref_{};
 };
 
diff --git a/src/executor/operator/physical_scan/physical_table_scan.cppm b/src/executor/operator/physical_scan/physical_table_scan.cppm
index 87f50dc50b..2ecb38460e 100644
--- a/src/executor/operator/physical_scan/physical_table_scan.cppm
+++ b/src/executor/operator/physical_scan/physical_table_scan.cppm
@@ -42,7 +42,7 @@ public:
                                UniquePtr<FastRoughFilterEvaluator> &&fast_rough_filter_evaluator,
                                SharedPtr<Vector<LoadMeta>> load_metas,
                                bool add_row_id = false)
-        : PhysicalScanBase(id, PhysicalOperatorType::kTableScan, nullptr, nullptr, base_table_ref, load_metas),
+        : PhysicalScanBase(id, PhysicalOperatorType::kTableScan, nullptr, nullptr, 0, base_table_ref, load_metas),
           fast_rough_filter_evaluator_(std::move(fast_rough_filter_evaluator)), add_row_id_(add_row_id) {}
 
     ~PhysicalTableScan() override = default;
@@ -69,10 +69,6 @@ public:
 
     bool IsExchange() const override { return true; }
 
-    void FillingTableRefs(HashMap<SizeT, SharedPtr<BaseTableRef>> &table_refs) override {
-        table_refs.insert({base_table_ref_->table_index_, base_table_ref_});
-    }
-
 private:
     void ExecuteInternal(QueryContext *query_context, TableScanOperatorState *table_scan_operator_state);
 
diff --git a/src/executor/operator/physical_sink.cpp b/src/executor/operator/physical_sink.cpp
index 070f44d239..363eeebcff 100644
--- a/src/executor/operator/physical_sink.cpp
+++ b/src/executor/operator/physical_sink.cpp
@@ -169,6 +169,23 @@ void PhysicalSink::FillSinkStateFromLastOperatorState(MaterializeSinkState *mate
             }
             break;
         }
+        case PhysicalOperatorType::kReadCache: {
+            auto *read_cache_state = static_cast<ReadCacheState *>(task_op_state);
+            if (read_cache_state->data_block_array_.empty()) {
+                if (materialize_sink_state->Error()) {
+                    materialize_sink_state->empty_result_ = true;
+                } else {
+                    String error_message = "Empty read cache output";
+                    UnrecoverableError(error_message);
+                }
+            } else {
+                for (auto &data_block : read_cache_state->data_block_array_) {
+                    materialize_sink_state->data_block_array_.emplace_back(std::move(data_block));
+                }
+                read_cache_state->data_block_array_.clear();
+            }
+            break;
+        }
         default: {
             Status status = Status::NotSupport(fmt::format("{} isn't supported here.", PhysicalOperatorToString(task_op_state->operator_type_)));
             RecoverableError(status);
diff --git a/src/executor/physical_operator.cpp b/src/executor/physical_operator.cpp
index 89131069e0..88af55f544 100644
--- a/src/executor/physical_operator.cpp
+++ b/src/executor/physical_operator.cpp
@@ -31,8 +31,12 @@ import block_entry;
 import block_column_entry;
 import logical_type;
 import internal_types;
-
+import result_cache_manager;
 import logger;
+import data_block;
+import txn;
+import table_entry;
+import cached_match;
 
 namespace infinity {
 
diff --git a/src/executor/physical_operator.cppm b/src/executor/physical_operator.cppm
index 5a5511c9c9..71c79f688c 100644
--- a/src/executor/physical_operator.cppm
+++ b/src/executor/physical_operator.cppm
@@ -75,6 +75,8 @@ public:
 
     bool cache_result() const { return cache_result_; }
 
+    void SetCacheResult(bool cache_result) { cache_result_ = cache_result; }
+
 protected:
     u64 operator_id_;
     PhysicalOperatorType operator_type_{PhysicalOperatorType::kInvalid};
diff --git a/src/executor/physical_planner.cpp b/src/executor/physical_planner.cpp
index 0bbb4709cf..1831c1a11f 100644
--- a/src/executor/physical_planner.cpp
+++ b/src/executor/physical_planner.cpp
@@ -920,7 +920,8 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildIndexScan(const SharedPtr<Logi
                                          logical_operator->load_metas(),
                                          logical_operator->GetOutputNames(),
                                          logical_operator->GetOutputTypes(),
-                                         logical_index_scan->add_row_id_);
+                                         logical_index_scan->add_row_id_,
+                                         true);
 }
 
 UniquePtr<PhysicalOperator> PhysicalPlanner::BuildViewScan(const SharedPtr<LogicalNode> &logical_operator) const {
@@ -975,11 +976,12 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildMatchTensorScan(const SharedPt
                                             std::static_pointer_cast<MatchTensorExpression>(logical_match_tensor->query_expression_),
                                             logical_match_tensor->common_query_filter_,
                                             logical_match_tensor->topn_,
-                                            *logical_match_tensor->index_options_,
+                                            logical_match_tensor->index_options_,
                                             logical_operator->load_metas());
     match_tensor_scan_op->CheckColumn();
     match_tensor_scan_op->PlanWithIndex(query_context_ptr_);
     if (match_tensor_scan_op->TaskletCount() == 1) {
+        match_tensor_scan_op->SetCacheResult(true);
         return match_tensor_scan_op;
     } else {
         return MakeUnique<PhysicalMergeMatchTensor>(query_context_ptr_->GetNextNodeID(),
@@ -987,8 +989,11 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildMatchTensorScan(const SharedPt
                                                     logical_match_tensor->TableIndex(),
                                                     logical_match_tensor->base_table_ref_,
                                                     std::static_pointer_cast<MatchTensorExpression>(logical_match_tensor->query_expression_),
+                                                    logical_match_tensor->common_query_filter_->original_filter_,
                                                     logical_match_tensor->topn_,
-                                                    MakeShared<Vector<LoadMeta>>());
+                                                    logical_match_tensor->index_options_,
+                                                    MakeShared<Vector<LoadMeta>>(),
+                                                    true);
     }
 }
 
@@ -1002,6 +1007,7 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildMatchSparseScan(const SharedPt
                                             logical_match_sparse->common_query_filter_,
                                             logical_operator->load_metas());
     if (match_sparse_scan_op->GetTaskletCount(query_context_ptr_) == 1) {
+        match_sparse_scan_op->SetCacheResult(true);
         return match_sparse_scan_op;
     }
     auto merge_match_sparse_op =
@@ -1010,7 +1016,9 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildMatchSparseScan(const SharedPt
                                              logical_match_sparse->TableIndex(),
                                              logical_match_sparse->base_table_ref_,
                                              std::static_pointer_cast<MatchSparseExpression>(logical_match_sparse->query_expression_),
-                                             MakeShared<Vector<LoadMeta>>());
+                                             logical_match_sparse->common_query_filter_->original_filter_,
+                                             MakeShared<Vector<LoadMeta>>(),
+                                             true);
     return merge_match_sparse_op;
 }
 
@@ -1051,6 +1059,7 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildKnn(const SharedPtr<LogicalNod
 
     knn_scan_op->PlanWithIndex(query_context_ptr_);
     if (knn_scan_op->TaskletCount() == 1) {
+        knn_scan_op->SetCacheResult(true);
         return knn_scan_op;
     } else {
         return MakeUnique<PhysicalMergeKnn>(query_context_ptr_->GetNextNodeID(),
@@ -1059,8 +1068,10 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildKnn(const SharedPtr<LogicalNod
                                             logical_knn_scan->GetOutputNames(),
                                             logical_knn_scan->GetOutputTypes(),
                                             logical_knn_scan->knn_expression(),
+                                            logical_knn_scan->common_query_filter_->original_filter_,
                                             logical_knn_scan->knn_table_index_,
-                                            MakeShared<Vector<LoadMeta>>());
+                                            MakeShared<Vector<LoadMeta>>(),
+                                            true);
     }
 }
 
@@ -1162,10 +1173,12 @@ UniquePtr<PhysicalOperator> PhysicalPlanner::BuildCompactFinish(const SharedPtr<
 UniquePtr<PhysicalOperator> PhysicalPlanner::BuildReadCache(const SharedPtr<LogicalNode> &logical_operator) const {
     const auto *logical_read_cache = static_cast<LogicalReadCache *>(logical_operator.get());
     return MakeUnique<PhysicalReadCache>(logical_read_cache->node_id(),
+                                         logical_read_cache->origin_type_,
                                          logical_read_cache->base_table_ref_,
                                          logical_read_cache->cache_content_,
                                          logical_read_cache->column_map_,
-                                         logical_read_cache->load_metas());
+                                         logical_read_cache->load_metas(),
+                                         logical_read_cache->is_min_heap_);
 }
 
 UniquePtr<PhysicalOperator> PhysicalPlanner::BuildExplain(const SharedPtr<LogicalNode> &logical_operator) const {
diff --git a/src/expression/base_expression.cppm b/src/expression/base_expression.cppm
index b41cb5831c..589e69fcfb 100644
--- a/src/expression/base_expression.cppm
+++ b/src/expression/base_expression.cppm
@@ -21,6 +21,8 @@ import stl;
 import expression_type;
 import data_type;
 import internal_types;
+import infinity_exception;
+import third_party;
 
 namespace infinity {
 
@@ -70,6 +72,16 @@ public:
 
     [[nodiscard]] virtual String ToString() const = 0;
 
+    virtual u64 Hash() const {
+        UnrecoverableError(fmt::format("Not implemented {}'s Hash", int(type_)));
+        return 0;
+    }
+
+    virtual bool Eq(const BaseExpression &other) const {
+        UnrecoverableError(fmt::format("Not implemented {}'s Eq", int(type_)));
+        return false;
+    }
+
 protected:
     ExpressionType type_{};
     Vector<SharedPtr<BaseExpression>> arguments_{};
diff --git a/src/expression/cast_expression.cpp b/src/expression/cast_expression.cpp
index 35730ee4cf..6aaab3e948 100644
--- a/src/expression/cast_expression.cpp
+++ b/src/expression/cast_expression.cpp
@@ -169,4 +169,19 @@ bool CastExpression::CanCast(const DataType &source, const DataType &target) {
 
 String CastExpression::ToString() const { return fmt::format("Cast({} AS {})", arguments_[0]->Name(), target_type_.ToString()); }
 
+u64 CastExpression::Hash() const {
+    u64 h = 0;
+    h ^= std::hash<SizeT>() (reinterpret_cast<SizeT>(func_.function));
+    h ^= arguments_[0]->Hash();
+    return h;
+}
+
+bool CastExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kCast) {
+        return false;
+    }
+    const auto &other = static_cast<const CastExpression &>(other_base);
+    return func_.function == other.func_.function && arguments_[0]->Eq(*other.arguments_[0]);
+}
+
 } // namespace infinity
diff --git a/src/expression/cast_expression.cppm b/src/expression/cast_expression.cppm
index 3b74119ca9..ec9885013b 100644
--- a/src/expression/cast_expression.cppm
+++ b/src/expression/cast_expression.cppm
@@ -42,6 +42,10 @@ public:
 
     BoundCastFunc func_;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 private:
     DataType target_type_;
 };
diff --git a/src/expression/column_expression.cpp b/src/expression/column_expression.cpp
index d8046c52d7..506fdeadbe 100644
--- a/src/expression/column_expression.cpp
+++ b/src/expression/column_expression.cpp
@@ -58,4 +58,23 @@ String ColumnExpression::ToString() const {
     }
 }
 
+u64 ColumnExpression::Hash() const {
+    u64 h = 0;
+    h ^= std::hash<String>()(table_name_);
+    h ^= std::hash<String>()(column_name_);
+    return h;
+}
+
+bool ColumnExpression::Eq(const BaseExpression &other) const {
+    if (other.type() != ExpressionType::kColumn) {
+        return false;
+    }
+    const auto &other_column = static_cast<const ColumnExpression &>(other);
+    bool eq = table_name_ == other_column.table_name_ && column_name_ == other_column.column_name_;
+    if (!eq) {
+        return false;
+    }
+    return true;
+}
+
 } // namespace infinity
diff --git a/src/expression/column_expression.cppm b/src/expression/column_expression.cppm
index b7b287a4f6..f365b24b82 100644
--- a/src/expression/column_expression.cppm
+++ b/src/expression/column_expression.cppm
@@ -72,6 +72,10 @@ public:
 
     inline Optional<SpecialType> special() const { return special_; }
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 private:
     String ToString() const final;
 
diff --git a/src/expression/filter_fulltext_expression.cpp b/src/expression/filter_fulltext_expression.cpp
index 2ffb2eba8f..fa3745c82a 100644
--- a/src/expression/filter_fulltext_expression.cpp
+++ b/src/expression/filter_fulltext_expression.cpp
@@ -63,4 +63,20 @@ SharedPtr<FilterFulltextExpression> FilterFulltextExpression::BuildFilterFulltex
     return MakeShared<FilterFulltextExpression>(std::move(fields), std::move(matching_text), std::move(options_text));
 }
 
+u64 FilterFulltextExpression::Hash() const {
+    u64 h = 0;
+    h ^= std::hash<String>()(fields_);
+    h ^= std::hash<String>()(matching_text_);
+    h ^= std::hash<String>()(options_text_);
+    return h;
+}
+
+bool FilterFulltextExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kFilterFullText) {
+        return false;
+    }
+    const auto &other = static_cast<const FilterFulltextExpression &>(other_base);
+    return fields_ == other.fields_ && matching_text_ == other.matching_text_ && options_text_ == other.options_text_;
+}
+
 } // namespace infinity
diff --git a/src/expression/filter_fulltext_expression.cppm b/src/expression/filter_fulltext_expression.cppm
index a5771d3f05..c1d8cae406 100644
--- a/src/expression/filter_fulltext_expression.cppm
+++ b/src/expression/filter_fulltext_expression.cppm
@@ -35,6 +35,10 @@ public:
 
     DataType Type() const override;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other_base) const override;
+
     String fields_;
     String matching_text_;
     String options_text_;
diff --git a/src/expression/function_expression.cpp b/src/expression/function_expression.cpp
index 2b4d6bee99..9355ee1294 100644
--- a/src/expression/function_expression.cpp
+++ b/src/expression/function_expression.cpp
@@ -58,4 +58,33 @@ String FunctionExpression::ToString() const {
     return ss.str();
 }
 
+u64 FunctionExpression::Hash() const {
+    u64 h = 0;
+
+    h ^= func_.Hash();
+    for (const auto &arg : arguments_) {
+        h ^= arg->Hash();
+    }
+    return h;
+}
+
+bool FunctionExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kFunction) {
+        return false;
+    }
+    const auto &other = static_cast<const FunctionExpression &>(other_base);
+    if (!func_.Eq(other.func_)) {
+        return false;
+    }
+    if (arguments_.size() != other.arguments_.size()) {
+        return false;
+    }
+    for (SizeT i = 0; i < arguments_.size(); ++i) {
+        if (!arguments_[i]->Eq(*other.arguments_[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
 } // namespace infinity
diff --git a/src/expression/function_expression.cppm b/src/expression/function_expression.cppm
index e08b73a916..eff26e7009 100644
--- a/src/expression/function_expression.cppm
+++ b/src/expression/function_expression.cppm
@@ -34,6 +34,10 @@ public:
 
     String ToString() const override;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 public:
     ScalarFunction func_;
 };
diff --git a/src/expression/knn_expression.cpp b/src/expression/knn_expression.cpp
index 049f77e815..8892c9bdb3 100644
--- a/src/expression/knn_expression.cpp
+++ b/src/expression/knn_expression.cpp
@@ -86,4 +86,37 @@ String KnnExpression::ToString() const {
     return expr_str;
 }
 
+u64 KnnExpression::Hash() const {
+    u64 h = 0;
+    h = std::hash<i64>()(dimension_);
+    h ^= std::hash<EmbeddingDataType>()(embedding_data_type_);
+    h ^= std::hash<KnnDistanceType>()(distance_type_);
+    h ^= std::hash<i32>()(topn_);
+    h ^= std::hash<String>()(using_index_);
+    if (optional_filter_) {
+        h ^= optional_filter_->Hash();
+    }
+    return h;
+}
+
+bool KnnExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kKnn) {
+        return false;
+    }
+    const auto &other = static_cast<const KnnExpression &>(other_base);
+    bool eq = dimension_ == other.dimension_ && embedding_data_type_ == other.embedding_data_type_ && distance_type_ == other.distance_type_ &&
+              query_embedding_.Eq(other.query_embedding_, embedding_data_type_, dimension_) && topn_ == other.topn_ &&
+              opt_params_ == other.opt_params_ && using_index_ == other.using_index_ && ignore_index_ == other.ignore_index_;
+    if (!eq) {
+        return false;
+    }
+    if (optional_filter_ && other.optional_filter_) {
+        return optional_filter_->Eq(*other.optional_filter_);
+    }
+    if (bool(optional_filter_) ^ bool(other.optional_filter_)) {
+        return false;
+    }
+    return true;
+}
+
 } // namespace infinity
diff --git a/src/expression/knn_expression.cppm b/src/expression/knn_expression.cppm
index 791719c321..dabb4961f1 100644
--- a/src/expression/knn_expression.cppm
+++ b/src/expression/knn_expression.cppm
@@ -60,11 +60,15 @@ public:
         }
     }
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 public:
     const i64 dimension_{0};
     const EmbeddingDataType embedding_data_type_{EmbeddingDataType::kElemInvalid};
     const KnnDistanceType distance_type_{KnnDistanceType::kInvalid};
-    const EmbeddingT query_embedding_;
+    EmbeddingT query_embedding_;
     const i64 topn_;
     Vector<InitParameter> opt_params_;
     const String using_index_;
diff --git a/src/expression/match_expression.cpp b/src/expression/match_expression.cpp
index d189abae45..c5e4297ad9 100644
--- a/src/expression/match_expression.cpp
+++ b/src/expression/match_expression.cpp
@@ -40,4 +40,21 @@ String MatchExpression::ToString() const {
     return expr_str;
 }
 
+u64 MatchExpression::Hash() const {
+    u64 h = 0;
+    h ^= std::hash<String>()(fields_);
+    h ^= std::hash<String>()(matching_text_);
+    h ^= std::hash<String>()(options_text_);
+    return h;
+}
+
+bool MatchExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kMatch) {
+        return false;
+    }
+    const auto &other = static_cast<const MatchExpression &>(other_base);
+    bool eq = fields_ == other.fields_ && matching_text_ == other.matching_text_ && options_text_ == other.options_text_;
+    return eq;
+}
+
 } // namespace infinity
diff --git a/src/expression/match_expression.cppm b/src/expression/match_expression.cppm
index 962d81af05..9819843545 100644
--- a/src/expression/match_expression.cppm
+++ b/src/expression/match_expression.cppm
@@ -32,6 +32,10 @@ public:
 
     String ToString() const override;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 public:
     String fields_;
     String matching_text_;
diff --git a/src/expression/match_sparse_expression.cpp b/src/expression/match_sparse_expression.cpp
index a7e8e72fc6..dc51f06bf4 100644
--- a/src/expression/match_sparse_expression.cpp
+++ b/src/expression/match_sparse_expression.cpp
@@ -42,10 +42,10 @@ MatchSparseExpression::MatchSparseExpression(Vector<SharedPtr<BaseExpression>> s
                                              SparseMetricType metric_type,
                                              SizeT query_n,
                                              SizeT topn,
-                                             const Vector<UniquePtr<InitParameter>> &opt_params,
+                                             Vector<UniquePtr<InitParameter>> opt_params,
                                              SharedPtr<BaseExpression> optional_filter)
     : BaseExpression(ExpressionType::kMatchSparse, std::move(search_column)), metric_type_(metric_type), query_n_(query_n), topn_(topn),
-      opt_params_(opt_params), optional_filter_(std::move(optional_filter)) {
+      opt_params_(std::move(opt_params)), optional_filter_(std::move(optional_filter)) {
     column_expr_ = static_cast<const ColumnExpression *>(arguments_[0].get());
     this->MakeQuery(query_sparse_expr);
 }
@@ -93,6 +93,51 @@ DataType MatchSparseExpression::Type() const {
     return DataType(LogicalType::kInvalid);
 }
 
+u64 MatchSparseExpression::Hash() const {
+    u64 h = 0;
+    for (const auto &arg : arguments_) {
+        h ^= arg->Hash();
+    }
+    h ^= column_expr_->Hash();
+    h ^= query_sparse_expr_->Hash();
+    h ^= std::hash<SparseMetricType>()(metric_type_);
+    h ^= std::hash<SizeT>()(query_n_);
+    h ^= std::hash<SizeT>()(topn_);
+    if (optional_filter_) {
+        h ^= optional_filter_->Hash();
+    }
+    return h;
+}
+
+bool MatchSparseExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kMatchSparse) {
+        return false;
+    }
+    const auto &other = static_cast<const MatchSparseExpression &>(other_base);
+    if (arguments_.size() != other.arguments_.size()) {
+        return false;
+    }
+    for (size_t i = 0; i < arguments_.size(); ++i) {
+        if (!arguments_[i]->Eq(*other.arguments_[i])) {
+            return false;
+        }
+    }
+    bool eq = column_expr_->Eq(*other.column_expr_) && query_sparse_expr_->Eq(*other.query_sparse_expr_) && metric_type_ == other.metric_type_ &&
+              query_n_ == other.query_n_ && topn_ == other.topn_;
+    if (!eq) {
+        return false;
+    }
+    if (opt_params_.size() != other.opt_params_.size()) {
+        return false;
+    }
+    for (size_t i = 0; i < opt_params_.size(); ++i) {
+        if (*(opt_params_[i]) != *(other.opt_params_[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void MatchSparseExpression::MakeQuery(SharedPtr<BaseExpression> query_sparse_expr) {
     const auto &column_type = column_expr_->Type();
     BoundCastFunc cast = CastFunction::GetBoundFunc(query_sparse_expr->Type(), column_type);
diff --git a/src/expression/match_sparse_expression.cppm b/src/expression/match_sparse_expression.cppm
index e1740ccc21..12687e11d4 100644
--- a/src/expression/match_sparse_expression.cppm
+++ b/src/expression/match_sparse_expression.cppm
@@ -37,13 +37,17 @@ public:
                           SparseMetricType metric_type,
                           SizeT query_n,
                           SizeT topn,
-                          const Vector<UniquePtr<InitParameter>> &opt_params,
+                          Vector<UniquePtr<InitParameter>> opt_params,
                           SharedPtr<BaseExpression> optional_filter);
 
     DataType Type() const override;
 
     String ToString() const override;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 private:
     void MakeQuery(SharedPtr<BaseExpression> query_sparse_expr);
 
@@ -55,7 +59,7 @@ public:
     SizeT query_n_;
     SizeT topn_;
 
-    const Vector<UniquePtr<InitParameter>> &opt_params_;
+    Vector<UniquePtr<InitParameter>> opt_params_;
 
     SharedPtr<BaseExpression> optional_filter_;
 };
diff --git a/src/expression/match_tensor_expression.cpp b/src/expression/match_tensor_expression.cpp
index f82486023f..a2b9c5293e 100644
--- a/src/expression/match_tensor_expression.cpp
+++ b/src/expression/match_tensor_expression.cpp
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 module;
+#include<vector>
 
 module match_tensor_expression;
 
@@ -59,4 +60,37 @@ String MatchTensorExpression::ToString() const {
     return fmt::format("MATCH TENSOR ({}, {}, {}{}{})", column_expr_->Name(), tensor_str, MethodToString(search_method_), options_str, filter_str);
 }
 
+u64 MatchTensorExpression::Hash() const {
+    u64 h = 0;
+    for (const auto &arg : arguments_) {
+        h ^= arg->Hash();
+    }
+    h ^= std::hash<MatchTensorSearchMethod>()(search_method_);
+    h ^= column_expr_->Hash();
+    h ^= std::hash<EmbeddingDataType>()(embedding_data_type_);
+    h ^= std::hash<u32>()(dimension_);
+    h ^= std::hash<u32>()(tensor_basic_embedding_dimension_);
+    h ^= std::hash<String>()(options_text_);
+    return h;
+}
+
+bool MatchTensorExpression::Eq(const BaseExpression &other_base) const {
+    if (other_base.type() != ExpressionType::kMatchTensor) {
+        return false;
+    }
+    const auto &other = static_cast<const MatchTensorExpression &>(other_base);
+    if (arguments_.size() != other.arguments_.size()) {
+        return false;
+    }
+    for (SizeT i = 0; i < arguments_.size(); ++i) {
+        if (!arguments_[i]->Eq(*other.arguments_[i])) {
+            return false;
+        }
+    }
+    bool eq = search_method_ == other.search_method_ && column_expr_->Eq(*other.column_expr_) && embedding_data_type_ == other.embedding_data_type_ &&
+              dimension_ == other.dimension_ && query_embedding_.Eq(other.query_embedding_, embedding_data_type_, dimension_) &&
+              tensor_basic_embedding_dimension_ == other.tensor_basic_embedding_dimension_ && options_text_ == other.options_text_;
+    return eq;
+}
+
 } // namespace infinity
diff --git a/src/expression/match_tensor_expression.cppm b/src/expression/match_tensor_expression.cppm
index ad155db047..31d4b5123b 100644
--- a/src/expression/match_tensor_expression.cppm
+++ b/src/expression/match_tensor_expression.cppm
@@ -44,11 +44,15 @@ public:
 
     static String MethodToString(MatchTensorSearchMethod method);
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
     const MatchTensorSearchMethod search_method_;
     const ColumnExpression *column_expr_ = nullptr;
     const EmbeddingDataType embedding_data_type_;
     const u32 dimension_;                        // num of total elements in the tensor (num of embedding * dimension of single embedding)
-    const EmbeddingT query_embedding_;           // treat the query tensor as an embedding here
+    EmbeddingT query_embedding_;           // treat the query tensor as an embedding here
     const u32 tensor_basic_embedding_dimension_; // dimension of single embedding in the tensor column
     const u32 num_of_embedding_in_query_tensor_ = dimension_ / tensor_basic_embedding_dimension_;
     const String options_text_;
diff --git a/src/expression/reference_expression.cpp b/src/expression/reference_expression.cpp
index f585bfcd70..8bec1e2253 100644
--- a/src/expression/reference_expression.cpp
+++ b/src/expression/reference_expression.cpp
@@ -45,4 +45,22 @@ String ReferenceExpression::ToString() const {
     }
 }
 
+u64 ReferenceExpression::Hash() const {
+    u64 h = 0;
+    h ^= std::hash<String>{}(table_name_);
+    h ^= std::hash<String>{}(column_name_);
+    h ^= std::hash<SizeT>{}(column_index_);
+    return h;
+}
+
+bool ReferenceExpression::Eq(const BaseExpression &other) const {
+    if (other.type() != ExpressionType::kReference) {
+        return false;
+    }
+
+    const ReferenceExpression &other_ref = static_cast<const ReferenceExpression &>(other);
+    return data_type_ == other_ref.data_type_ && table_name_ == other_ref.table_name_ && column_name_ == other_ref.column_name_ &&
+           column_index_ == other_ref.column_index_;
+}
+
 } // namespace infinity
\ No newline at end of file
diff --git a/src/expression/reference_expression.cppm b/src/expression/reference_expression.cppm
index 82038aeae7..819e418199 100644
--- a/src/expression/reference_expression.cppm
+++ b/src/expression/reference_expression.cppm
@@ -41,6 +41,10 @@ public:
 
     String ToString() const override;
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 private:
     DataType data_type_;
 
diff --git a/src/expression/value_expression.cpp b/src/expression/value_expression.cpp
index 89b3bd9cc1..73709130b8 100644
--- a/src/expression/value_expression.cpp
+++ b/src/expression/value_expression.cpp
@@ -15,6 +15,7 @@
 module;
 
 import stl;
+import expression_type;
 
 module value_expression;
 
@@ -22,4 +23,14 @@ namespace infinity {
 
 String ValueExpression::ToString() const { return value_.ToString(); }
 
+u64 ValueExpression::Hash() const { return 0; }
+
+bool ValueExpression::Eq(const BaseExpression &other_base) const { 
+    if (other_base.type() != ExpressionType::kValue) {
+        return false;
+    }
+    const auto &other = static_cast<const ValueExpression &>(other_base);
+    return value_ == other.value_;
+}
+
 } // namespace infinity
diff --git a/src/expression/value_expression.cppm b/src/expression/value_expression.cppm
index aba2574b19..8eeea54c60 100644
--- a/src/expression/value_expression.cppm
+++ b/src/expression/value_expression.cppm
@@ -40,6 +40,10 @@ public:
 
     const Value &GetValue() const { return value_; }
 
+    u64 Hash() const override;
+
+    bool Eq(const BaseExpression &other) const override;
+
 private:
     Value value_;
 };
diff --git a/src/function/scalar_function.cpp b/src/function/scalar_function.cpp
index 9ea0226bc2..2ccc9c56d6 100644
--- a/src/function/scalar_function.cpp
+++ b/src/function/scalar_function.cpp
@@ -30,7 +30,7 @@ import logger;
 
 namespace infinity {
 
-ScalarFunction::ScalarFunction(String name, Vector<DataType> argument_types, DataType return_type, ScalarFunctionType function)
+ScalarFunction::ScalarFunction(String name, Vector<DataType> argument_types, DataType return_type, ScalarFunctionTypePtr function)
     : Function(std::move(name), FunctionType::kScalar), parameter_types_(std::move(argument_types)), return_type_(std::move(return_type)),
       function_(std::move(function)) {}
 
@@ -76,4 +76,8 @@ String ScalarFunction::ToString() const {
     return ss.str();
 }
 
+u64 ScalarFunction::Hash() const { return std::hash<SizeT>()(reinterpret_cast<SizeT>(function_)); }
+
+bool ScalarFunction::Eq(const ScalarFunction &other) const { return function_ == other.function_; }
+
 } // namespace infinity
diff --git a/src/function/scalar_function.cppm b/src/function/scalar_function.cppm
index 32503dfa2a..1d5a8915b6 100644
--- a/src/function/scalar_function.cppm
+++ b/src/function/scalar_function.cppm
@@ -225,11 +225,11 @@ struct TernaryTryOpVarlenToVarlenWrapper {
 };
 
 
-using ScalarFunctionType = std::function<void(const DataBlock &, SharedPtr<ColumnVector> &)>;
+using ScalarFunctionTypePtr = void (*)(const DataBlock &, SharedPtr<ColumnVector> &);
 
 export class ScalarFunction final : public Function {
 public:
-    explicit ScalarFunction(String name, Vector<DataType> argument_types, DataType return_type, ScalarFunctionType function);
+    explicit ScalarFunction(String name, Vector<DataType> argument_types, DataType return_type, ScalarFunctionTypePtr function);
 
     void CastArgumentTypes(Vector<BaseExpression> &input_arguments);
 
@@ -237,11 +237,15 @@ public:
 
     [[nodiscard]] String ToString() const final;
 
+    u64 Hash() const;
+
+    bool Eq(const ScalarFunction &other) const;
+
 public:
     Vector<DataType> parameter_types_{};
     DataType return_type_;
 
-    ScalarFunctionType function_{};
+    ScalarFunctionTypePtr function_{};
 
 public:
     // Unary function
diff --git a/src/main/config.cpp b/src/main/config.cpp
index 4f2828cea6..3467098559 100644
--- a/src/main/config.cpp
+++ b/src/main/config.cpp
@@ -421,6 +421,23 @@ Status Config::Init(const SharedPtr<String> &config_path, DefaultConfig *default
             UnrecoverableError(status.message());
         }
 
+        // Result Cache Mode
+        String result_cache_mode(DEFAULT_RESULT_CACHE_MODE);
+        auto result_cache_mode_option = MakeUnique<StringOption>(RESULT_CACHE_MODE_OPTION_NAME, result_cache_mode);
+        status = global_options_.AddOption(std::move(result_cache_mode_option));
+        if(!status.ok()) {
+            fmt::print("Fatal: {}", status.message());
+            UnrecoverableError(status.message());
+        }
+
+        i64 cache_result_num = DEFAULT_CACHE_RESULT_NUM;
+        auto cache_result_num_option = MakeUnique<IntegerOption>(CACHE_RESULT_NUM_OPTION_NAME, cache_result_num, std::numeric_limits<i64>::max(), 0);
+        status = global_options_.AddOption(std::move(cache_result_num_option));
+        if(!status.ok()) {
+            fmt::print("Fatal: {}", status.message());
+            UnrecoverableError(status.message());
+        }
+
         // Temp Dir
         String temp_dir = "/var/infinity/tmp";
         if(default_config != nullptr) {
@@ -1646,6 +1663,28 @@ Status Config::Init(const SharedPtr<String> &config_path, DefaultConfig *default
                             global_options_.AddOption(std::move(mem_index_memory_quota_option));
                             break;
                         }
+                        case GlobalOptionIndex::kResultCacheMode: {
+                            String result_cache_mode_str(DEFAULT_RESULT_CACHE_MODE);
+                            if (elem.second.is_string()) {
+                                result_cache_mode_str = elem.second.value_or(result_cache_mode_str);
+                            } else {
+                                return Status::InvalidConfig("'result_cache_mode' field isn't string.");
+                            }
+                            auto result_cache_mode_option = MakeUnique<StringOption>(RESULT_CACHE_MODE_OPTION_NAME, result_cache_mode_str);
+                            global_options_.AddOption(std::move(result_cache_mode_option));
+                            break;
+                        }
+                        case GlobalOptionIndex::kCacheResultNum: {
+                            i64 cache_result_num = DEFAULT_CACHE_RESULT_NUM;
+                            if (elem.second.is_integer()) {
+                                cache_result_num = elem.second.value_or(cache_result_num);
+                            } else {
+                                return Status::InvalidConfig("'cache_result_num' field isn't integer.");
+                            }
+                            auto cache_result_num_option = MakeUnique<IntegerOption>(CACHE_RESULT_NUM_OPTION_NAME, cache_result_num, std::numeric_limits<i64>::max(), 0);
+                            global_options_.AddOption(std::move(cache_result_num_option));
+                            break;
+                        }
                         default: {
                             return Status::InvalidConfig(fmt::format("Unrecognized config parameter: {} in 'buffer' field", var_name));
                         }
@@ -1691,6 +1730,24 @@ Status Config::Init(const SharedPtr<String> &config_path, DefaultConfig *default
                         UnrecoverableError(status.message());
                     }
                 }
+                if (global_options_.GetOptionByIndex(GlobalOptionIndex::kResultCacheMode) == nullptr) {
+                    // Result Cache Mode
+                    String result_cache_mode_str(DEFAULT_RESULT_CACHE_MODE);
+                    UniquePtr<StringOption> result_cache_mode_option = MakeUnique<StringOption>(RESULT_CACHE_MODE_OPTION_NAME, result_cache_mode_str);
+                    Status status = global_options_.AddOption(std::move(result_cache_mode_option));
+                    if(!status.ok()) {
+                        UnrecoverableError(status.message());
+                    }
+                }
+                
+                if (global_options_.GetOptionByIndex(GlobalOptionIndex::kCacheResultNum) == nullptr) {
+                    i64 cache_result_num = DEFAULT_CACHE_RESULT_NUM;
+                    UniquePtr<IntegerOption> cache_result_num_option = MakeUnique<IntegerOption>(CACHE_RESULT_NUM_OPTION_NAME, cache_result_num, std::numeric_limits<i64>::max(), 0);
+                    Status status = global_options_.AddOption(std::move(cache_result_num_option));
+                    if(!status.ok()) {
+                        UnrecoverableError(status.message());
+                    }
+                }
 
             } else {
                 return Status::InvalidConfig("No 'buffer' section in configure file.");
@@ -2267,6 +2324,27 @@ i64 Config::MemIndexMemoryQuota() {
     return global_options_.GetIntegerValue(GlobalOptionIndex::kMemIndexMemoryQuota);
 }
 
+String Config::ResultCacheMode() {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return global_options_.GetStringValue(GlobalOptionIndex::kResultCacheMode);
+}
+
+i64 Config::CacheResultNum() {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return global_options_.GetIntegerValue(GlobalOptionIndex::kCacheResultNum);
+}
+
+void Config::SetCacheResult(const String &mode) {
+    std::lock_guard<std::mutex> guard(mutex_);
+    BaseOption *base_option = global_options_.GetOptionByIndex(GlobalOptionIndex::kResultCacheMode);
+    if (base_option->data_type_ != BaseOptionDataType::kString) {
+        String error_message = "Attempt to set string value to result cache mode data type option";
+        UnrecoverableError(error_message);
+    }
+    StringOption *result_cache_mode_option = static_cast<StringOption *>(base_option);
+    result_cache_mode_option->value_ = mode;
+}
+
 // WAL
 String Config::WALDir() {
     std::lock_guard<std::mutex> guard(mutex_);
diff --git a/src/main/config.cppm b/src/main/config.cppm
index 2568f1aac3..d00aa06d43 100644
--- a/src/main/config.cppm
+++ b/src/main/config.cppm
@@ -112,6 +112,10 @@ public:
 
     i64 MemIndexMemoryQuota();
 
+    String ResultCacheMode();
+    i64 CacheResultNum();
+    void SetCacheResult(const String &mode);
+
     // WAL
     String WALDir();
 
diff --git a/src/main/options.cpp b/src/main/options.cpp
index ff3c06e51f..6900d70568 100644
--- a/src/main/options.cpp
+++ b/src/main/options.cpp
@@ -72,6 +72,9 @@ GlobalOptions::GlobalOptions() {
     name2index_[String(TEMP_DIR_OPTION_NAME)] = GlobalOptionIndex::kTempDir;
     name2index_[String(MEMINDEX_MEMORY_QUOTA_OPTION_NAME)] = GlobalOptionIndex::kMemIndexMemoryQuota;
 
+    name2index_[String(RESULT_CACHE_MODE_OPTION_NAME)] = GlobalOptionIndex::kResultCacheMode;
+    name2index_[String(CACHE_RESULT_NUM_OPTION_NAME)] = GlobalOptionIndex::kCacheResultNum;
+
     name2index_[String(WAL_DIR_OPTION_NAME)] = GlobalOptionIndex::kWALDir;
     name2index_[String(WAL_COMPACT_THRESHOLD_OPTION_NAME)] = GlobalOptionIndex::kWALCompactThreshold;
     name2index_[String(FULL_CHECKPOINT_INTERVAL_OPTION_NAME)] = GlobalOptionIndex::kFullCheckpointInterval;
diff --git a/src/main/options.cppm b/src/main/options.cppm
index bc509ffcd8..57253ed45b 100644
--- a/src/main/options.cppm
+++ b/src/main/options.cppm
@@ -147,19 +147,21 @@ export enum class GlobalOptionIndex : i8 {
     kPersistenceDir = 31,
     kPersistenceObjectSizeLimit = 32,
     kMemIndexMemoryQuota = 33,
-    kServerMode = 34,
-    kPeerServerIP = 35,
-    kPeerServerPort = 36,
-    kPeerServerConnectionPoolSize = 37,
-    kStorageType = 38,
-    kObjectStorage = 39,
-    kObjectStorageUrl = 40,
-    kObjectStorageBucket = 41,
-    kObjectStorageAccessKey = 42,
-    kObjectStorageSecretKey = 43,
-    kObjectStorageHttps = 44,
-
-    kInvalid = 45,
+    kResultCacheMode = 34,
+    kCacheResultNum = 35,
+    kServerMode = 36,
+    kPeerServerIP = 37,
+    kPeerServerPort = 38,
+    kPeerServerConnectionPoolSize = 39,
+    kStorageType = 40,
+    kObjectStorage = 41,
+    kObjectStorageUrl = 42,
+    kObjectStorageBucket = 43,
+    kObjectStorageAccessKey = 44,
+    kObjectStorageSecretKey = 45,
+    kObjectStorageHttps = 46,
+
+    kInvalid = 47,
 };
 
 export struct GlobalOptions {
diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp
index dbb6029cc7..d7b1330738 100644
--- a/src/parser/parser.cpp
+++ b/src/parser/parser.cpp
@@ -5346,7 +5346,7 @@ YYLTYPE yylloc = yyloc_default;
         yyerror(&yyloc, scanner, result, "Offset expression isn't valid without Limit expression");
         YYERROR;
     }
-    if((yyvsp[-3].select_stmt)->search_expr_ != nullptr and ((yyvsp[-2].order_by_expr_list_t) != nullptr or (yyvsp[-1].expr_t) != nullptr or (yyvsp[0].expr_t) != nullptr)) {
+    if((yyvsp[-3].select_stmt)->search_expr_ != nullptr and ((yyvsp[-2].order_by_expr_list_t) != nullptr /*or $3 != nullptr or $4 != nullptr*/)) {
         delete (yyvsp[-3].select_stmt);
         if ((yyvsp[-2].order_by_expr_list_t)) {
             for (auto ptr : *((yyvsp[-2].order_by_expr_list_t))) {
@@ -5356,7 +5356,7 @@ YYLTYPE yylloc = yyloc_default;
         }
         delete (yyvsp[-1].expr_t);
         delete (yyvsp[0].expr_t);
-        yyerror(&yyloc, scanner, result, "Result modifier(ORDER BY, LIMIT, OFFSET) is conflict with SEARCH expression.");
+        yyerror(&yyloc, scanner, result, "Result modifier(ORDER BY) is conflict with SEARCH expression.");
         YYERROR;
     }
     (yyvsp[-3].select_stmt)->order_by_list = (yyvsp[-2].order_by_expr_list_t);
diff --git a/src/parser/parser.y b/src/parser/parser.y
index da95f2cf25..bd253e454c 100644
--- a/src/parser/parser.y
+++ b/src/parser/parser.y
@@ -1546,7 +1546,7 @@ select_clause_with_modifier: select_clause_without_modifier order_by_clause limi
         yyerror(&yyloc, scanner, result, "Offset expression isn't valid without Limit expression");
         YYERROR;
     }
-    if($1->search_expr_ != nullptr and ($2 != nullptr or $3 != nullptr or $4 != nullptr)) {
+    if($1->search_expr_ != nullptr and ($2 != nullptr /*or $3 != nullptr or $4 != nullptr*/)) {
         delete $1;
         if ($2) {
             for (auto ptr : *($2)) {
@@ -1556,7 +1556,7 @@ select_clause_with_modifier: select_clause_without_modifier order_by_clause limi
         }
         delete $3;
         delete $4;
-        yyerror(&yyloc, scanner, result, "Result modifier(ORDER BY, LIMIT, OFFSET) is conflict with SEARCH expression.");
+        yyerror(&yyloc, scanner, result, "Result modifier(ORDER BY) is conflict with SEARCH expression.");
         YYERROR;
     }
     $1->order_by_list = $2;
diff --git a/src/parser/statement/statement_common.h b/src/parser/statement/statement_common.h
index 38905044d2..0e3172ddc3 100644
--- a/src/parser/statement/statement_common.h
+++ b/src/parser/statement/statement_common.h
@@ -91,6 +91,10 @@ struct InitParameter {
         delete init_params;
         return results;
     }
+
+    bool operator==(const InitParameter &other) const {
+        return param_name_ == other.param_name_ && param_value_ == other.param_value_;
+    }
 };
 
 struct IfExistsInfo {
diff --git a/src/parser/type/complex/embedding_type.h b/src/parser/type/complex/embedding_type.h
index dc4785b6b2..fef13a1194 100644
--- a/src/parser/type/complex/embedding_type.h
+++ b/src/parser/type/complex/embedding_type.h
@@ -101,10 +101,21 @@ inline EmbeddingDataType ToEmbeddingDataType<bfloat16_t>() {
 struct EmbeddingType {
 public:
     char *ptr{};
-    const bool new_allocated_{};
+        bool new_allocated_{};
 
     static size_t embedding_type_width[];
 
+    void Own(EmbeddingDataType type, size_t dimension) {
+        if (new_allocated_) {
+            return;
+        }
+        size_t mem_size = EmbeddingSize(type, dimension);
+        char *new_ptr = new char[mem_size];
+        std::memcpy(new_ptr, ptr, mem_size);
+        ptr = new_ptr;
+        new_allocated_ = true;
+    }
+
 public:
     static inline size_t EmbeddingDataWidth(EmbeddingDataType type_index) { return embedding_type_width[to_underlying_val(type_index)]; }
 
@@ -291,6 +302,10 @@ struct EmbeddingType {
         ParserError("ToString() isn't implemented");
         return std::string();
     }
+
+    bool Eq(const EmbeddingType &other, EmbeddingDataType type, size_t dimension) const {
+        return std::memcmp(ptr, other.ptr, EmbeddingSize(type, dimension)) == 0;
+    }
 };
 
 } // namespace infinity
diff --git a/src/planner/cached_node/cached_index_scan.cpp b/src/planner/cached_node/cached_index_scan.cpp
new file mode 100644
index 0000000000..eb2a86007b
--- /dev/null
+++ b/src/planner/cached_node/cached_index_scan.cpp
@@ -0,0 +1,50 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+module;
+
+module cached_index_scan;
+
+import logical_index_scan;
+import physical_index_scan;
+import logical_node_type;
+
+namespace infinity {
+
+CachedIndexScan::CachedIndexScan(TxnTimeStamp query_ts, const LogicalIndexScan *logical_index_scan)
+    : CachedScanBase(logical_index_scan->operator_type(), logical_index_scan->base_table_ref_.get(), query_ts, logical_index_scan->GetOutputNames()),
+      filter_expression_(logical_index_scan->index_filter_) {}
+
+CachedIndexScan::CachedIndexScan(TxnTimeStamp query_ts, const PhysicalIndexScan *physical_index_scan)
+    : CachedScanBase(LogicalNodeType::kIndexScan, physical_index_scan, query_ts), filter_expression_(physical_index_scan->FilterExpression()) {}
+
+u64 CachedIndexScan::Hash() const {
+    u64 h = 0;
+    h ^= CachedScanBase::Hash();
+    h ^= filter_expression_->Hash();
+    return h;
+}
+
+bool CachedIndexScan::Eq(const CachedNodeBase &other_base) const {
+    if (!CachedScanBase::Eq(other_base)) {
+        return false;
+    }
+    if (type() != other_base.type()) {
+        return false;
+    }
+    const auto &other = static_cast<const CachedIndexScan &>(other_base);
+    return filter_expression_->Eq(*other.filter_expression_);
+}
+
+} // namespace infinity
diff --git a/src/planner/cached_node/cached_index_scan.cppm b/src/planner/cached_node/cached_index_scan.cppm
new file mode 100644
index 0000000000..68d0755142
--- /dev/null
+++ b/src/planner/cached_node/cached_index_scan.cppm
@@ -0,0 +1,42 @@
+//  Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+module;
+
+export module cached_index_scan;
+
+import stl;
+import cached_scan_base;
+import base_expression;
+
+namespace infinity {
+
+class LogicalIndexScan;
+class PhysicalIndexScan;
+
+export class CachedIndexScan final : public CachedScanBase {
+public:
+    CachedIndexScan(TxnTimeStamp query_ts, const LogicalIndexScan *logical_index_scan);
+
+    CachedIndexScan(TxnTimeStamp query_ts, const PhysicalIndexScan *physical_index_scan);
+
+    u64 Hash() const override;
+
+    bool Eq(const CachedNodeBase &other) const override;
+
+private:
+    SharedPtr<BaseExpression> filter_expression_;
+};
+
+}
diff --git a/src/planner/cached_node/cached_match.cpp b/src/planner/cached_node/cached_match.cpp
index 80398c3051..0718771e48 100644
--- a/src/planner/cached_node/cached_match.cpp
+++ b/src/planner/cached_node/cached_match.cpp
@@ -26,26 +26,26 @@ import physical_match;
 namespace infinity {
 
 CachedMatch::CachedMatch(TxnTimeStamp query_ts, LogicalMatch *logical_match)
-    : CachedMatchBase(LogicalNodeType::kMatch,
-                      logical_match->base_table_ref_->schema_name(),
-                      logical_match->base_table_ref_->table_name(),
-                      logical_match->base_table_ref_->column_ids_,
+    : CachedScanBase(LogicalNodeType::kMatch,
+                      logical_match->base_table_ref_.get(),
                       query_ts,
                       logical_match->GetOutputNames()),
       match_expr_(logical_match->match_expr_), filter_expression_(logical_match->filter_expression_), topn_(logical_match->top_n_) {}
 
 CachedMatch::CachedMatch(TxnTimeStamp query_ts, PhysicalMatch *physical_match)
-    : CachedMatchBase(LogicalNodeType::kMatch,
-                      physical_match->base_table_ref()->schema_name(),
-                      physical_match->base_table_ref()->table_name(),
-                      physical_match->base_table_ref()->column_ids_,
+    : CachedScanBase(LogicalNodeType::kMatch,
+                      physical_match->base_table_ref().get(),
                       query_ts,
                       physical_match->GetOutputNames()),
       match_expr_(physical_match->match_expr()), filter_expression_(physical_match->filter_expression()), topn_(physical_match->top_n()) {}
 
 u64 CachedMatch::Hash() const {
-    u64 h = CachedMatchBase::Hash();
-    // TODO
+    u64 h = CachedScanBase::Hash();
+    h ^= match_expr_->Hash();
+    h ^= std::hash<u32>()(topn_);
+    if (filter_expression_) {
+        h ^= filter_expression_->Hash();
+    }
     return h;
 }
 
@@ -54,11 +54,21 @@ bool CachedMatch::Eq(const CachedNodeBase &other_base) const {
         return false;
     }
     const auto &other = static_cast<const CachedMatch &>(other_base);
-    bool cached = CachedMatchBase::Equal(other);
-    if (!cached) {
+    if (!CachedScanBase::Eq(other)) {
+        return false;
+    }
+    if (!match_expr_->Eq(*other.match_expr_)) {
+        return false;
+    }
+    if (topn_ != other.topn_) {
+        return false;
+    }
+    if (filter_expression_ && other.filter_expression_) {
+        return filter_expression_->Eq(*other.filter_expression_);
+    }
+    if (filter_expression_ || other.filter_expression_) {
         return false;
     }
-    // TODO
     return true;
 }
 
diff --git a/src/planner/cached_node/cached_match.cppm b/src/planner/cached_node/cached_match.cppm
index 1eb1f33e03..3fad99d549 100644
--- a/src/planner/cached_node/cached_match.cppm
+++ b/src/planner/cached_node/cached_match.cppm
@@ -18,7 +18,7 @@ export module cached_match;
 
 import stl;
 import cached_node_base;
-import cached_match_base;
+import cached_scan_base;
 import logical_node_type;
 
 namespace infinity {
@@ -29,7 +29,7 @@ class BaseExpression;
 class LogicalMatch;
 class PhysicalMatch;
 
-export class CachedMatch : public CachedMatchBase {
+export class CachedMatch final : public CachedScanBase {
 public:
     CachedMatch(TxnTimeStamp query_ts, LogicalMatch *logical_match);
 
diff --git a/src/planner/cached_node/cached_match_base.cpp b/src/planner/cached_node/cached_match_base.cpp
deleted file mode 100644
index d547356dcd..0000000000
--- a/src/planner/cached_node/cached_match_base.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-module;
-
-#include <vector>
-
-module cached_match_base;
-
-namespace infinity {
-
-u64 CachedMatchBase::Hash() const {
-    u64 h = CachedNodeBase::Hash();
-    h = h ^ std::hash<String>{}(*schema_name_);
-    h = h ^ std::hash<String>{}(*table_name_);
-    h = h ^ std::hash<TxnTimeStamp>{}(query_ts_);
-    return h;
-}
-
-bool CachedMatchBase::Equal(const CachedMatchBase &other) const {
-    return *schema_name_ == *other.schema_name_ && *table_name_ == *other.table_name_ && query_ts_ == other.query_ts_;
-}
-
-} // namespace infinity
\ No newline at end of file
diff --git a/src/planner/cached_node/cached_match_scan.cpp b/src/planner/cached_node/cached_match_scan.cpp
new file mode 100644
index 0000000000..dd6d5a2357
--- /dev/null
+++ b/src/planner/cached_node/cached_match_scan.cpp
@@ -0,0 +1,145 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+module;
+
+module cached_match_scan;
+
+import logical_match_sparse_scan;
+import logical_match_tensor_scan;
+import logical_node_type;
+import physical_scan_base;
+import physical_knn_scan;
+import physical_match_sparse_scan;
+import physical_match_tensor_scan;
+import physical_merge_knn;
+import physical_merge_match_sparse;
+import physical_merge_match_tensor;
+
+namespace infinity {
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const LogicalMatchScanBase *logical_match_scan)
+    : CachedScanBase(logical_match_scan->operator_type(), logical_match_scan->base_table_ref_.get(), query_ts, logical_match_scan->GetOutputNames()),
+      query_expression_(logical_match_scan->query_expression_), filter_expression_(logical_match_scan->filter_expression_) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalKnnScan *physical_knn_scan)
+    : CachedScanBase(LogicalNodeType::kKnnScan, physical_knn_scan, query_ts), query_expression_(physical_knn_scan->knn_expression_),
+      filter_expression_(physical_knn_scan->common_query_filter_->original_filter_) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMatchSparseScan *physical_sparse_scan)
+    : CachedScanBase(LogicalNodeType::kMatchSparseScan, physical_sparse_scan, query_ts), query_expression_(physical_sparse_scan->match_sparse_expr()),
+      filter_expression_(physical_sparse_scan->common_query_filter_->original_filter_) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMatchTensorScan *physical_tensor_scan)
+    : CachedScanBase(LogicalNodeType::kMatchTensorScan, physical_tensor_scan, query_ts), query_expression_(physical_tensor_scan->match_tensor_expr()),
+      filter_expression_(physical_tensor_scan->common_query_filter()->original_filter_) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeKnn *physical_merge_knn)
+    : CachedScanBase(LogicalNodeType::kKnnScan, physical_merge_knn, query_ts), query_expression_(physical_merge_knn->knn_expression_),
+      filter_expression_(physical_merge_knn->filter_expression_) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeMatchSparse *physical_merge_match_sparse)
+    : CachedScanBase(LogicalNodeType::kMatchSparseScan, physical_merge_match_sparse, query_ts),
+      query_expression_(physical_merge_match_sparse->match_sparse_expr()), filter_expression_(physical_merge_match_sparse->filter_expression()) {}
+
+CachedMatchScanBase::CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeMatchTensor *physical_merge_match_tensor)
+    : CachedScanBase(LogicalNodeType::kMatchTensorScan,
+                     physical_merge_match_tensor->base_table_ref(),
+                     query_ts,
+                     physical_merge_match_tensor->GetOutputNames()),
+      query_expression_(physical_merge_match_tensor->match_tensor_expr()), filter_expression_(physical_merge_match_tensor->filter_expression()) {}
+
+u64 CachedMatchScanBase::Hash() const {
+    u64 h = CachedScanBase::Hash();
+    h ^= query_expression_->Hash();
+    if (filter_expression_) {
+        h ^= filter_expression_->Hash();
+    }
+    return h;
+}
+
+bool CachedMatchScanBase::Eq(const CachedNodeBase &other_base) const {
+    if (type() != other_base.type()) {
+        return false;
+    }
+    const auto &other = static_cast<const CachedMatchScanBase &>(other_base);
+    if (!CachedScanBase::Eq(other)) {
+        return false;
+    }
+    if (!query_expression_->Eq(*other.query_expression_)) {
+        return false;
+    }
+    if (filter_expression_ && other.filter_expression_) {
+        return filter_expression_->Eq(*other.filter_expression_);
+    }
+    if (bool(filter_expression_) ^ bool(other.filter_expression_)) {
+        return false;
+    }
+    return true;
+}
+
+CachedKnnScan::CachedKnnScan(TxnTimeStamp query_ts, const LogicalKnnScan *logical_knn_scan) : CachedMatchScanBase(query_ts, logical_knn_scan) {}
+
+CachedKnnScan::CachedKnnScan(TxnTimeStamp query_ts, const PhysicalKnnScan *physical_knn_scan) : CachedMatchScanBase(query_ts, physical_knn_scan) {
+    auto &expr = physical_knn_scan->knn_expression_;
+    expr->query_embedding_.Own(expr->embedding_data_type_, expr->dimension_);
+}
+
+CachedKnnScan::CachedKnnScan(TxnTimeStamp query_ts, const PhysicalMergeKnn *physical_merge_knn) : CachedMatchScanBase(query_ts, physical_merge_knn) {
+    auto &expr = physical_merge_knn->knn_expression_;
+    expr->query_embedding_.Own(expr->embedding_data_type_, expr->dimension_);
+}
+
+CachedMatchSparseScan::CachedMatchSparseScan(TxnTimeStamp query_ts, const LogicalMatchSparseScan *logical_sparse_scan)
+    : CachedMatchScanBase(query_ts, logical_sparse_scan) {}
+
+CachedMatchSparseScan::CachedMatchSparseScan(TxnTimeStamp query_ts, const PhysicalMatchSparseScan *physical_sparse_scan)
+    : CachedMatchScanBase(query_ts, physical_sparse_scan) {}
+
+CachedMatchSparseScan::CachedMatchSparseScan(TxnTimeStamp query_ts, const PhysicalMergeMatchSparse *physical_merge_match_sparse)
+    : CachedMatchScanBase(query_ts, physical_merge_match_sparse) {}
+
+CachedMatchTensorScan::CachedMatchTensorScan(TxnTimeStamp query_ts, const LogicalMatchTensorScan *logical_tensor_scan)
+    : CachedMatchScanBase(query_ts, logical_tensor_scan), topn_(logical_tensor_scan->topn_), index_options_(logical_tensor_scan->index_options_) {}
+
+CachedMatchTensorScan::CachedMatchTensorScan(TxnTimeStamp query_ts, const PhysicalMatchTensorScan *physical_tensor_scan)
+    : CachedMatchScanBase(query_ts, physical_tensor_scan), topn_(physical_tensor_scan->GetTopN()),
+      index_options_(physical_tensor_scan->index_options()) {
+    auto &expr = physical_tensor_scan->match_tensor_expr();
+    expr->query_embedding_.Own(expr->embedding_data_type_, expr->dimension_);
+}
+
+CachedMatchTensorScan::CachedMatchTensorScan(TxnTimeStamp query_ts, const PhysicalMergeMatchTensor *physical_merge_match_tensor)
+    : CachedMatchScanBase(query_ts, physical_merge_match_tensor), topn_(physical_merge_match_tensor->GetTopN()),
+      index_options_(physical_merge_match_tensor->index_options()) {
+    auto &expr = physical_merge_match_tensor->match_tensor_expr();
+    expr->query_embedding_.Own(expr->embedding_data_type_, expr->dimension_);
+}
+
+u64 CachedMatchTensorScan::Hash() const {
+    u64 h = 0;
+    h ^= CachedMatchScanBase::Hash();
+    h ^= std::hash<u32>()(topn_);
+    return h;
+}
+
+bool CachedMatchTensorScan::Eq(const CachedNodeBase &other) const {
+    if (!CachedMatchScanBase::Eq(other)) {
+        return false;
+    }
+    const auto &other_tensor = static_cast<const CachedMatchTensorScan &>(other);
+    return topn_ == other_tensor.topn_ && *index_options_ == *other_tensor.index_options_;
+}
+
+} // namespace infinity
diff --git a/src/planner/cached_node/cached_match_scan.cppm b/src/planner/cached_node/cached_match_scan.cppm
new file mode 100644
index 0000000000..856f286773
--- /dev/null
+++ b/src/planner/cached_node/cached_match_scan.cppm
@@ -0,0 +1,99 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+module;
+
+export module cached_match_scan;
+
+import stl;
+import cached_scan_base;
+import logical_match_scan_base;
+import physical_filter_scan_base;
+import base_expression;
+import logical_match_tensor_scan;
+
+namespace infinity {
+
+class LogicalKnnScan;
+class PhysicalKnnScan;
+class LogicalMatchSparseScan;
+class PhysicalMatchSparseScan;
+class PhysicalMatchTensorScan;
+class PhysicalMergeKnn;
+class PhysicalMergeMatchSparse;
+class PhysicalMergeMatchTensor;
+
+export class CachedMatchScanBase : public CachedScanBase {
+public:
+    CachedMatchScanBase(TxnTimeStamp query_ts, const LogicalMatchScanBase *logical_match_scan);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalKnnScan *physical_knn_scan);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMatchSparseScan *physical_sparse_scan);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMatchTensorScan *physical_tensor_scan);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeKnn *physical_merge_knn);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeMatchSparse *physical_merge_match_sparse);
+
+    CachedMatchScanBase(TxnTimeStamp query_ts, const PhysicalMergeMatchTensor *physical_merge_match_tensor);
+
+    u64 Hash() const override;
+
+    bool Eq(const CachedNodeBase &other) const override;
+
+    const BaseExpression *query_expression() const { return query_expression_.get(); }
+
+private:
+    SharedPtr<BaseExpression> query_expression_{};
+    SharedPtr<BaseExpression> filter_expression_{};
+};
+
+export class CachedKnnScan final : public CachedMatchScanBase {
+public:
+    CachedKnnScan(TxnTimeStamp query_ts, const LogicalKnnScan *logical_knn_scan);
+
+    CachedKnnScan(TxnTimeStamp query_ts, const PhysicalKnnScan *physical_knn_scan);
+
+    CachedKnnScan(TxnTimeStamp query_ts, const PhysicalMergeKnn *physical_merge_knn);
+};
+
+export class CachedMatchSparseScan final : public CachedMatchScanBase {
+public:
+    CachedMatchSparseScan(TxnTimeStamp query_ts, const LogicalMatchSparseScan *logical_sparse_scan);
+
+    CachedMatchSparseScan(TxnTimeStamp query_ts, const PhysicalMatchSparseScan *physical_sparse_scan);
+
+    CachedMatchSparseScan(TxnTimeStamp query_ts, const PhysicalMergeMatchSparse *physical_merge_match_sparse);
+};
+
+export class CachedMatchTensorScan final : public CachedMatchScanBase {
+public:
+    CachedMatchTensorScan(TxnTimeStamp query_ts, const LogicalMatchTensorScan *logical_tensor_scan);
+
+    CachedMatchTensorScan(TxnTimeStamp query_ts, const PhysicalMatchTensorScan *physical_tensor_scan);
+
+    CachedMatchTensorScan(TxnTimeStamp query_ts, const PhysicalMergeMatchTensor *physical_merge_match_tensor);
+
+    u64 Hash() const override;
+
+    bool Eq(const CachedNodeBase &other) const override;
+
+private:
+    u32 topn_;
+    SharedPtr<MatchTensorScanIndexOptions> index_options_;
+};
+
+} // namespace infinity
diff --git a/src/planner/cached_node/cached_node_base.cppm b/src/planner/cached_node/cached_node_base.cppm
index a961a1e1a7..9b2ee94ce9 100644
--- a/src/planner/cached_node/cached_node_base.cppm
+++ b/src/planner/cached_node/cached_node_base.cppm
@@ -33,7 +33,7 @@ public:
         return h;
     }
 
-    virtual bool Eq(const CachedNodeBase &other) const = 0;
+    virtual bool Eq(const CachedNodeBase &other) const { return type_ == other.type_; }
 
     LogicalNodeType type() const { return type_; }
 
diff --git a/src/planner/cached_node/cached_scan_base.cpp b/src/planner/cached_node/cached_scan_base.cpp
new file mode 100644
index 0000000000..d382045b26
--- /dev/null
+++ b/src/planner/cached_node/cached_scan_base.cpp
@@ -0,0 +1,54 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+module;
+
+#include <vector>
+
+module cached_scan_base;
+
+import base_table_ref;
+import physical_scan_base;
+
+namespace infinity {
+
+CachedScanBase::CachedScanBase(LogicalNodeType type,
+                               const BaseTableRef *base_table_ref,
+                               TxnTimeStamp query_ts,
+                               SharedPtr<Vector<String>> output_names)
+    : CachedNodeBase(type, output_names), schema_name_(base_table_ref->schema_name()), table_name_(base_table_ref->table_name()),
+      column_ids_(base_table_ref->column_ids_), query_ts_(query_ts) {}
+
+CachedScanBase::CachedScanBase(LogicalNodeType type, const PhysicalScanBase *physical_scan_base, TxnTimeStamp query_ts)
+    : CachedNodeBase(type, physical_scan_base->GetOutputNames()), schema_name_(physical_scan_base->base_table_ref_->schema_name()),
+      table_name_(physical_scan_base->base_table_ref_->table_name()), column_ids_(physical_scan_base->base_table_ref_->column_ids_),
+      query_ts_(query_ts) {}
+
+u64 CachedScanBase::Hash() const {
+    u64 h = CachedNodeBase::Hash();
+    h = h ^ std::hash<String>{}(*schema_name_);
+    h = h ^ std::hash<String>{}(*table_name_);
+    h = h ^ std::hash<TxnTimeStamp>{}(query_ts_);
+    return h;
+}
+
+bool CachedScanBase::Eq(const CachedNodeBase &other_base) const {
+    if (!CachedNodeBase::Eq(other_base)) {
+        return false;
+    }
+    const auto &other = static_cast<const CachedScanBase &>(other_base);
+    return *schema_name_ == *other.schema_name_ && *table_name_ == *other.table_name_ && query_ts_ == other.query_ts_;
+}
+
+} // namespace infinity
\ No newline at end of file
diff --git a/src/planner/cached_node/cached_match_base.cppm b/src/planner/cached_node/cached_scan_base.cppm
similarity index 62%
rename from src/planner/cached_node/cached_match_base.cppm
rename to src/planner/cached_node/cached_scan_base.cppm
index dce2498e0b..ba98c61bd7 100644
--- a/src/planner/cached_node/cached_match_base.cppm
+++ b/src/planner/cached_node/cached_scan_base.cppm
@@ -14,29 +14,26 @@
 
 module;
 
-export module cached_match_base;
+export module cached_scan_base;
 
 import stl;
 import cached_node_base;
-import base_table_ref;
 import logical_node_type;
 
 namespace infinity {
 
-export class CachedMatchBase : public CachedNodeBase {
+class BaseTableRef;
+class PhysicalScanBase;
+
+export class CachedScanBase : public CachedNodeBase {
 public:
-    CachedMatchBase(LogicalNodeType type,
-                    SharedPtr<String> schema_name,
-                    SharedPtr<String> table_name,
-                    const Vector<ColumnID> column_ids,
-                    TxnTimeStamp query_ts,
-                    SharedPtr<Vector<String>> output_names)
-        : CachedNodeBase(type, output_names), schema_name_(std::move(schema_name)), table_name_(std::move(table_name)), column_ids_(column_ids),
-          query_ts_(query_ts) {}
+    CachedScanBase(LogicalNodeType type, const BaseTableRef *base_table_ref, TxnTimeStamp query_ts, SharedPtr<Vector<String>> output_names);
+
+    CachedScanBase(LogicalNodeType type, const PhysicalScanBase *physical_scan_base, TxnTimeStamp query_ts);
 
     u64 Hash() const override;
 
-    bool Equal(const CachedMatchBase &other) const;
+    bool Eq(const CachedNodeBase &other) const override;
 
     const String &schema_name() const { return *schema_name_; }
     const String &table_name() const { return *table_name_; }
diff --git a/src/planner/expression_binder.cpp b/src/planner/expression_binder.cpp
index 59c0c82d53..ae327ae766 100644
--- a/src/planner/expression_binder.cpp
+++ b/src/planner/expression_binder.cpp
@@ -834,7 +834,7 @@ SharedPtr<BaseExpression> ExpressionBinder::BuildMatchTensorExpr(const MatchTens
     return bound_match_tensor_expr;
 }
 
-SharedPtr<BaseExpression> ExpressionBinder::BuildMatchSparseExpr(const MatchSparseExpr &expr, BindContext *bind_context_ptr, i64 depth, bool root) {
+SharedPtr<BaseExpression> ExpressionBinder::BuildMatchSparseExpr(MatchSparseExpr &&expr, BindContext *bind_context_ptr, i64 depth, bool root) {
     if (expr.column_expr_->type_ != ParsedExprType::kColumn) {
         UnrecoverableError("MatchSparse expression expect a column expression");
     }
@@ -897,7 +897,7 @@ SharedPtr<BaseExpression> ExpressionBinder::BuildSearchExpr(const SearchExpr &ex
                 break;
             }
             case ParsedExprType::kMatchSparse: {
-                const auto &match_sparse = *static_cast<const MatchSparseExpr *>(match_expr);
+                auto &match_sparse = const_cast<MatchSparseExpr &>(*static_cast<const MatchSparseExpr *>(match_expr));
                 for(auto &param : match_sparse.opt_params_){
                     if(param->param_name_ != "alpha" and param->param_name_ != "beta" and param->param_name_ != "tail"){
                         RecoverableError(Status::SyntaxError(fmt::format("Unsupported optional parameter: {}", param->param_name_)));
@@ -906,7 +906,7 @@ SharedPtr<BaseExpression> ExpressionBinder::BuildSearchExpr(const SearchExpr &ex
                 if (match_sparse.filter_expr_) {
                     have_filter_in_subsearch = true;
                 }
-                match_exprs.push_back(BuildMatchSparseExpr(match_sparse, bind_context_ptr, depth, false));
+                match_exprs.push_back(BuildMatchSparseExpr(std::move(match_sparse), bind_context_ptr, depth, false));
                 break;
             }
             default: {
diff --git a/src/planner/expression_binder.cppm b/src/planner/expression_binder.cppm
index 6a6be86c61..5c9d33ecc2 100644
--- a/src/planner/expression_binder.cppm
+++ b/src/planner/expression_binder.cppm
@@ -80,7 +80,7 @@ public:
 
     virtual SharedPtr<BaseExpression> BuildMatchTensorExpr(const MatchTensorExpr &expr, BindContext *bind_context_ptr, i64 depth, bool root);
 
-    virtual SharedPtr<BaseExpression> BuildMatchSparseExpr(const MatchSparseExpr &expr, BindContext *bind_context_ptr, i64 depth, bool root);
+    virtual SharedPtr<BaseExpression> BuildMatchSparseExpr(MatchSparseExpr &&expr, BindContext *bind_context_ptr, i64 depth, bool root);
 
     virtual SharedPtr<BaseExpression> BuildSearchExpr(const SearchExpr &expr, BindContext *bind_context_ptr, i64 depth, bool root);
 
diff --git a/src/planner/node/logical_match_scan/logical_match_tensor_scan.cppm b/src/planner/node/logical_match_scan/logical_match_tensor_scan.cppm
index 746b1ed7dd..5a0c638e80 100644
--- a/src/planner/node/logical_match_scan/logical_match_tensor_scan.cppm
+++ b/src/planner/node/logical_match_scan/logical_match_tensor_scan.cppm
@@ -42,6 +42,12 @@ export struct MatchTensorScanIndexOptions {
     u32 emvb_n_doc_out_second_stage_ = topn_ * EMVB_N_DOC_OUT_SECOND_STAGE_FACTOR;
     f32 emvb_threshold_final_ = EMVB_THRESHOLD_FINAL;
     explicit MatchTensorScanIndexOptions(u32 topn) : topn_(topn) {}
+
+    bool operator==(const MatchTensorScanIndexOptions &other) const {
+        return topn_ == other.topn_ && emvb_centroid_nprobe_ == other.emvb_centroid_nprobe_ &&
+               emvb_threshold_first_ == other.emvb_threshold_first_ && emvb_n_doc_to_score_ == other.emvb_n_doc_to_score_ &&
+               emvb_n_doc_out_second_stage_ == other.emvb_n_doc_out_second_stage_ && emvb_threshold_final_ == other.emvb_threshold_final_;
+    }
 };
 
 export class LogicalMatchTensorScan final : public LogicalMatchScanBase {
@@ -57,7 +63,7 @@ public:
     // extra options
     // will be parsed in InitExtraOptions()
     u32 topn_ = 0;
-    UniquePtr<MatchTensorScanIndexOptions> index_options_;
+    SharedPtr<MatchTensorScanIndexOptions> index_options_;
 };
 
 } // namespace infinity
diff --git a/src/planner/node/logical_read_cache.cpp b/src/planner/node/logical_read_cache.cpp
index 632d6bc3a6..a61b9ced89 100644
--- a/src/planner/node/logical_read_cache.cpp
+++ b/src/planner/node/logical_read_cache.cpp
@@ -26,11 +26,13 @@ import infinity_exception;
 namespace infinity {
 
 LogicalReadCache::LogicalReadCache(u64 node_id,
+                                   LogicalNodeType origin_type,
                                    SharedPtr<BaseTableRef> base_table_ref,
                                    SharedPtr<CacheContent> cache_content,
-                                   Vector<SizeT> column_map)
-    : LogicalNode(node_id, LogicalNodeType::kReadCache), base_table_ref_(std::move(base_table_ref)), cache_content_(std::move(cache_content)),
-      column_map_(std::move(column_map)) {}
+                                   Vector<SizeT> column_map,
+                                   bool is_min_heap)
+    : LogicalNode(node_id, LogicalNodeType::kReadCache), origin_type_(origin_type), base_table_ref_(std::move(base_table_ref)),
+      cache_content_(std::move(cache_content)), column_map_(std::move(column_map)), is_min_heap_(is_min_heap) {}
 
 Vector<ColumnBinding> LogicalReadCache::GetColumnBindings() const {
     Vector<ColumnBinding> result;
diff --git a/src/planner/node/logical_read_cache.cppm b/src/planner/node/logical_read_cache.cppm
index 68e092547d..6b578415ef 100644
--- a/src/planner/node/logical_read_cache.cppm
+++ b/src/planner/node/logical_read_cache.cppm
@@ -30,7 +30,12 @@ struct CacheContent;
 
 export class LogicalReadCache : public LogicalNode {
 public:
-    LogicalReadCache(u64 node_id, SharedPtr<BaseTableRef> base_table_ref, SharedPtr<CacheContent> cache_content, Vector<SizeT> column_map);
+    LogicalReadCache(u64 node_id,
+                     LogicalNodeType origin_type,
+                     SharedPtr<BaseTableRef> base_table_ref,
+                     SharedPtr<CacheContent> cache_content,
+                     Vector<SizeT> column_map,
+                     bool is_min_heap);
 
 public:
     virtual Vector<ColumnBinding> GetColumnBindings() const;
@@ -44,9 +49,11 @@ public:
     virtual String name() { return "LogicalReadCache"; }
 
 public:
+    LogicalNodeType origin_type_;
     SharedPtr<BaseTableRef> base_table_ref_;
     SharedPtr<CacheContent> cache_content_;
     Vector<SizeT> column_map_; // result column id -> cache column id
+    bool is_min_heap_;
 };
 
 } // namespace infinity
\ No newline at end of file
diff --git a/src/planner/optimizer.cpp b/src/planner/optimizer.cpp
index 4897d8abf1..c419b8698f 100644
--- a/src/planner/optimizer.cpp
+++ b/src/planner/optimizer.cpp
@@ -43,7 +43,9 @@ Optimizer::Optimizer(QueryContext *query_context_ptr) : query_context_ptr_(query
     AddRule(MakeUnique<ColumnPruner>());
     AddRule(MakeUnique<LazyLoad>());
     AddRule(MakeUnique<ColumnRemapper>());
-    AddRule(MakeUnique<ResultCacheGetter>()); // put after column pruner, column remapper
+    if (query_context_ptr->storage()->result_cache_manager()) {
+        AddRule(MakeUnique<ResultCacheGetter>()); // put after column pruner, column remapper
+    }
 }
 
 void Optimizer::AddRule(UniquePtr<OptimizerRule> rule) { rules_.emplace_back(std::move(rule)); }
diff --git a/src/planner/optimizer/result_cache_getter.cpp b/src/planner/optimizer/result_cache_getter.cpp
index b6b9de2b1e..2d21b46d51 100644
--- a/src/planner/optimizer/result_cache_getter.cpp
+++ b/src/planner/optimizer/result_cache_getter.cpp
@@ -23,7 +23,17 @@ import result_cache_manager;
 import logical_node_type;
 import logical_read_cache;
 import logical_fusion;
+import logical_match_tensor_scan;
+import logical_match_sparse_scan;
+import logical_knn_scan;
+import logical_index_scan;
 import cached_match;
+import cached_match_scan;
+import cached_index_scan;
+import third_party;
+import logger;
+import base_table_ref;
+import knn_expression;
 
 namespace infinity {
 
@@ -37,28 +47,73 @@ void ResultCacheGetter::ApplyToPlan(QueryContext *query_context_ptr, SharedPtr<L
         if (!op) {
             return;
         }
+        Optional<CacheOutput> cache_output;
+        SharedPtr<BaseTableRef> base_table_ref;
+        bool is_min_heap = false;
         switch (op->operator_type()) {
             case LogicalNodeType::kMatch: {
                 auto *logical_match = static_cast<LogicalMatch *>(op.get());
+                base_table_ref = logical_match->base_table_ref_;
                 TxnTimeStamp query_ts = std::min(begin_ts, logical_match->base_table_ref_->max_commit_ts());
                 CachedMatch cached_match(query_ts, logical_match);
-                Optional<CacheOutput> cache_output = cache_mgr->GetCache(cached_match);
-                if (!cache_output.has_value()) {
-                    break;
-                }
-                auto logical_read_cache = MakeShared<LogicalReadCache>(logical_match->node_id(),
-                                                                       logical_match->base_table_ref_,
-                                                                       std::move(cache_output->cache_content_),
-                                                                       std::move(cache_output->column_map_));
-                logical_read_cache->set_left_node(op->left_node());
-                logical_read_cache->set_right_node(op->right_node());
-                op = logical_read_cache;
+                cache_output = cache_mgr->GetCache(cached_match);
+                is_min_heap = true;
+                break;
+            }
+            case LogicalNodeType::kMatchTensorScan: {
+                auto *logical_match_tensor_scan = static_cast<LogicalMatchTensorScan *>(op.get());
+                base_table_ref = logical_match_tensor_scan->base_table_ref_;
+                TxnTimeStamp query_ts = std::min(begin_ts, logical_match_tensor_scan->base_table_ref_->max_commit_ts());
+                CachedMatchTensorScan cached_match_tensor_scan(query_ts, logical_match_tensor_scan);
+                cache_output = cache_mgr->GetCache(cached_match_tensor_scan);
+                is_min_heap = true;
+                break;
+            }
+            case LogicalNodeType::kMatchSparseScan: {
+                auto *logical_match_sparse_scan = static_cast<LogicalMatchSparseScan *>(op.get());
+                base_table_ref = logical_match_sparse_scan->base_table_ref_;
+                TxnTimeStamp query_ts = std::min(begin_ts, logical_match_sparse_scan->base_table_ref_->max_commit_ts());
+                CachedMatchSparseScan cached_match_sparse_scan(query_ts, logical_match_sparse_scan);
+                cache_output = cache_mgr->GetCache(cached_match_sparse_scan);
+                is_min_heap = true;
+                break;
+            }
+            case LogicalNodeType::kKnnScan: {
+                auto *logical_knn_scan = static_cast<LogicalKnnScan *>(op.get());
+                base_table_ref = logical_knn_scan->base_table_ref_;
+                TxnTimeStamp query_ts = std::min(begin_ts, logical_knn_scan->base_table_ref_->max_commit_ts());
+                CachedKnnScan cached_knn_scan(query_ts, logical_knn_scan);
+                cache_output = cache_mgr->GetCache(cached_knn_scan);
+                is_min_heap = static_cast<const KnnExpression *>(cached_knn_scan.query_expression())->IsKnnMinHeap();
+                break;
+            }
+            case LogicalNodeType::kIndexScan: {
+                auto *logical_index_scan = static_cast<LogicalIndexScan *>(op.get());
+                base_table_ref = logical_index_scan->base_table_ref_;
+                TxnTimeStamp query_ts = std::min(begin_ts, logical_index_scan->base_table_ref_->max_commit_ts());
+                CachedIndexScan cached_index_scan(query_ts, logical_index_scan);
+                cache_output = cache_mgr->GetCache(cached_index_scan);
                 break;
             }
             default: {
-                //
+                break;
             }
         }
+        if (!cache_output.has_value()) {
+            LOG_INFO(fmt::format("No cache found for match node {}", op->node_id()));
+        } else {
+            LOG_INFO(fmt::format("Cache found for match node {}", op->node_id()));
+            auto logical_read_cache = MakeShared<LogicalReadCache>(op->node_id(),
+                                                                   op->operator_type(),
+                                                                   base_table_ref,
+                                                                   std::move(cache_output->cache_content_),
+                                                                   std::move(cache_output->column_map_),
+                                                                   is_min_heap);
+            logical_read_cache->set_left_node(op->left_node());
+            logical_read_cache->set_right_node(op->right_node());
+            op = logical_read_cache;
+        }
+
         // visit children after handling current node
         visit_node(op->left_node());
         visit_node(op->right_node());
diff --git a/src/scheduler/fragment_context.cpp b/src/scheduler/fragment_context.cpp
index c25ddcbdc9..ea3bfd2581 100644
--- a/src/scheduler/fragment_context.cpp
+++ b/src/scheduler/fragment_context.cpp
@@ -1119,7 +1119,6 @@ void FragmentContext::MakeSinkState(i64 parallel_count) {
             tasks_[0]->sink_state_ = MakeUnique<QueueSinkState>(plan_fragment_ptr_->FragmentID(), 0);
             break;
         }
-
         case PhysicalOperatorType::kExplain:
         case PhysicalOperatorType::kShow: {
             if (fragment_type_ != FragmentType::kSerialMaterialize) {
@@ -1138,6 +1137,7 @@ void FragmentContext::MakeSinkState(i64 parallel_count) {
             sink_state_ptr->column_names_ = last_operator->GetOutputNames();
             break;
         }
+        case PhysicalOperatorType::kReadCache:
         case PhysicalOperatorType::kMatch: {
             for (u64 task_id = 0; (i64)task_id < parallel_count; ++task_id) {
                 tasks_[task_id]->sink_state_ = MakeUnique<QueueSinkState>(plan_fragment_ptr_->FragmentID(), task_id);
@@ -1326,6 +1326,7 @@ void FragmentContext::CreateTasks(i64 cpu_count, i64 operator_count, FragmentCon
             }
             break;
         }
+        case PhysicalOperatorType::kReadCache:
         case PhysicalOperatorType::kMatch:
         case PhysicalOperatorType::kMergeKnn:
         case PhysicalOperatorType::kMergeMatchTensor:
@@ -1445,6 +1446,7 @@ SharedPtr<DataTable> SerialMaterializedFragmentCtx::GetResultInternal() {
                 result_table->UpdateRowCount(data_block->row_count());
                 result_table->data_blocks_.emplace_back(std::move(data_block));
             }
+            materialize_sink_state->data_block_array_.clear();
             //            result_table->data_blocks_ = std::move(materialize_sink_state->data_block_array_);
             return result_table;
         }
@@ -1527,6 +1529,7 @@ SharedPtr<DataTable> ParallelMaterializedFragmentCtx::GetResultInternal() {
         for (auto &result_data_block : materialize_sink_state->data_block_array_) {
             result_table->Append(std::move(result_data_block));
         }
+        materialize_sink_state->data_block_array_.clear();
     }
 
     return result_table;
@@ -1576,6 +1579,7 @@ SharedPtr<DataTable> ParallelStreamFragmentCtx::GetResultInternal() {
         for (auto &result_data_block : materialize_sink_state->data_block_array_) {
             result_table->Append(std::move(result_data_block));
         }
+        materialize_sink_state->data_block_array_.clear();
     }
 
     return result_table;
diff --git a/src/storage/column_vector/value.cpp b/src/storage/column_vector/value.cpp
index 6b4d550b0f..0fa1827973 100644
--- a/src/storage/column_vector/value.cpp
+++ b/src/storage/column_vector/value.cpp
@@ -1033,10 +1033,11 @@ bool Value::operator==(const Value &other) const {
             });
         }
         case LogicalType::kSparse: {
-            // TODO
-            String error_message = "Not implemented yet.";
-            UnrecoverableError(error_message);
-            break;
+            const auto &sparse1 = GetSparse();
+            const auto &sparse2 = other.GetSparse();
+            const auto &[nnz1, raw_idx1, raw_data1] = sparse1;
+            const auto &[nnz2, raw_idx2, raw_data2] = sparse2;
+            return nnz1 == nnz2 && std::ranges::equal(raw_idx1, raw_idx2) && std::ranges::equal(raw_data1, raw_data2);
         }
         case LogicalType::kInterval:
         case LogicalType::kArray:
diff --git a/src/storage/data_block.cpp b/src/storage/data_block.cpp
index f8db561406..c2620b73c5 100644
--- a/src/storage/data_block.cpp
+++ b/src/storage/data_block.cpp
@@ -54,8 +54,7 @@ bool DataBlock::AppendColumns(const DataBlock &other, const Vector<SizeT> &colum
 
 UniquePtr<DataBlock> DataBlock::Clone() const {
     if (!finalized) {
-        String error_message = "Not finalized data block";
-        UnrecoverableError(error_message);
+        return nullptr;
     }
     auto data_block = MakeUnique<DataBlock>();
     data_block->Init(column_vectors);
diff --git a/src/storage/result_cache_manager.cpp b/src/storage/result_cache_manager.cpp
index e0a314a1f7..f4b67acd68 100644
--- a/src/storage/result_cache_manager.cpp
+++ b/src/storage/result_cache_manager.cpp
@@ -18,75 +18,134 @@ module;
 
 module result_cache_manager;
 
-import cached_match_base;
+import cached_scan_base;
 import infinity_exception;
 import logical_match;
 import physical_match;
 import logical_node_type;
+import logger;
 
 namespace infinity {
 
-bool CacheContent::AppendColumns(const CacheContent &other, const Vector<SizeT> &column_idxes) {
+UniquePtr<CacheContent> CacheContent::AppendColumns(const CacheContent &other, const Vector<SizeT> &column_idxes) const {
     if (data_blocks_.size() != other.data_blocks_.size()) {
-        return false;
+        return nullptr;
     }
-    for (SizeT i = 0; i < data_blocks_.size(); ++i) {
-        DataBlock &old_block = *data_blocks_[i];
+    UniquePtr<CacheContent> result = Clone();
+    for (SizeT i = 0; i < result->data_blocks_.size(); ++i) {
+        DataBlock &old_block = *result->data_blocks_[i];
         const DataBlock &new_block = *other.data_blocks_[i];
         bool success = old_block.AppendColumns(new_block, column_idxes);
         if (!success) {
-            return false;
+            return nullptr;
         }
     }
     for (SizeT idx : column_idxes) {
-        column_names_->push_back((*(other.column_names_))[idx]);
+        result->column_names_->push_back((*(other.column_names_))[idx]);
     }
-    return true;
+    return result;
 }
 
-bool ResultCacheManager::AddCache(UniquePtr<CachedNodeBase> cached_node, Vector<UniquePtr<DataBlock>> data_blocks) {
-    if (cached_node == nullptr) {
+UniquePtr<CacheContent> CacheContent::Clone() const {
+    Vector<UniquePtr<DataBlock>> data_blocks;
+    for (const auto &block : data_blocks_) {
+        data_blocks.push_back(block->Clone());
+    }
+    return MakeUnique<CacheContent>(std::move(data_blocks), column_names_);
+}
+
+bool CacheResultMap::AddCache(
+    UniquePtr<CachedNodeBase> cached_node,
+    Vector<UniquePtr<DataBlock>> data_blocks,
+    const std::function<void(UniquePtr<CachedNodeBase>, CacheContent &, Vector<UniquePtr<DataBlock>>)> &update_content_func) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    auto mp_iter = lru_map_.find(cached_node.get());
+    if (mp_iter != lru_map_.end()) {
+        CacheContent &old_content = *mp_iter->second->cache_content_;
+        update_content_func(std::move(cached_node), old_content, std::move(data_blocks));
         return false;
     }
+    if (lru_list_.size() >= cache_num_capacity_) {
+        LRUEntry &envict_entry = lru_list_.back();
+        SizeT remove_n = lru_map_.erase(envict_entry.cached_node_.get());
+        if (remove_n != 1) {
+            UnrecoverableError("Failed to remove cache entry from lru_map_");
+        }
+        lru_list_.pop_back();
+    }
+    auto *cached_node_ptr = cached_node.get();
     auto cache_content = MakeShared<CacheContent>(std::move(data_blocks), cached_node->output_names());
+    lru_list_.emplace_front(std::move(cached_node), cache_content);
+    lru_map_.emplace_hint(mp_iter, cached_node_ptr, lru_list_.begin());
+    return true;
+}
 
+SharedPtr<CacheContent> CacheResultMap::GetCache(const CachedNodeBase &cached_node) {
     std::lock_guard<std::mutex> lock(mtx_);
-    auto iter = cache_map_.find(static_cast<const CachedNodeBase *>(cached_node.get()));
-    if (iter == cache_map_.end()) {
-        cache_map_.emplace(std::move(cached_node), std::move(cache_content));
-        return true;
+    auto mp_iter = lru_map_.find(&cached_node);
+    if (mp_iter == lru_map_.end()) {
+        return nullptr;
     }
+    auto iter = mp_iter->second;
+    lru_list_.splice(lru_list_.begin(), lru_list_, iter);
+    return iter->cache_content_;
+}
 
-    SharedPtr<Vector<String>> new_output_names = cached_node->output_names();
-    SharedPtr<Vector<String>> old_output_names = iter->second->column_names_;
-
-    Vector<SizeT> add_columns;
-    for (SizeT i = 0; i < new_output_names->size(); ++i) {
-        const String &output_name = (*new_output_names)[i];
-        auto iter = std::find(old_output_names->begin(), old_output_names->end(), output_name);
-        if (iter == old_output_names->end()) {
-            add_columns.push_back(i);
+SizeT CacheResultMap::DropIF(std::function<bool(const CachedNodeBase &)> pred) {
+    std::lock_guard<std::mutex> lock(mtx_);
+    SizeT removed = 0;
+    for (auto mp_iter = lru_map_.begin(); mp_iter != lru_map_.end();) {
+        const auto &[cached_node, iter] = *mp_iter;
+        if (pred(*cached_node)) {
+            lru_list_.erase(iter);
+            mp_iter = lru_map_.erase(mp_iter);
+            ++removed;
+        } else {
+            ++mp_iter;
         }
     }
-    if (add_columns.empty()) {
-        return true;
-    }
-    bool success = iter->second->AppendColumns(*cache_content, add_columns);
-    if (!success) {
-        iter->second = std::move(cache_content);
+    return removed;
+}
+
+bool ResultCacheManager::AddCache(UniquePtr<CachedNodeBase> cached_node, Vector<UniquePtr<DataBlock>> data_blocks) {
+    if (cached_node == nullptr) {
         return false;
     }
-    return true;
+    auto update_content_func = [](UniquePtr<CachedNodeBase> cached_node, CacheContent &old_content, Vector<UniquePtr<DataBlock>> data_blocks) {
+        auto new_content = MakeShared<CacheContent>(std::move(data_blocks), cached_node->output_names());
+        SharedPtr<Vector<String>> new_output_names = new_content->column_names_;
+        SharedPtr<Vector<String>> old_output_names = old_content.column_names_;
+
+        Vector<SizeT> add_columns;
+        for (SizeT i = 0; i < new_output_names->size(); ++i) {
+            const String &output_name = (*new_output_names)[i];
+            auto iter = std::find(old_output_names->begin(), old_output_names->end(), output_name);
+            if (iter == old_output_names->end()) {
+                add_columns.push_back(i);
+            }
+        }
+        if (add_columns.empty()) {
+            return;
+        }
+        UniquePtr<CacheContent> updated_content = old_content.AppendColumns(*new_content, add_columns);
+        if (!updated_content) {
+            LOG_WARN("Failed to append columns to cache content");
+            old_content = std::move(*new_content);
+        } else {
+            LOG_INFO("Success update cache content");
+            old_content = std::move(*updated_content);
+        }
+    };
+    return cache_map_.AddCache(std::move(cached_node), std::move(data_blocks), update_content_func);
 }
 
 Optional<CacheOutput> ResultCacheManager::GetCache(const CachedNodeBase &cached_node) {
-    std::lock_guard<std::mutex> lock(mtx_);
-    auto iter = cache_map_.find(&cached_node);
-    if (iter == cache_map_.end()) {
+    SharedPtr<CacheContent> cache_content = cache_map_.GetCache(cached_node);
+    if (!cache_content) {
         return None;
     }
-    SharedPtr<CacheContent> cache_content = iter->second;
     SharedPtr<Vector<String>> output_names = cached_node.output_names();
+
     Vector<SizeT> column_map;
     for (const String &output_name : *output_names) {
         auto column_iter = std::find(cache_content->column_names_->begin(), cache_content->column_names_->end(), output_name);
@@ -99,28 +158,18 @@ Optional<CacheOutput> ResultCacheManager::GetCache(const CachedNodeBase &cached_
 }
 
 SizeT ResultCacheManager::DropTable(const String &schema_name, const String &table_name) {
-    std::lock_guard<std::mutex> lock(mtx_);
-
-    SizeT removed = 0;
-    for (auto iter = cache_map_.begin(); iter != cache_map_.end();) {
-        const CachedNodeBase &cached_node_base = *iter->first;
+    auto pred = [&](const CachedNodeBase &cached_node_base) {
         switch (cached_node_base.type()) {
             case LogicalNodeType::kMatch: {
-                const auto &cached_match_base = static_cast<const CachedMatchBase &>(cached_node_base);
-                if (cached_match_base.schema_name() == schema_name && cached_match_base.table_name() == table_name) {
-                    iter = cache_map_.erase(iter);
-                    ++removed;
-                } else {
-                    ++iter;
-                }
-                break;
+                const auto &cached_scan_base = static_cast<const CachedScanBase &>(cached_node_base);
+                return cached_scan_base.schema_name() == schema_name && cached_scan_base.table_name() == table_name;
             }
             default: {
-                break;
+                return false;
             }
         }
-    }
-    return removed;
+    };
+    return cache_map_.DropIF(pred);
 }
 
 } // namespace infinity
\ No newline at end of file
diff --git a/src/storage/result_cache_manager.cppm b/src/storage/result_cache_manager.cppm
index 0fc1daef6a..4bee6e436e 100644
--- a/src/storage/result_cache_manager.cppm
+++ b/src/storage/result_cache_manager.cppm
@@ -33,7 +33,9 @@ public:
     CacheContent(Vector<UniquePtr<DataBlock>> data_blocks, SharedPtr<Vector<String>> column_names)
         : data_blocks_(std::move(data_blocks)), column_names_(std::move(column_names)) {}
 
-    bool AppendColumns(const CacheContent &other, const Vector<SizeT> &column_idxes);
+    UniquePtr<CacheContent> AppendColumns(const CacheContent &other, const Vector<SizeT> &column_idxes) const;
+
+    UniquePtr<CacheContent> Clone() const;
 
     Vector<UniquePtr<DataBlock>> data_blocks_;
     SharedPtr<Vector<String>> column_names_;
@@ -44,24 +46,48 @@ export struct CacheOutput {
     Vector<SizeT> column_map_;
 };
 
-export class ResultCacheManager {
+class CacheResultMap {
 public:
     struct CachedLogicalMatchBaseHash {
         using is_transparent = std::true_type;
 
-        SizeT operator()(const UniquePtr<CachedNodeBase> &key) const { return key->Hash(); }
         SizeT operator()(const CachedNodeBase *key) const { return key->Hash(); }
     };
 
     struct CachedLogicalMatchBaseEq {
         using is_transparent = std::true_type;
 
-        bool operator()(const UniquePtr<CachedNodeBase> &key1, const UniquePtr<CachedNodeBase> &key2) const { return key1->Eq(*key2); }
-        bool operator()(const UniquePtr<CachedNodeBase> &key1, const CachedNodeBase *key2) const { return key1->Eq(*key2); }
+        bool operator()(const CachedNodeBase *key1, const CachedNodeBase *key2) const { return key1->Eq(*key2); }
     };
 
+    CacheResultMap(SizeT cache_num_capacity) : cache_num_capacity_(cache_num_capacity) {}
+
+    bool AddCache(UniquePtr<CachedNodeBase> cached_node,
+                  Vector<UniquePtr<DataBlock>> data_blocks,
+                  const std::function<void(UniquePtr<CachedNodeBase>, CacheContent &, Vector<UniquePtr<DataBlock>>)> &update_content_func);
+
+    SharedPtr<CacheContent> GetCache(const CachedNodeBase &cached_node);
+
+    SizeT DropIF(std::function<bool(const CachedNodeBase &)> pred);
+
+private:
+    struct LRUEntry {
+        UniquePtr<CachedNodeBase> cached_node_;
+        SharedPtr<CacheContent> cache_content_;
+    };
+    using LRUList = List<LRUEntry>;
+    using LRUMap = HashMap<CachedNodeBase *, LRUList::iterator, CachedLogicalMatchBaseHash, CachedLogicalMatchBaseEq>;
+
+    std::mutex mtx_;
+
+    SizeT cache_num_capacity_;
+    LRUList lru_list_;
+    LRUMap lru_map_;
+};
+
+export class ResultCacheManager {
 public:
-    ResultCacheManager() = default;
+    ResultCacheManager(SizeT cache_num_capacity) : cache_map_(cache_num_capacity) {}
 
     bool AddCache(UniquePtr<CachedNodeBase> cached_node, Vector<UniquePtr<DataBlock>> data_blocks);
 
@@ -70,8 +96,7 @@ public:
     SizeT DropTable(const String &schema_name, const String &table_name);
 
 private:
-    HashMap<UniquePtr<CachedNodeBase>, SharedPtr<CacheContent>, CachedLogicalMatchBaseHash, CachedLogicalMatchBaseEq> cache_map_;
-    std::mutex mtx_;
+    CacheResultMap cache_map_;
 };
 
 } // namespace infinity
\ No newline at end of file
diff --git a/src/storage/storage.cpp b/src/storage/storage.cpp
index bb69c64b0b..2371d8374c 100644
--- a/src/storage/storage.cpp
+++ b/src/storage/storage.cpp
@@ -59,6 +59,13 @@ Storage::Storage(Config *config_ptr) : config_ptr_(config_ptr) {}
 
 Storage::~Storage() = default;
 
+ResultCacheManager *Storage::result_cache_manager() const noexcept {
+    if (config_ptr_->ResultCacheMode() != "on") {
+        return nullptr;
+    }
+    return result_cache_manager_.get();
+}
+
 StorageMode Storage::GetStorageMode() const {
     std::unique_lock<std::mutex> lock(mutex_);
     return current_storage_mode_;
@@ -151,7 +158,10 @@ void Storage::SetStorageMode(StorageMode target_mode) {
                 UnrecoverableError("Result cache manager was initialized before.");
             }
             // TODO: add result_cache_manager
-            // result_cache_manager_ = MakeUnique<ResultCacheManager>();
+            if (config_ptr_->ResultCacheMode() == "on") {
+                SizeT cache_result_num = config_ptr_->CacheResultNum();
+                result_cache_manager_ = MakeUnique<ResultCacheManager>(cache_result_num);
+            }
 
             // Construct buffer manager
             if (buffer_mgr_ != nullptr) {
diff --git a/src/storage/storage.cppm b/src/storage/storage.cppm
index 03bfe50b2d..b5b18c0b23 100644
--- a/src/storage/storage.cppm
+++ b/src/storage/storage.cppm
@@ -64,7 +64,7 @@ public:
 
     [[nodiscard]] inline CleanupInfoTracer *cleanup_info_tracer() const noexcept { return cleanup_info_tracer_.get(); }
 
-    [[nodiscard]] inline ResultCacheManager *result_cache_manager() const noexcept { return result_cache_manager_.get(); }
+    [[nodiscard]] ResultCacheManager *result_cache_manager() const noexcept;
 
     StorageMode GetStorageMode() const;
     void SetStorageMode(StorageMode mode);
diff --git a/src/unit_test/main/config.cpp b/src/unit_test/main/config.cpp
index 12f67e4009..5a0c87bd6e 100644
--- a/src/unit_test/main/config.cpp
+++ b/src/unit_test/main/config.cpp
@@ -69,6 +69,9 @@ TEST_F(ConfigTest, test1) {
     EXPECT_EQ(config.LRUNum(), 7);
     EXPECT_EQ(config.TempDir(), "/var/infinity/tmp");
     EXPECT_EQ(config.MemIndexMemoryQuota(), 4 * 1024l * 1024l * 1024l);
+
+    EXPECT_EQ(config.ResultCacheMode(), "off");
+    EXPECT_EQ(config.CacheResultNum(), 10000);
 }
 
 TEST_F(ConfigTest, test2) {
@@ -112,6 +115,9 @@ TEST_F(ConfigTest, test2) {
     EXPECT_EQ(config.LRUNum(), 8);
     EXPECT_EQ(config.TempDir(), "/var/infinity/tmp");
     EXPECT_EQ(config.MemIndexMemoryQuota(), 2 * 1024l * 1024l * 1024l);
+
+    EXPECT_EQ(config.ResultCacheMode(), "on");
+    EXPECT_EQ(config.CacheResultNum(), 100);
 }
 
 TEST_F(ConfigTest, TestWrongParamNames) {
diff --git a/src/unit_test/parser/sql_select_statement.cpp b/src/unit_test/parser/sql_select_statement.cpp
index 76a4b51b66..76b2654685 100644
--- a/src/unit_test/parser/sql_select_statement.cpp
+++ b/src/unit_test/parser/sql_select_statement.cpp
@@ -1359,7 +1359,7 @@ TEST_F(SelectStatementParsingTest, bad_search_test) {
 
     {
         // bit only support hamming
-        String input_sql = "SELECT b FROM t1 SEARCH MATCH TEXT ('author^2,name^5', 'frank dune') LIMIT 5;";
+        String input_sql = "SELECT b FROM t1 SEARCH MATCH VECTOR (c1, [1,0,1,0,1,1,0], 'bit', 'l2', 3) WHERE a > 0 LIMIT 5;";
         parser->Parse(input_sql, result.get());
 //        std::cout << result->error_message_ << std::endl;
         EXPECT_FALSE(result->error_message_.empty());
diff --git a/src/unit_test/storage/result_cache_manager.cpp b/src/unit_test/storage/result_cache_manager.cpp
index 8a9ccbaf27..edcdecf0fd 100644
--- a/src/unit_test/storage/result_cache_manager.cpp
+++ b/src/unit_test/storage/result_cache_manager.cpp
@@ -39,7 +39,7 @@ class MockCachedNode : public CachedNodeBase {
 };
 
 TEST(ResultCacheManagerTest, test1) {
-    ResultCacheManager cache_manager;
+    ResultCacheManager cache_manager(100);
 
     String key1 = "key1";
     auto output_names1 = MakeShared<Vector<String>>(Vector<String>{"col1", "col2"});
@@ -97,9 +97,41 @@ TEST(ResultCacheManagerTest, test1) {
     auto res3 = cache_manager.GetCache(*cached_node3);
     EXPECT_FALSE(res3.has_value());
     bool success3 = cache_manager.AddCache(std::move(cached_node3), std::move(blocks3));
-    EXPECT_TRUE(success3);
+    EXPECT_FALSE(success3);
     auto res4 = cache_manager.GetCache(*cached_node4);
     EXPECT_TRUE(res4.has_value());
     EXPECT_EQ(res4->column_map_.size(), 1);
     EXPECT_EQ(res4->column_map_[0], 2);
 }
+
+TEST(ResultCacheManagerTest, test2) {
+    ResultCacheManager cache_manager(2);
+    String key1 = "key1";
+    auto output_names1 = MakeShared<Vector<String>>(Vector<String>{"col1"});
+    auto cached_node1 = MakeUnique<MockCachedNode>(key1, output_names1);
+
+    String key2 = "key2";
+    auto output_names2 = MakeShared<Vector<String>>(Vector<String>{"col2"});
+    auto cached_node2 = MakeUnique<MockCachedNode>(key2, output_names2);
+
+    String key3 = "key3";
+    auto output_names3 = MakeShared<Vector<String>>(Vector<String>{"col1", "col2", "col3"});
+    auto cached_node3 = MakeUnique<MockCachedNode>(key3, output_names3);
+
+    auto cached_node11 = MakeUnique<MockCachedNode>(key1, output_names1);
+    bool success = cache_manager.AddCache(std::move(cached_node1), {});
+    EXPECT_TRUE(success);
+
+    auto cached_node21 = MakeUnique<MockCachedNode>(key2, output_names2);
+    bool success2 = cache_manager.AddCache(std::move(cached_node2), {});
+    EXPECT_TRUE(success2);
+
+    auto res1 = cache_manager.GetCache(*cached_node11);
+    EXPECT_TRUE(res1.has_value());
+
+    bool success3 = cache_manager.AddCache(std::move(cached_node3), {});
+    EXPECT_TRUE(success3);
+
+    auto res2 = cache_manager.GetCache(*cached_node21);
+    EXPECT_FALSE(res2.has_value());
+}
diff --git a/test/data/config/infinity_conf.toml b/test/data/config/infinity_conf.toml
index 30ebdca849..d25c6b2d36 100644
--- a/test/data/config/infinity_conf.toml
+++ b/test/data/config/infinity_conf.toml
@@ -37,6 +37,9 @@ lru_num                 = 8
 temp_dir                = "/var/infinity/tmp"
 memindex_memory_quota   = "2GB"
 
+result_cache_mode       = "on"
+cache_result_num        = 100
+
 [wal]
 wal_dir                 = "/var/infinity/wal"
 
diff --git a/test/sql/dql/filter/filter_fulltext_function.slt b/test/sql/dql/filter/filter_fulltext_function.slt
index 1d93433bf8..2663a4d3ee 100644
--- a/test/sql/dql/filter/filter_fulltext_function.slt
+++ b/test/sql/dql/filter/filter_fulltext_function.slt
@@ -1,3 +1,5 @@
+statement ok
+SET CONFIG result_cache_mode "off";
 
 statement ok
 DROP TABLE IF EXISTS ft_in_filter;
@@ -188,3 +190,6 @@ SELECT * FROM ft_in_filter WHERE filter_text('doc', 'second') OR num < 2 OR num
 # Clean up
 statement ok
 DROP TABLE ft_in_filter;
+
+statement ok
+SET CONFIG result_cache_mode "on";
diff --git a/test/sql/dql/index_scan/index_scan_str.slt b/test/sql/dql/index_scan/index_scan_str.slt
index f1555671fb..4271bd83a1 100644
--- a/test/sql/dql/index_scan/index_scan_str.slt
+++ b/test/sql/dql/index_scan/index_scan_str.slt
@@ -1,3 +1,6 @@
+statement ok
+SET CONFIG result_cache_mode "off";
+
 statement ok
 DROP TABLE IF EXISTS str_index_scan_insert;
 
@@ -53,4 +56,7 @@ PROJECT (4)
    - output_columns: [__rowid]
 
 statement ok
-DROP TABLE str_index_scan_insert;
\ No newline at end of file
+DROP TABLE str_index_scan_insert;
+
+statement ok
+SET CONFIG result_cache_mode "on";
diff --git a/test/sql/dql/knn/tensor/fusion_rerank_maxsim.slt b/test/sql/dql/knn/tensor/fusion_rerank_maxsim.slt
index deca7a9981..a678052d7e 100644
--- a/test/sql/dql/knn/tensor/fusion_rerank_maxsim.slt
+++ b/test/sql/dql/knn/tensor/fusion_rerank_maxsim.slt
@@ -1,3 +1,5 @@
+statement ok
+SET CONFIG result_cache_mode "off";
 
 statement ok
 DROP TABLE IF EXISTS sqllogic_fusion_rerank_maxsim;
@@ -148,3 +150,6 @@ test33 3.620001
 # Cleanup
 statement ok
 DROP TABLE sqllogic_fusion_rerank_maxsim;
+
+statement ok
+SET CONFIG result_cache_mode "on";
diff --git a/test/sql/dql/result_cache/cached_fulltext.slt b/test/sql/dql/result_cache/cached_fulltext.slt
new file mode 100644
index 0000000000..45763eac5c
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_fulltext.slt
@@ -0,0 +1,80 @@
+statement ok
+DROP TABLE IF EXISTS cached_fulltext;
+
+statement ok
+CREATE TABLE cached_fulltext(doctitle varchar DEFAULT '', docdate varchar DEFAULT '', body varchar DEFAULT '');
+
+statement ok
+COPY cached_fulltext FROM '/var/infinity/test_data/enwiki_99.csv' WITH ( DELIMITER '\t', FORMAT CSV );
+
+statement ok
+CREATE INDEX ft_index ON cached_fulltext(body) USING FULLTEXT;
+
+query I
+EXPLAIN SELECT doctitle, docdate, ROW_ID(), SCORE() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [doctitle (#0), docdate (#1), ROW_ID (#3), SCORE (#2)]
+ -> MATCH (2)
+    - table name: cached_fulltext(default_db.cached_fulltext)
+    - table index: #1
+    - match expression: MATCH TEXT ('body^5', 'harmful chemical', '')
+    - index filter: None
+    - leftover filter: None
+    - output columns: [doctitle, docdate, __score, __rowid]
+
+query I
+SELECT doctitle, docdate, ROW_ID(), SCORE() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+Anarchism 30-APR-2012 03:25:17.000 0 22.299635
+
+query I
+EXPLAIN SELECT doctitle, docdate, ROW_ID(), SCORE() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [doctitle (#0), docdate (#1), ROW_ID (#3), SCORE (#2)]
+ -> Read cache (2)
+    - table name: (default_db.cached_fulltext)
+    - output columns: [doctitle, docdate, __score, __rowid]
+
+query I
+SELECT doctitle, docdate, ROW_ID(), SCORE() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+Anarchism 30-APR-2012 03:25:17.000 0 22.299635
+
+query I
+EXPLAIN SELECT ROW_ID() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [ROW_ID (#1)]
+ -> Read cache (2)
+    - table name: (default_db.cached_fulltext)
+    - output columns: [__score, __rowid]
+
+query I
+SELECT ROW_ID() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+0
+
+statement ok
+INSERT INTO cached_fulltext VALUES('Anarchism', '30-APR-2012 03:25:17.000', 'Anarchism is a political philosophy that advocates self-governed societies based on voluntary institutions. These are often described as stateless societies, although several authors have defined them more specifically as institutions based on non-hierarchical free associations. Anarchism holds the state to be undesirable, unnecessary and harmful.');
+
+query I
+EXPLAIN SELECT doctitle, docdate, ROW_ID(), SCORE() FROM cached_fulltext SEARCH MATCH TEXT ('body^5', 'harmful chemical');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [doctitle (#0), docdate (#1), ROW_ID (#3), SCORE (#2)]
+ -> MATCH (2)
+    - table name: cached_fulltext(default_db.cached_fulltext)
+    - table index: #1
+    - match expression: MATCH TEXT ('body^5', 'harmful chemical', '')
+    - index filter: None
+    - leftover filter: None
+    - output columns: [doctitle, docdate, __score, __rowid]
+
+statement ok
+DROP TABLE cached_fulltext;
diff --git a/test/sql/dql/result_cache/cached_index_scan.slt b/test/sql/dql/result_cache/cached_index_scan.slt
new file mode 100644
index 0000000000..b9026bdda8
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_index_scan.slt
@@ -0,0 +1,85 @@
+statement ok
+DROP TABLE IF EXISTS cached_index_scan;
+
+statement ok
+CREATE TABLE cached_index_scan (c1 integer, mod_256_min_128 tinyint, mod_7 tinyint);
+
+statement ok
+COPY cached_index_scan FROM '/var/infinity/test_data/test_big_index_scan.csv' WITH (DELIMITER ',', FORMAT CSV);
+
+statement ok
+CREATE INDEX idx_c1 on cached_index_scan(c1);
+
+query I
+EXPLAIN SELECT * FROM cached_index_scan WHERE (c1 < 5) OR (c1 > 10000 AND c1 < 10005) OR c1 = 19990 ORDER BY c1;
+----
+ PROJECT (5)
+  - table index: #4
+  - expressions: [c1 (#0), mod_256_min_128 (#1), mod_7 (#2)]
+ -> SORT (4)
+    - expressions: [c1 (#0) ASC]
+    - output columns: [c1, __rowid]
+   -> INDEX SCAN (7)
+      - table name: cached_index_scan(default_db.cached_index_scan)
+      - table index: #1
+      - filter: ((CAST(c1 (#1.0) AS BigInt) < 5) OR ((CAST(c1 (#1.0) AS BigInt) > 10000) AND (CAST(c1 (#1.0) AS BigInt) < 10005))) OR (CAST(c1 (#1.0) AS BigInt) = 19990)
+      - output_columns: [__rowid]
+
+query I
+SELECT * FROM cached_index_scan WHERE (c1 < 5) OR (c1 > 10000 AND c1 < 10005) OR c1 = 19990 ORDER BY c1;
+----
+0 0 0
+1 1 1
+2 2 2
+3 3 3
+4 4 4
+10001 17 5
+10002 18 6
+10003 19 0
+10004 20 1
+19990 22 5
+
+query I
+EXPLAIN SELECT * FROM cached_index_scan WHERE (c1 < 5) OR (c1 > 10000 AND c1 < 10005) OR c1 = 19990 ORDER BY c1;
+----
+ PROJECT (5)
+  - table index: #4
+  - expressions: [c1 (#0), mod_256_min_128 (#1), mod_7 (#2)]
+ -> SORT (4)
+    - expressions: [c1 (#0) ASC]
+    - output columns: [c1, __rowid]
+   -> Read cache (7)
+      - table name: (default_db.cached_index_scan)
+      - output columns: [__rowid]
+
+query I
+SELECT * FROM cached_index_scan WHERE (c1 < 5) OR (c1 > 10000 AND c1 < 10005) OR c1 = 19990 ORDER BY c1;
+----
+0 0 0
+1 1 1
+2 2 2
+3 3 3
+4 4 4
+10001 17 5
+10002 18 6
+10003 19 0
+10004 20 1
+19990 22 5
+
+query I
+EXPLAIN SELECT * FROM cached_index_scan WHERE (c1 < 5) OR (c1 > 10000 AND c1 < 10010) OR c1 = 19990 ORDER BY c1;
+----
+ PROJECT (5)
+  - table index: #4
+  - expressions: [c1 (#0), mod_256_min_128 (#1), mod_7 (#2)]
+ -> SORT (4)
+    - expressions: [c1 (#0) ASC]
+    - output columns: [c1, __rowid]
+   -> INDEX SCAN (7)
+      - table name: cached_index_scan(default_db.cached_index_scan)
+      - table index: #1
+      - filter: ((CAST(c1 (#1.0) AS BigInt) < 5) OR ((CAST(c1 (#1.0) AS BigInt) > 10000) AND (CAST(c1 (#1.0) AS BigInt) < 10010))) OR (CAST(c1 (#1.0) AS BigInt) = 19990)
+      - output_columns: [__rowid]
+
+statement ok
+DROP TABLE cached_index_scan;
diff --git a/test/sql/dql/result_cache/cached_knn_scan.slt b/test/sql/dql/result_cache/cached_knn_scan.slt
new file mode 100644
index 0000000000..f5100be760
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_knn_scan.slt
@@ -0,0 +1,68 @@
+statement ok
+DROP TABLE IF EXISTS cached_knn_scan;
+
+statement ok
+CREATE TABLE cached_knn_scan(c1 INT, c2 EMBEDDING(FLOAT, 4));
+
+statement ok
+COPY cached_knn_scan FROM '/var/infinity/test_data/embedding_float_dim4.csv' WITH (DELIMITER ',', FORMAT CSV);
+
+query I
+EXPLAIN SELECT c1, Distance() FROM cached_knn_scan SEARCH MATCH VECTOR (c2, [0.3, 0.3, 0.2, 0.2], 'float', 'l2', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [c1 (#0), DISTANCE (#1)]
+ -> KNN SCAN (2)
+    - table name: cached_knn_scan(default_db.cached_knn_scan)
+    - table index: #4
+    - embedding info: c2
+      - element type: FLOAT32
+      - dimension: 4
+      - distance type: L2
+      - query embedding: [0.3,0.3,0.2,0.2]
+    - output columns: [c1, __score, __rowid]
+
+query I
+SELECT c1, Distance() FROM cached_knn_scan SEARCH MATCH VECTOR (c2, [0.3, 0.3, 0.2, 0.2], 'float', 'l2', 3);
+----
+8 0.020000
+6 0.060000
+4 0.100000
+
+query I
+EXPLAIN SELECT c1, Distance() FROM cached_knn_scan SEARCH MATCH VECTOR (c2, [0.3, 0.3, 0.2, 0.2], 'float', 'l2', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [c1 (#0), DISTANCE (#1)]
+ -> Read cache (2)
+    - table name: (default_db.cached_knn_scan)
+    - output columns: [c1, __score, __rowid]
+
+query I
+SELECT c1, Distance() FROM cached_knn_scan SEARCH MATCH VECTOR (c2, [0.3, 0.3, 0.2, 0.2], 'float', 'l2', 3);
+----
+8 0.020000
+6 0.060000
+4 0.100000
+
+query I
+EXPLAIN SELECT c1, Distance() FROM cached_knn_scan SEARCH MATCH VECTOR (c2, [0.3, 0.3, 0.2, 0.1], 'float', 'l2', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [c1 (#0), DISTANCE (#1)]
+ -> KNN SCAN (2)
+    - table name: cached_knn_scan(default_db.cached_knn_scan)
+    - table index: #4
+    - embedding info: c2
+      - element type: FLOAT32
+      - dimension: 4
+      - distance type: L2
+      - query embedding: [0.3,0.3,0.2,0.1]
+    - output columns: [c1, __score, __rowid]
+
+statement ok
+DROP TABLE cached_knn_scan;
+
diff --git a/test/sql/dql/result_cache/cached_limit.slt b/test/sql/dql/result_cache/cached_limit.slt
new file mode 100644
index 0000000000..1512b1335c
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_limit.slt
@@ -0,0 +1,76 @@
+statement ok
+DROP TABLE IF EXISTS cached_limit_fulltext;
+
+statement ok
+CREATE TABLE cached_limit_fulltext(doctitle varchar DEFAULT '', docdate varchar DEFAULT '', body varchar DEFAULT '');
+
+statement ok
+COPY cached_limit_fulltext FROM '/var/infinity/test_data/enwiki_99.csv' WITH ( DELIMITER '\t', FORMAT CSV );
+
+statement ok
+CREATE INDEX ft_index ON cached_limit_fulltext(body) USING FULLTEXT;
+
+query I
+EXPLAIN SELECT ROW_ID() FROM cached_limit_fulltext SEARCH MATCH TEXT ('body^5', 'American', 'topn=10') LIMIT 3;
+----
+ PROJECT (4)
+  - table index: #4
+  - expressions: [ROW_ID (#1)]
+ -> LIMIT (3)
+    - limit: 3
+    - output columns: [__score, __rowid]
+   -> MATCH (2)
+      - table name: cached_limit_fulltext(default_db.cached_limit_fulltext)
+      - table index: #1
+      - match expression: MATCH TEXT ('body^5', 'American', 'topn=10')
+      - index filter: None
+      - leftover filter: None
+      - output columns: [__score, __rowid]
+
+query I
+SELECT ROW_ID() FROM cached_limit_fulltext SEARCH MATCH TEXT ('body^5', 'American', 'topn=10') LIMIT 3;
+----
+94
+95
+78
+
+query I
+EXPLAIN SELECT ROW_ID() FROM cached_limit_fulltext SEARCH MATCH TEXT ('body^5', 'American', 'topn=10') LIMIT 3 OFFSET 3;
+----
+ PROJECT (4)
+  - table index: #4
+  - expressions: [ROW_ID (#1)]
+ -> LIMIT (3)
+    - limit: 3
+    - offset: 3
+    - output columns: [__score, __rowid]
+   -> Read cache (2)
+      - table name: (default_db.cached_limit_fulltext)
+      - output columns: [__score, __rowid]
+
+query I
+SELECT ROW_ID() FROM cached_limit_fulltext SEARCH MATCH TEXT ('body^5', 'American', 'topn=10') LIMIT 3 OFFSET 3;
+----
+72
+66
+54
+
+query I
+EXPLAIN SELECT ROW_ID() FROM cached_limit_fulltext SEARCH MATCH TEXT ('body^5', 'American', 'topn=30') LIMIT 3;
+----
+ PROJECT (4)
+  - table index: #4
+  - expressions: [ROW_ID (#1)]
+ -> LIMIT (3)
+    - limit: 3
+    - output columns: [__score, __rowid]
+   -> MATCH (2)
+      - table name: cached_limit_fulltext(default_db.cached_limit_fulltext)
+      - table index: #1
+      - match expression: MATCH TEXT ('body^5', 'American', 'topn=30')
+      - index filter: None
+      - leftover filter: None
+      - output columns: [__score, __rowid]
+
+statement ok
+DROP TABLE cached_limit_fulltext;
diff --git a/test/sql/dql/result_cache/cached_sparse_scan.slt b/test/sql/dql/result_cache/cached_sparse_scan.slt
new file mode 100644
index 0000000000..7d66dd634c
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_sparse_scan.slt
@@ -0,0 +1,115 @@
+statement ok
+DROP TABLE IF EXISTS cached_sparse_scan;
+
+statement ok
+CREATE TABLE cached_sparse_scan(col1 INT, col2 SPARSE(FLOAT,100));
+
+statement ok
+COPY cached_sparse_scan FROM '/var/infinity/test_data/sparse_knn.csv' WITH (FORMAT CSV);
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> MatchSparseScan (2)
+    - table index: #1
+    - output columns: [col1, __score, __rowid]
+
+query I
+SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+4
+2
+1
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> Read cache (2)
+    - table name: (default_db.cached_sparse_scan)
+    - output columns: [col1, __score, __rowid]
+
+query I
+SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+4
+2
+1
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3) WHERE col1 < 4;
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> MatchSparseScan (2)
+    - table index: #1
+    - output columns: [col1, __score, __rowid]
+
+statement ok
+COPY cached_sparse_scan FROM '/var/infinity/test_data/sparse_knn.csv' WITH (FORMAT CSV);
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> MERGE MatchSparse (5)
+    - table name: cached_sparse_scan(default_db.cached_sparse_scan)
+    - table index: #1
+    - MatchSparse expression: MATCH SPARSE (col2, [Cast([0:1.000000,20:2.000000,80:3.000000] AS Sparse(float,int8,100))], INNER_PRODUCT, 3) WITH ()
+    - Top N: 3
+    - output columns: [col1, __score, __rowid]
+   -> MatchSparseScan (2)
+      - table index: #1
+      - output columns: [col1, __score, __rowid]
+
+query I
+SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+4
+4
+2
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> Read cache (2)
+    - table name: (default_db.cached_sparse_scan)
+    - output columns: [col1, __score, __rowid]
+
+query I
+SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3);
+----
+4
+4
+2
+
+query I
+EXPLAIN SELECT col1 FROM cached_sparse_scan SEARCH MATCH SPARSE (col2, [0:1.0,20:2.0,80:3.0], 'ip', 3) WHERE col1 < 4;
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [col1 (#0)]
+ -> MERGE MatchSparse (5)
+    - table name: cached_sparse_scan(default_db.cached_sparse_scan)
+    - table index: #1
+    - MatchSparse expression: MATCH SPARSE (col2, [Cast([0:1.000000,20:2.000000,80:3.000000] AS Sparse(float,int8,100))], INNER_PRODUCT, 3) WITH ()
+    - Top N: 3
+    - output columns: [col1, __score, __rowid]
+   -> MatchSparseScan (2)
+      - table index: #1
+      - output columns: [col1, __score, __rowid]
+
+statement ok
+DROP TABLE cached_sparse_scan;
+
diff --git a/test/sql/dql/result_cache/cached_tensor_scan.slt b/test/sql/dql/result_cache/cached_tensor_scan.slt
new file mode 100644
index 0000000000..a68df3d977
--- /dev/null
+++ b/test/sql/dql/result_cache/cached_tensor_scan.slt
@@ -0,0 +1,158 @@
+statement ok
+DROP TABLE IF EXISTS cached_tensor_scan;
+
+statement ok
+CREATE TABLE cached_tensor_scan (title VARCHAR, num INT, t TENSOR(FLOAT, 4), body VARCHAR);
+
+statement ok
+COPY cached_tensor_scan FROM '/var/infinity/test_data/tensor_maxsim.csv' WITH (DELIMITER ',', FORMAT CSV);
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#0), SCORE (#1)]
+ -> MatchTensorScan (2)
+    - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+    - table index: #1
+    - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3.5]], MAX_SIM)
+    - Top N: 10
+    - index filter: None
+    - leftover filter: None
+    - output columns: [title, __score, __rowid]
+
+query I
+SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+test22 636.870056
+test55 27.369999
+test66 11.910000
+test33 3.620001
+test77 2.260000
+test00 -5.190000
+test44 -5.190000
+test11 -9.660001
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#0), SCORE (#1)]
+ -> Read cache (2)
+    - table name: (default_db.cached_tensor_scan)
+    - output columns: [title, __score, __rowid]
+
+query I
+SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+test22 636.870056
+test55 27.369999
+test66 11.910000
+test33 3.620001
+test77 2.260000
+test00 -5.190000
+test44 -5.190000
+test11 -9.660001
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.0], 'float', 'maxsim', '') WHERE 10 > num;
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#1), SCORE (#2)]
+ -> MatchTensorScan (2)
+    - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+    - table index: #1
+    - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3]], MAX_SIM)
+    - Top N: 10
+    - index filter: None
+    - leftover filter: 10 > CAST(num (#0) AS BigInt)
+    - output columns: [num, title, __score, __rowid]
+
+statement ok
+COPY cached_tensor_scan FROM '/var/infinity/test_data/tensor_maxsim.csv' WITH (DELIMITER ',', FORMAT CSV);
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#0), SCORE (#1)]
+ -> MERGE MatchTensor (5)
+    - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+    - table index: #1
+    - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3.5]], MAX_SIM)
+    - Top N: 10
+    - output columns: [title, __score, __rowid]
+   -> MatchTensorScan (2)
+      - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+      - table index: #1
+      - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3.5]], MAX_SIM)
+      - Top N: 10
+      - index filter: None
+      - leftover filter: None
+      - output columns: [title, __score, __rowid]
+
+query I
+SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+test22 636.870056
+test22 636.870056
+test55 27.369999
+test55 27.369999
+test66 11.910000
+test66 11.910000
+test33 3.620001
+test33 3.620001
+test77 2.260000
+test77 2.260000
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#0), SCORE (#1)]
+ -> Read cache (2)
+    - table name: (default_db.cached_tensor_scan)
+    - output columns: [title, __score, __rowid]
+
+query I
+SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.5], 'float', 'maxsim', '');
+----
+test22 636.870056
+test22 636.870056
+test55 27.369999
+test55 27.369999
+test66 11.910000
+test66 11.910000
+test33 3.620001
+test33 3.620001
+test77 2.260000
+test77 2.260000
+
+query I
+EXPLAIN SELECT title, SCORE() FROM cached_tensor_scan SEARCH MATCH TENSOR (t, [0.0, -10.0, 0.0, 0.7, 9.2, 45.6, -55.8, 3.0], 'float', 'maxsim', '') WHERE 10 > num;
+----
+ PROJECT (3)
+  - table index: #4
+  - expressions: [title (#1), SCORE (#2)]
+ -> MERGE MatchTensor (5)
+    - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+    - table index: #1
+    - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3]], MAX_SIM)
+    - Top N: 10
+    - output columns: [num, title, __score, __rowid]
+   -> MatchTensorScan (2)
+      - table name: cached_tensor_scan(default_db.cached_tensor_scan)
+      - table index: #1
+      - MatchTensor expression: MATCH TENSOR (t, [[0,-10,0,0.7],[9.2,45.6,-55.8,3]], MAX_SIM)
+      - Top N: 10
+      - index filter: None
+      - leftover filter: 10 > CAST(num (#0) AS BigInt)
+      - output columns: [num, title, __score, __rowid]
+
+statement ok
+DROP TABLE cached_tensor_scan;