refactor(server): optimize rockdb batch query perf by lokidundun · Pull Request #2982 · apache/hugegraph

lokidundun · 2026-03-29T14:43:54Z

Purpose of the PR

Related [Improve] Gremlin query ids batch query to backend such as HBase/HStore #2674

Main Changes

The core change in this PR is a refactor/optimization of the RocksDB batch query path in three main areas: request coalescing, result backfilling, and shard-level parallelism control.
The focus is not on the API layer, but on how batch get is executed internally and how objects are reused, with the goal of reducing query latency and memory jitter under high concurrency.

Verifying these changes

RocksDBTableQueryByIdsTest
1.testVertexQueryByIdsWithAllExistingIds
2. testVertexQueryByIdsWithExistingAndMissingIdsMixed
3. testVertexQueryByIdsDuplicateIds
4. testEdgeOutQueryByIdsWithAllExistingIds
5. testEdgeInQueryByIdsWithAllExistingIds
6. testVertexQueryByIdsFailsWhenHasChanges
7. testPublicQueryMultiIdsFails
8. testPublicQuerySingleIdFails

EdgeCoreTest
9. testQueryEdgesByNonConsecutiveDuplicateIds — graph.edges(id1, id2, id1)

Unit test: RocksDBTableQueryByIdsTest (8 tests) — covers multi-get path, duplicate ids, missing ids, hasChanges guard
Integration test: EdgeCoreTest#testQueryEdgesByNonConsecutiveDuplicateIds — verify graph.edges(id1, id2, id1) via public API
Integration test: EdgeCoreTest#testQueryEdgesByIdWithGraphAPI — verify adjacent duplicate ids (graph.edges(id, id))
CI: HugeGraph-Server CI / RocksDB backend

Does this PR potentially affect the following parts?

Dependencies (add/update license info & regenerate_known_dependencies.sh)
Modify configurations
The public API
Other affects (typed here)
Nope

Documentation Status

Doc - TODO
Doc - Done
Doc - No Need

lokidundun · 2026-03-30T14:38:27Z

This CI failure is unrelated to the changes in this PR. The PR focuses on optimizing RocksDB batch query performance, and the failing build check does not involve the code modified here.

imbajin · 2026-03-31T06:56:02Z

Already rerun CI (also could check the tests could pass in local env)

imbajin · 2026-03-31T08:03:19Z

seems a little strange (after rerun 3 times still failed)

Temporarily use super.queryByIds() instead of getByIds() for batch version support.

lokidundun · 2026-04-06T11:02:10Z

@imbajin could you please take another look when you are convenient❤️

Copilot

Pull request overview

This PR introduces batched backend fetching for queryVerticesByIds() to reduce overhead when querying many vertex ids (e.g., g.V(id1, id2, ...)) by splitting backend id lookups into multiple IdQuery requests.

Changes:

Collect backend-only vertex ids during queryVerticesByIds() and issue backend queries in batches using query.batch_size.
Add per-batch capacity checks before executing backend queries.
Minor formatting adjustment in RocksDB table iterator helper signature.

Reviewed changes

Copilot reviewed 1 out of 2 changed files in this pull request and generated 5 comments.

File	Description
hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/backend/tx/GraphTransaction.java	Batch backend id queries in `queryVerticesByIds()` instead of building a single `IdQuery` for all backend ids.
hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java	Formatting-only change to method parameter indentation.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-06T15:35:24Z

