[opt](segment) Ignore not-found segments in query and load paths

be/src/common/config.cpp

@@ -1643,6 +1643,8 @@ DEFINE_mBool(enable_parquet_page_index, "true");
 
 DEFINE_mBool(ignore_not_found_file_in_external_table, "true");
 
+DEFINE_mBool(ignore_not_found_segment, "true");
+
 DEFINE_mBool(enable_hdfs_mem_limiter, "true");
 
 DEFINE_mInt16(topn_agg_limit_multiplier, "2");

be/src/common/config.h

@@ -1704,6 +1704,11 @@ DECLARE_mBool(enable_parquet_page_index);
 // Default is true, if set to false, the not found file will result in query failure.
 DECLARE_mBool(ignore_not_found_file_in_external_table);
 
+// Whether to ignore IO errors (NOT_FOUND, EIO) when loading segment files in native olap tables.
+// Default is true. When a segment file is missing or has IO errors,
+// the query/load will skip the failing segment instead of reporting error to users.
+DECLARE_mBool(ignore_not_found_segment);
+
 DECLARE_mBool(enable_hdfs_mem_limiter);
 
 // Define how many percent data in hashtable bigger than limit

be/src/storage/rowset/beta_rowset.cpp

@@ -251,7 +251,15 @@ Status BetaRowset::load_segments(int64_t seg_id_begin, int64_t seg_id_end,
     int64_t seg_id = seg_id_begin;
     while (seg_id < seg_id_end) {
         std::shared_ptr<segment_v2::Segment> segment;
-        RETURN_IF_ERROR(load_segment(seg_id, nullptr, &segment));
+        auto st = load_segment(seg_id, nullptr, &segment);
+        if ((st.is<ErrorCode::NOT_FOUND>() || st.is<ErrorCode::IO_ERROR>()) &&
+            config::ignore_not_found_segment) {
+            LOG(WARNING) << "segment io error, skip it. rowset_id=" << rowset_id()
+                         << ", seg_id=" << seg_id << ", status=" << st;
+            seg_id++;
+            continue;
+        }
+        RETURN_IF_ERROR(st);
         segments->push_back(std::move(segment));
         seg_id++;
     }
@@ -260,6 +268,12 @@ Status BetaRowset::load_segments(int64_t seg_id_begin, int64_t seg_id_end,
 
 Status BetaRowset::load_segment(int64_t seg_id, OlapReaderStatistics* stats,
                                 segment_v2::SegmentSharedPtr* segment) {
+    DBUG_EXECUTE_IF("BetaRowset::load_segment.return_not_found", {
+        return Status::Error<ErrorCode::NOT_FOUND>("injected segment not found, seg_id={}", seg_id);
+    });
+    DBUG_EXECUTE_IF("BetaRowset::load_segment.return_io_error", {
+        return Status::Error<ErrorCode::IO_ERROR>("injected segment io error, seg_id={}", seg_id);
+    });
     auto fs = _rowset_meta->fs();
     if (!fs) {
         return Status::Error<INIT_FAILED>("get fs failed");

be/src/storage/segment/lazy_init_segment_iterator.cpp

@@ -17,6 +17,7 @@
 
 #include "storage/segment/lazy_init_segment_iterator.h"
 
+#include "storage/rowset/beta_rowset.h"
 #include "storage/segment/segment_loader.h"
 
 namespace doris::segment_v2 {
@@ -40,8 +41,16 @@ Status LazyInitSegmentIterator::init(const StorageReadOptions& opts) {
     std::shared_ptr<Segment> segment;
     {
         SegmentCacheHandle segment_cache_handle;
-        RETURN_IF_ERROR(SegmentLoader::instance()->load_segment(
-                _rowset, _segment_id, &segment_cache_handle, _should_use_cache, false, opts.stats));
+        auto st = SegmentLoader::instance()->load_segment(
+                _rowset, _segment_id, &segment_cache_handle, _should_use_cache, false, opts.stats);
+        if ((st.is<ErrorCode::NOT_FOUND>() || st.is<ErrorCode::IO_ERROR>()) &&
+            config::ignore_not_found_segment) {
+            LOG(WARNING) << "segment io error, skip it. rowset_id=" << _rowset->rowset_id()
+                         << ", seg_id=" << _segment_id << ", status=" << st;
+            // _inner_iterator remains nullptr, next_batch() will return EOF
+            return Status::OK();
+        }
+        RETURN_IF_ERROR(st);
         const auto& tmp_segments = segment_cache_handle.get_segments();
         segment = tmp_segments[0];
     }

be/src/storage/segment/lazy_init_segment_iterator.h

@@ -40,7 +40,9 @@ class LazyInitSegmentIterator : public RowwiseIterator {
     Status next_batch(Block* block) override {
         if (UNLIKELY(_need_lazy_init)) {
             RETURN_IF_ERROR(init(_read_options));
-            DCHECK(_inner_iterator != nullptr);
+        }
+        if (_inner_iterator == nullptr) {
+            return Status::EndOfFile("segment not found, skipped");
         }
 
         return _inner_iterator->next_batch(block);
@@ -49,6 +51,9 @@ class LazyInitSegmentIterator : public RowwiseIterator {
     const Schema& schema() const override { return *_schema; }
 
     Status current_block_row_locations(std::vector<RowLocation>* locations) override {
+        if (_inner_iterator == nullptr) {
+            return Status::EndOfFile("no segment loaded");
+        }
         return _inner_iterator->current_block_row_locations(locations);
     }
 

be/src/storage/segment/segment_loader.cpp

@@ -91,8 +91,15 @@ Status SegmentLoader::load_segments(const BetaRowsetSharedPtr& rowset,
         return Status::OK();
     }
     for (int64_t i = 0; i < rowset->num_segments(); i++) {
-        RETURN_IF_ERROR(load_segment(rowset, i, cache_handle, use_cache, need_load_pk_index_and_bf,
-                                     index_load_stats));
+        auto st = load_segment(rowset, i, cache_handle, use_cache, need_load_pk_index_and_bf,
+                               index_load_stats);
+        if ((st.is<ErrorCode::NOT_FOUND>() || st.is<ErrorCode::IO_ERROR>()) &&
+            config::ignore_not_found_segment) {
+            LOG(WARNING) << "segment io error, skip it. rowset_id=" << rowset->rowset_id()
+                         << ", seg_id=" << i << ", status=" << st;
+            continue;
+        }
+        RETURN_IF_ERROR(st);
     }
     cache_handle->set_inited();
     return Status::OK();