This is an automated email from the ASF dual-hosted git repository.

dataroaring pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git


The following commit(s) were added to refs/heads/master by this push:
     new 86e80427e7c [feat](cloud) get_mow_tablet_stats_and_meta support 
versioned read (#54778)
86e80427e7c is described below

commit 86e80427e7c508c21374f09d561c7313205e42d2
Author: meiyi <[email protected]>
AuthorDate: Thu Aug 14 20:54:57 2025 +0800

    [feat](cloud) get_mow_tablet_stats_and_meta support versioned read (#54778)
---
 cloud/src/meta-service/meta_service.cpp | 41 +++++++++++++++++++++++++++++----
 cloud/test/meta_service_test.cpp        | 38 +++++++++++++++++++++++++++++-
 2 files changed, 74 insertions(+), 5 deletions(-)

diff --git a/cloud/src/meta-service/meta_service.cpp 
b/cloud/src/meta-service/meta_service.cpp
index 327f9f796bc..b6cfd26530e 100644
--- a/cloud/src/meta-service/meta_service.cpp
+++ b/cloud/src/meta-service/meta_service.cpp
@@ -3915,6 +3915,7 @@ bool 
MetaServiceImpl::get_mow_tablet_stats_and_meta(MetaServiceCode& code, std::
     std::stringstream ss;
     bool is_versioned_read = is_version_read_enabled(instance_id);
     if (!config::enable_batch_get_mow_tablet_stats_and_meta) {
+        MetaReader reader(instance_id, txn_kv_.get());
         for (const auto& tablet_idx : request->tablet_indexes()) {
             // 1. get compaction cnts
             TabletStatsPB tablet_stat;
@@ -3949,7 +3950,27 @@ bool 
MetaServiceImpl::get_mow_tablet_stats_and_meta(MetaServiceCode& code, std::
                     return false;
                 }
             } else {
-                CHECK(false) << "versioned read is not supported yet";
+                err = reader.get_tablet_compact_stats(txn.get(), 
tablet_idx.tablet_id(),
+                                                      &tablet_stat, nullptr);
+                if (err == TxnErrorCode::TXN_TOO_OLD) {
+                    code = MetaServiceCode::OK;
+                    err = txn_kv_->create_txn(&txn);
+                    if (err != TxnErrorCode::TXN_OK) {
+                        code = cast_as<ErrCategory::CREATE>(err);
+                        ss << "failed to init txn when get tablet stats";
+                        msg = ss.str();
+                        return false;
+                    }
+                    err = reader.get_tablet_compact_stats(txn.get(), 
tablet_idx.tablet_id(),
+                                                          &tablet_stat, 
nullptr);
+                }
+                if (err != TxnErrorCode::TXN_OK) {
+                    code = cast_as<ErrCategory::READ>(err);
+                    msg = fmt::format("failed to get tablet compact stats, 
err={}, tablet_id={}",
+                                      err, tablet_idx.tablet_id());
+                    LOG(WARNING) << msg;
+                    return false;
+                }
             }
             
response->add_base_compaction_cnts(tablet_stat.base_compaction_cnt());
             
response->add_cumulative_compaction_cnts(tablet_stat.cumulative_compaction_cnt());
@@ -3980,7 +4001,19 @@ bool 
MetaServiceImpl::get_mow_tablet_stats_and_meta(MetaServiceCode& code, std::
                     return false;
                 }
             } else {
-                CHECK(false) << "versioned read is not supported yet";
+                err = reader.get_tablet_meta(txn.get(), 
tablet_idx.tablet_id(), &tablet_meta,
+                                             nullptr);
+                if (err != TxnErrorCode::TXN_OK) {
+                    ss << "failed to get versioned tablet meta"
+                       << (err == TxnErrorCode::TXN_KEY_NOT_FOUND ? " (not 
found)" : "")
+                       << " instance_id=" << instance_id << " tablet_id=" << 
tablet_idx.tablet_id()
+                       << " err=" << err;
+                    msg = ss.str();
+                    code = err == TxnErrorCode::TXN_KEY_NOT_FOUND
+                                   ? MetaServiceCode::TABLET_NOT_FOUND
+                                   : cast_as<ErrCategory::READ>(err);
+                    return false;
+                }
             }
             response->add_tablet_states(
                     
static_cast<std::underlying_type_t<TabletStatePB>>(tablet_meta.tablet_state()));
@@ -4054,8 +4087,8 @@ bool 
MetaServiceImpl::get_mow_tablet_stats_and_meta(MetaServiceCode& code, std::
         }
         for (size_t i = 0; i < tablet_meta_keys.size(); i++) {
             if (!tablet_meta_values[i].has_value()) {
-                code = cast_as<ErrCategory::READ>(err);
-                msg = fmt::format("failed to get tablet meta, err={} 
tablet_id={}", err,
+                code = MetaServiceCode::TABLET_NOT_FOUND;
+                msg = fmt::format("failed to get tablet meta (not found), 
tablet_id={}",
                                   request->tablet_indexes(i).tablet_id());
                 return false;
             }
diff --git a/cloud/test/meta_service_test.cpp b/cloud/test/meta_service_test.cpp
index f2fb620f9fb..4471b5a3658 100644
--- a/cloud/test/meta_service_test.cpp
+++ b/cloud/test/meta_service_test.cpp
@@ -294,7 +294,8 @@ void insert_rowset(MetaServiceProxy* meta_service, int64_t 
db_id, const std::str
 
 static void add_tablet_metas(MetaServiceProxy* meta_service, std::string 
instance_id,
                              int64_t table_id, int64_t index_id,
-                             const std::vector<std::array<int64_t, 2>>& 
tablet_idxes) {
+                             const std::vector<std::array<int64_t, 2>>& 
tablet_idxes,
+                             bool skip_tablet_meta = false) {
     std::unique_ptr<Transaction> txn;
     ASSERT_EQ(meta_service->txn_kv()->create_txn(&txn), TxnErrorCode::TXN_OK);
 
@@ -309,6 +310,9 @@ static void add_tablet_metas(MetaServiceProxy* 
meta_service, std::string instanc
         stats.set_cumulative_point(30);
         txn->put(stats_key, stats.SerializeAsString());
 
+        if (skip_tablet_meta) {
+            continue;
+        }
         doris::TabletMetaCloudPB tablet_pb;
         tablet_pb.set_table_id(table_id);
         tablet_pb.set_index_id(index_id);
@@ -5225,6 +5229,38 @@ TEST(MetaServiceTest, 
GetDeleteBitmapUpdateLockTabletStatsError) {
             ASSERT_EQ(cumulative_point, 30);
         }
     }
+
+    for (bool val : enable_batch_get_mow_tablet_stats_and_meta_vals) {
+        config::enable_batch_get_mow_tablet_stats_and_meta = val;
+        // 2.5 abnormal path, meeting error when reading tablets' meta
+        std::string instance_id = 
"test_get_delete_bitmap_update_lock_abnormal5";
+        [[maybe_unused]] auto* sp = SyncPoint::get_instance();
+        DORIS_CLOUD_DEFER {
+            SyncPoint::get_instance()->disable_processing();
+            SyncPoint::get_instance()->clear_all_call_backs();
+        };
+        sp->set_call_back("get_instance_id", [&](auto&& args) {
+            auto* ret = try_any_cast_ret<std::string>(args);
+            ret->first = instance_id;
+            ret->second = true;
+        });
+
+        sp->enable_processing();
+
+        int64_t db_id = 1000;
+        int64_t table_id = 2001;
+        int64_t index_id = 3001;
+        // [(partition_id, tablet_id)]
+        std::vector<std::array<int64_t, 2>> tablet_idxes {
+                {70001, 12345}, {80001, 3456}, {90001, 6789}};
+
+        add_tablet_metas(meta_service.get(), instance_id, table_id, index_id, 
tablet_idxes, true);
+
+        GetDeleteBitmapUpdateLockResponse res;
+        get_delete_bitmap_update_lock(meta_service.get(), res, db_id, 
table_id, index_id,
+                                      tablet_idxes, 5, 999999, -1, true);
+        ASSERT_EQ(res.status().code(), MetaServiceCode::TABLET_NOT_FOUND);
+    }
 }
 
 static std::string generate_random_string(int length) {


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to