+        if (!backendIds.isEmpty()) {
            // Query from backend store
-            query.mustSortByInput(false);
-            Iterator<HugeVertex> it = this.queryVerticesFromBackend(query);
-            QueryResults.fillMap(it, vertices);
+            final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();
+            for (int i = 0; i < backendIds.size(); i += batch) {
+                int end = Math.min(i + batch, backendIds.size());
+                IdQuery query = new IdQuery(type);


The PR title says this is a RocksDB optimization, but the functional change here is backend-agnostic batching in GraphTransaction (affecting all stores, especially RPC-based ones). Please align the PR title (or add RocksDB-specific changes) so the intent matches what’s actually being modified.

Copilot · 2026-04-06T15:35:24Z

@@ -799,17 +800,30 @@ protected Iterator<Vertex> queryVerticesByIds(Object[] vertexIds, boolean adjace
                // Found from local tx
                vertices.put(vertex.id(), vertex);
            } else {
-                // Prepare to query from backend store
-                query.query(id);
+                // store the IDs queried from backend
+                backendIds.add(id);
            }


This change allocates backendIds as a second full list of ids (in addition to ids), which doubles memory usage for large g.V(id1,id2,...) calls (up to Query.DEFAULT_CAPACITY). Consider batching/issuing backend IdQuery requests incrementally during the main loop (flush when reaching batch size) to avoid retaining all backend ids at once.

Copilot · 2026-04-06T15:35:25Z

+            final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();
+            for (int i = 0; i < backendIds.size(); i += batch) {
+                int end = Math.min(i + batch, backendIds.size());
+                IdQuery query = new IdQuery(type);
+                for (int j = i; j < end; j++) {
+                    Id id = backendIds.get(j);
+                    query.query(id);
+                }


With batching, duplicated ids that fall into different batches will trigger repeated backend reads/RPCs for the same id. You can keep the output behavior (duplicates preserved via ids) while deduplicating backend fetches (e.g., track a seen-set for backendIds or build per-batch unique ids) to avoid redundant backend queries.

Copilot · 2026-04-06T15:35:25Z

-            query.mustSortByInput(false);
-            Iterator<HugeVertex> it = this.queryVerticesFromBackend(query);
-            QueryResults.fillMap(it, vertices);
+            final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();


final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size(); is effectively always this.batchSize because query.batch_size is configured with a minimum of 1 (see CoreOptions.QUERY_BATCH_SIZE). Removing the dead fallback branch will simplify the code.

Suggested change

final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();

final int batch = this.batchSize;

Copilot · 2026-04-06T15:35:25Z

+        if (!backendIds.isEmpty()) {
            // Query from backend store
-            query.mustSortByInput(false);
-            Iterator<HugeVertex> it = this.queryVerticesFromBackend(query);
-            QueryResults.fillMap(it, vertices);
+            final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();
+            for (int i = 0; i < backendIds.size(); i += batch) {
+                int end = Math.min(i + batch, backendIds.size());
+                IdQuery query = new IdQuery(type);
+                for (int j = i; j < end; j++) {
+                    Id id = backendIds.get(j);
+                    query.query(id);
+                }
+                // Single batch capacity check
+                Query.checkForceCapacity(query.idsSize());
+
+                // Query from backend store
+                query.mustSortByInput(false);
+                Iterator<HugeVertex> it = this.queryVerticesFromBackend(query);
+                QueryResults.fillMap(it, vertices);
+            }


The new multi-batch path isn’t covered by tests. Please add a unit/integration test that exercises queryVerticesByIds() with vertexIds.length > query.batch_size, including (1) duplicates across a batch boundary and (2) mixed local-tx + backend ids, to ensure results and NotFoundException behavior remain unchanged.

imbajin · 2026-04-11T15:34:53Z

        // NOTE: allowed duplicated vertices if query by duplicated ids
        List<Id> ids = InsertionOrderUtil.newList();
        Map<Id, HugeVertex> vertices = new HashMap<>(vertexIds.length);
+        Set<Id> fetchedIds = InsertionOrderUtil.newSet();


⚠️ 这里新增 fetchedIds 之后，非相邻的重复 id 也会被全局去重；而旧逻辑里 IdQuery.query() 只会折叠相邻重复 id。最终返回结果看起来应该还是保持重复输出，但真实的后端访问路径已经变了。建议补一个回归测试，至少覆盖 超过 query.batch_size、跨 batch 的重复 id、缺失 id + checkMustExist 这几个组合场景，避免后面再改这里时把语义悄悄带偏。

imbajin · 2026-04-11T15:34:54Z

        Map<Id, HugeVertex> vertices = new HashMap<>(vertexIds.length);
+        Set<Id> fetchedIds = InsertionOrderUtil.newSet();
+        IdQuery batchQuery = null;
+        final int batchSize = this.batchSize;


⚠️ 这里把 batching 放在 GraphTransaction 通用层后，会影响所有 backend，而不只是 issue #2674 里提到的 RPC backend。

以 RocksDB 为例，当前 queryByIds() 仍然是逐 id 展开查询，并没有真正走 multi-get；现在强制按 query.batch_size 拆成多个 IdQuery，很可能只是增加额外的 query/iterator 次数。建议把这类分批策略下沉到具体 backend，或者至少通过 feature/store type 把它限定在 HBase/HStore 这类 RPC backend 上，避免把针对性优化变成全局行为变化。

PS: 后续我们应该让 RocksDB 使用上原生的 multi-get API (这应该是之前的 TODO)

GraphTransaction 不再按 batch_size 拆分 ID，一次性下发完整 IdQuery；

RocksDBTables.Vertex/Edge 已覆写 queryByIds()，在 !session.hasChanges() 时走 multiGetAsList() 原生批量读取，脏 session 安全回退到逐 id scan；

Copilot

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 5 comments.

+            @Override
+            public byte[] get(String table, byte[] key) {
+                throw new AssertionError(
+                        "reads should not be performed when hasChanges");
+            }
+


+        try {
+            BackendColumnIterator iter = this.vertexTable.queryByIds(mockSession, ids);
+            // FlatMapperIterator is lazy; trigger evaluation to hit the mock
+            iter.hasNext();
+            Assert.fail("queryByIds should fail when session has pending changes");
+        } catch (AssertionError e) {
+            Assert.assertTrue(e.getMessage().contains("hasChanges"));
+        }
+    }


+    protected BackendColumnIterator queryByIdsWithGet(RocksDBSessions.Session session,
+                                                      Collection<Id> ids) {
+        if (ids.size() == 1) {
+            return this.queryById(session, ids.iterator().next());
+        }
+
+        if (!session.hasChanges()) {
+            return this.getByIds(session, ids);
+        }
+
+        // NOTE: this will lead to lazy create rocksdb iterator
+        return BackendColumnIterator.wrap(new FlatMapperIterator<>(
+                ids.iterator(), id -> this.queryById(session, id)
+        ));
+    }


+            @Override
+            public byte[] get(String table, byte[] key) {
+                throw new AssertionError(
+                        "reads should not be performed when hasChanges");
+            }
+


+        try {
+            BackendColumnIterator iter = this.vertexTable.queryByIds(mockSession, ids);
+            // FlatMapperIterator is lazy; trigger evaluation to hit the mock
+            iter.hasNext();
+            Assert.fail("queryByIds should fail when session has pending changes");
+        } catch (AssertionError e) {
+            Assert.assertTrue(e.getMessage().contains("hasChanges"));
+        }
+    }


imbajin

Found one additional test coverage issue on the current head. I also +1'd the existing Copilot comments that already cover the hasChanges fallback problem.

imbajin · 2026-05-29T10:02:05Z

+        List<Id> ids = Arrays.asList(id1, id2, id1);
+        BackendColumnIterator iter = this.vertexTable.queryByIds(this.rocks.session(), ids);
+
+        Map<String, String> results = toResultMap(iter);


This test does not actually protect the duplicate-id behavior because toResultMap() collapses duplicate rows by key before the assertion. If queryByIds() regressed and returned v1, v2, v1, the map would still contain only two entries and this test would pass. Since this PR explicitly deduplicates ids before multi-get, please assert the iterator output sequence/count directly (for example collect the column names into a list) so duplicate backend results would fail the test.

Copilot

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (1)

hugegraph-server/hugegraph-rocksdb/src/main/java/org/apache/hugegraph/backend/store/rocksdb/RocksDBTable.java:250

getByIds() checks ids.size()==1 before de-duplicating, so an input like [id1, id1] takes the multi-get path even though there's only one unique key. Since this PR explicitly de-dups ids for performance, it would be more consistent (and slightly cheaper) to de-duplicate first and then apply the single-key fast path.

    protected BackendColumnIterator getByIds(RocksDBSessions.Session session,
                                             Collection<Id> ids) {
        if (ids.size() == 1) {
            return this.getById(session, ids.iterator().next());
        }

        Collection<Id> uniqueIds = ids instanceof Set ? ids : new LinkedHashSet<>(ids);
        List<byte[]> keys = new ArrayList<>(uniqueIds.size());
        for (Id id : uniqueIds) {
            keys.add(id.asBytes());
        }
        return session.get(this.table(), keys);
    }

lokidundun · 2026-05-30T16:11:49Z

        @Override
        protected BackendColumnIterator queryByIds(RocksDBSessions.Session session,
                                                   Collection<Id> ids) {
-            // TODO: use getByIds() after batch version multi-get is ready
-            return super.queryByIds(session, ids);
+            return this.queryByIdsWithGet(session, ids);
        }


Catch! This PR is RocksDB-only. I’ve updated the description to change closes 2674 to related 2674

VGalaxies · 2026-06-01T03:53:39Z


+    protected BackendColumnIterator queryByIdsWithGet(RocksDBSessions.Session session,
+                                                      Collection<Id> ids) {
+        E.checkState(!session.hasChanges(),


Non-blocking: enabling queryByIdsWithGet() for vertex/edge changes pending-write behavior: any session.hasChanges() now throws before even the single-id path. Please confirm all callers reach this only after commit/rollback, or keep the old per-id fallback for pending sessions and add a test through a public query path.

codecov · 2026-06-01T08:36:46Z

Codecov Report

❌ Patch coverage is 50.00000% with 3 lines in your changes missing coverage. Please review.
✅ Project coverage is 31.14%. Comparing base (9126c80) to head (73588c4).
⚠️ Report is 27 commits behind head on master.

Files with missing lines	Patch %	Lines
.../hugegraph/backend/store/rocksdb/RocksDBTable.java	25.00%	1 Missing and 2 partials ⚠️

Additional details and impacted files

@@             Coverage Diff              @@
##             master    #2982      +/-   ##
============================================
- Coverage     35.57%   31.14%   -4.43%     
+ Complexity      333      264      -69     
============================================
  Files           801      803       +2     
  Lines         67592    68232     +640     
  Branches       8790     8964     +174     
============================================
- Hits          24045    21252    -2793     
- Misses        40985    44570    +3585     
+ Partials       2562     2410     -152

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

imbajin

当前 head 上还有一个阻塞合入的 correctness 问题：Edge 的公开查询路径可能因为 RocksDB table 层全局去重而吞掉非相邻重复 id。hasChanges() 行为变化已有现有线程覆盖，这里不重复发 inline。

imbajin · 2026-06-03T13:42:48Z


-        List<byte[]> keys = new ArrayList<>(ids.size());
-        for (Id id : ids) {
+        Collection<Id> uniqueIds = ids instanceof Set ? ids : new LinkedHashSet<>(ids);


‼️ 这里的全局去重会让 Edge 的公开查询路径吞掉非相邻重复 id，属于用户可见的结果集回归。

完整路径是：

graph.edges(e1, e2, e1) | v GraphTransaction.queryEdgesByIds() | | IdQuery.query() 只折叠相邻重复 id | [e1, e2, e1] => query.idsSize()==3, ids.size()==3 v edges.isEmpty() && query.idsSize() == ids.size() | | 命中 fast path，直接返回 backend iterator v RocksDBTables.Edge.queryByIds() | v RocksDBTable.getByIds() | | new LinkedHashSet<>(ids) 全局去重 v [e1, e2, e1] => [e1, e2]

也就是说，GraphTransaction 只有在检测到重复 id 时才会回到按原始 ids 重建结果的慢路径；但当前 fast path 只能识别相邻重复，识别不了 e1, e2, e1 这种非相邻重复。旧的 scan/flat-map 路径会按输入 id 展开 3 次查询，新路径在这里被压成 2 个 key，最终返回结果会少一条。

建议不要在 Edge 的这条 fast path 上做 table-level 全局去重，或者在 transaction 层改成能检测任意重复 id 后再决定是否直接返回 backend iterator。

imbajin · 2026-06-03T13:42:48Z

+        this.rocks.session().put(this.vertexTable.table(), id2.asBytes(), getBytes("value2"));
+        this.commit();
+
+        List<Id> ids = Arrays.asList(id1, id2, id1);


⚠️ 这个 helper-level 测试把 [id1, id2, id1] 固化成“RocksDB table 层去重后只返回 2 条”，但它没有覆盖真正会出问题的公开 Edge 查询路径。

需要补一个从 Graph API / GraphTransaction 进入的回归测试，至少覆盖非相邻重复 edge id：

Object e1 = ...; Object e2 = ...; List<Edge> edges = ImmutableList.copyOf(graph.edges(e1, e2, e1)); Assert.assertEquals(3, edges.size());

图例：

helper test: TestEdgeTable.queryByIds([e1, e2, e1]) -> 只验证 table 层去重行为真实风险路径: graph.edges(e1, e2, e1) -> GraphTransaction fast path -> RocksDB Edge queryByIds -> table 层去重 -> 返回 2 条而不是 3 条

如果保留当前测试，它会让“后端吞掉重复 id”看起来像预期行为；但对 graph.edges(...) 的公开语义来说，重复输入应保留重复输出，现有 graph.edges(id, id) 测试已经固定了这个契约。

Copilot

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

imbajin

Current implementation looks mostly converged. I’m leaving two non-CI follow-ups: one test assertion should be tightened, and the PR verification section should be filled in.

imbajin · 2026-06-04T13:24:21Z

+
+        // Graph API does not guarantee duplicate results for duplicate ids
+        List<Edge> edges = ImmutableList.copyOf(graph.edges(id1, id2, id1));
+        Assert.assertTrue(edges.size() >= 2);


⚠️ 这个回归测试还没有真正锁住非连续重复 edge id 的语义。

当前 graph.edges(id1, id2, id1) 只断言 edges.size() >= 2 且结果包含 id1/id2。如果实现再次退化成错误结果 [id1, id2]，这个测试仍然会通过。

这里风险路径正是：

graph.edges(id1, id2, id1) -> GraphTransaction fast path -> RocksDB Edge queryByIds() -> backend iterator 直接返回

建议把断言改成精确校验 3 条结果，并确认顺序或至少确认 id1 出现两次：

Assert.assertEquals(3, edges.size()); Assert.assertEquals(id1, edges.get(0).id()); Assert.assertEquals(id2, edges.get(1).id()); Assert.assertEquals(id1, edges.get(2).id());

这样才能真正覆盖这次 PR 要修住的 Graph API multiplicity 行为。

之前就是这样的，但是在 IdQuery.query(Id) 只跳过连续重复（和上一个相同的 ID）。[id1, id2, id1] 中第二个 id1 的上一个是 id2，不相等，所以没被跳过，query.idsSize() 返回 3，跟 ids.size() 相等，快路径被误触发。ci 无法通过

这个 assert 放在 shared EdgeCoreTest 里确实不合适，因为 memory backend 当前会返回 2，CI failure 也验证了这一点。这个 core test 作为跨 backend smoke 保留弱断言可以接受；

RocksDB-specific multiplicity 现在由 RocksDBTableQueryByIdsTest 的 iterator sequence/count 覆盖不再阻塞这个点。

imbajin · 2026-06-04T13:24:27Z

⚠️ PR 描述里的 Verifying these changes 还停留在模板状态：

- [ ] Need tests and can be verified as follows:
    - xxx

这个 PR 已经来回调整过几轮，最终 scope 也收敛为 RocksDB-only multi-get 优化。建议把验证项补实，至少列出当前新增/应运行的测试，例如：

- RocksDB unit: RocksDBTableQueryByIdsTest
- RocksDB core: EdgeCoreTest#testQueryEdgesByNonConsecutiveDuplicateIds
- CI: HugeGraph-Server CI / rocksdb backend

这样后续 reviewer 可以直接确认当前 head 的验证边界，避免继续围绕“是否真的覆盖了最终实现路径”反复确认。

lokidundun · 2026-06-04T16:16:43Z

⚠️ PR 描述里的 Verifying these changes 还停留在模板状态：
- [ ] Need tests and can be verified as follows:
    - xxx
这个 PR 已经来回调整过几轮，最终 scope 也收敛为 RocksDB-only multi-get 优化。建议把验证项补实，至少列出当前新增/应运行的测试，例如：
- RocksDB unit: RocksDBTableQueryByIdsTest
- RocksDB core: EdgeCoreTest#testQueryEdgesByNonConsecutiveDuplicateIds
- CI: HugeGraph-Server CI / rocksdb backend
这样后续 reviewer 可以直接确认当前 head 的验证边界，避免继续围绕“是否真的覆盖了最终实现路径”反复确认。

done

optimize: Optimize RocksDB batch query performance

5ba6d4a

dosubot Bot added size:XS This PR changes 0-9 lines, ignoring generated files. perf store Store module labels Mar 29, 2026

github-project-automation Bot moved this to In progress in HugeGraph PD-Store Tasks Mar 29, 2026

github-project-automation Bot added this to HugeGraph PD-Store Tasks Mar 29, 2026

lokidundun closed this Mar 30, 2026

github-project-automation Bot moved this from In progress to Done in HugeGraph PD-Store Tasks Mar 30, 2026

lokidundun reopened this Mar 30, 2026

github-project-automation Bot moved this from Done to In progress in HugeGraph PD-Store Tasks Mar 30, 2026

lokidundun and others added 5 commits March 31, 2026 20:28

Refactor getByIds to queryByIds in RocksDBTable

f5405a0

Modify queryByIds to use super method temporarily

939ace0

Temporarily use super.queryByIds() instead of getByIds() for batch version support.

Refactor queryByIds to getByIds with HashSet

502c7df

Update RocksDBTables.java

352f66b

fix: fix ci

0d9052d

dosubot Bot added size:M This PR changes 30-99 lines, ignoring generated files. and removed size:XS This PR changes 0-9 lines, ignoring generated files. labels Apr 6, 2026

imbajin requested a review from Copilot April 6, 2026 15:30

Copilot started reviewing on behalf of imbajin April 6, 2026 15:31 View session

Copilot AI reviewed Apr 6, 2026

View reviewed changes

lokidundun changed the title ~~optimize: Optimize RocksDB batch query performance~~ optimize: Optimize batch query performance Apr 7, 2026

optimize: optimize the batch query

45298f9

imbajin reviewed Apr 11, 2026

View reviewed changes

optimize: optimize rockDb query

223fb28

dosubot Bot removed the size:M This PR changes 30-99 lines, ignoring generated files. label Apr 16, 2026

imbajin requested a review from Copilot May 29, 2026 09:38

Copilot started reviewing on behalf of imbajin May 29, 2026 09:38 View session

Copilot AI reviewed May 29, 2026

View reviewed changes

imbajin reviewed May 29, 2026

View reviewed changes

fix: refine queryByIdsWithGet hasChanges guard and align tests

0432f58

imbajin requested a review from Copilot May 30, 2026 14:18

Copilot started reviewing on behalf of imbajin May 30, 2026 14:18 View session

Copilot AI reviewed May 30, 2026

View reviewed changes

VGalaxies reviewed Jun 1, 2026

View reviewed changes

fix query test exception

cb98e63

lokidundun requested a review from imbajin June 1, 2026 08:37

imbajin requested a review from Copilot June 3, 2026 13:33

Copilot started reviewing on behalf of imbajin June 3, 2026 13:33 View session

imbajin reviewed Jun 3, 2026

View reviewed changes

Copilot AI reviewed Jun 3, 2026

View reviewed changes

test: verify non-consecutive duplicate ids are preserved in edge queries

73588c4

lokidundun requested a review from imbajin June 4, 2026 10:25

fix ci

f2d2e29

imbajin reviewed Jun 4, 2026

View reviewed changes

add detail test

b11ec06

github-actions Bot removed the inactive label Jun 4, 2026

imbajin approved these changes Jun 5, 2026

View reviewed changes

dosubot Bot added the lgtm This PR has been approved by a maintainer label Jun 5, 2026

github-project-automation Bot moved this from In progress to In review in HugeGraph PD-Store Tasks Jun 5, 2026

imbajin changed the title ~~optimize: Optimize rockdb batch query performance~~ refactor(server): optimize rockdb batch query perf Jun 5, 2026

imbajin merged commit 1f61c48 into apache:master Jun 5, 2026
15 checks passed

github-project-automation Bot moved this from In review to Done in HugeGraph PD-Store Tasks Jun 5, 2026

	final int batch = this.batchSize > 0 ? this.batchSize : backendIds.size();
	final int batch = this.batchSize;

Conversation

lokidundun commented Mar 29, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Purpose of the PR

Main Changes

Verifying these changes

Does this PR potentially affect the following parts?

Documentation Status

Uh oh!

lokidundun commented Mar 30, 2026

Uh oh!

imbajin commented Mar 31, 2026

Uh oh!

imbajin commented Mar 31, 2026

Uh oh!

lokidundun commented Apr 6, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Apr 6, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 6, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 6, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 6, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 6, 2026

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

imbajin Apr 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

imbajin left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

codecov Bot commented Jun 1, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

imbajin left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Uh oh!

lokidundun commented Mar 29, 2026 •

edited

Loading

imbajin Apr 11, 2026 •

edited

Loading

codecov Bot commented Jun 1, 2026 •

edited

Loading

lokidundun Jun 4, 2026 •

edited

Loading

imbajin Jun 5, 2026 •

edited

Loading