You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by li...@apache.org on 2026/07/15 04:58:55 UTC

(skywalking) branch master updated: Migrate all BanyanDB storage read queries from the typed query-builder API to BydbQL (#13947)

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

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


The following commit(s) were added to refs/heads/master by this push:
     new 5f6496e72c Migrate all BanyanDB storage read queries from the typed query-builder API to BydbQL (#13947)
5f6496e72c is described below

commit 5f6496e72c9acab1ce6ef107f3a168f6eaff8f40
Author: mrproliu <74...@qq.com>
AuthorDate: Wed Jul 15 12:58:50 2026 +0800

    Migrate all BanyanDB storage read queries from the typed query-builder API to BydbQL (#13947)
---
 docker/.env                                        |   2 +-
 docs/en/changes/changes.md                         |   1 +
 .../library/banyandb/v1/client/BanyanDBClient.java | 119 ++++
 .../library-banyandb-client/src/main/proto         |   2 +-
 .../v1/client/BanyanDBBydbQLQueryTest.java         | 148 +++++
 .../banyandb/BanyanDBAggregationQueryDAO.java      |  52 +-
 .../plugin/banyandb/BanyanDBRecordsQueryDAO.java   |  22 +-
 .../plugin/banyandb/BanyanDBStorageClient.java     |  47 +-
 .../BanyanDBEBPFProfilingScheduleQueryDAO.java     |  18 +-
 .../measure/BanyanDBHierarchyQueryDAO.java         |  51 +-
 .../banyandb/measure/BanyanDBMetadataQueryDAO.java | 224 ++++----
 .../banyandb/measure/BanyanDBMetricsDAO.java       |  31 +-
 .../banyandb/measure/BanyanDBMetricsQueryDAO.java  |  41 +-
 .../measure/BanyanDBNetworkAddressAliasDAO.java    |  18 +-
 .../banyandb/measure/BanyanDBServiceLabelDAO.java  |  16 +-
 .../measure/BanyanDBTagAutocompleteQueryDAO.java   |  34 +-
 .../banyandb/measure/BanyanDBTopologyQueryDAO.java | 117 ++--
 .../banyandb/stream/AbstractBanyanDBDAO.java       | 615 +++++++++++----------
 .../banyandb/stream/BanyanDBAlarmQueryDAO.java     | 116 ++--
 .../BanyanDBAsyncProfilerTaskLogQueryDAO.java      |  14 +-
 .../stream/BanyanDBAsyncProfilerTaskQueryDAO.java  |  42 +-
 .../stream/BanyanDBBrowserLogQueryDAO.java         |  42 +-
 .../stream/BanyanDBEBPFProfilingDataDAO.java       |  19 +-
 .../stream/BanyanDBEBPFProfilingTaskDAO.java       |  73 +--
 .../banyandb/stream/BanyanDBEventQueryDAO.java     | 129 ++---
 .../banyandb/stream/BanyanDBJFRDataQueryDAO.java   |  20 +-
 .../banyandb/stream/BanyanDBLogQueryDAO.java       | 100 ++--
 .../banyandb/stream/BanyanDBPprofDataQueryDAO.java |  19 +-
 .../stream/BanyanDBPprofTaskLogQueryDAO.java       |  17 +-
 .../banyandb/stream/BanyanDBPprofTaskQueryDAO.java |  42 +-
 .../stream/BanyanDBProfileTaskLogQueryDAO.java     |  11 +-
 .../stream/BanyanDBProfileTaskQueryDAO.java        |  48 +-
 .../BanyanDBProfileThreadSnapshotQueryDAO.java     |  47 +-
 .../stream/BanyanDBSpanAttachedEventQueryDAO.java  |  26 +-
 .../storage/plugin/banyandb/stream/Conditions.java | 218 ++++++++
 .../banyandb/trace/BanyanDBTraceQueryDAO.java      | 173 +++---
 .../banyandb/trace/BanyanDBZipkinQueryDAO.java     | 159 ++----
 .../server/storage/plugin/banyandb/BanyanDBIT.java |  33 +-
 .../plugin/banyandb/stream/ConditionsTest.java     | 160 ++++++
 test/e2e-v2/script/env                             |   2 +-
 40 files changed, 1678 insertions(+), 1390 deletions(-)

diff --git a/docker/.env b/docker/.env
index 0861b0eed9..8ed3c4b6a4 100644
--- a/docker/.env
+++ b/docker/.env
@@ -6,6 +6,6 @@
 # docker compose up
 
 ELASTICSEARCH_IMAGE=docker.elastic.co/elasticsearch/elasticsearch-oss:7.4.2
-BANYANDB_IMAGE=ghcr.io/apache/skywalking-banyandb:69c8f4d20ebb6532ea4c16a7ed7114dd6ec9770b
+BANYANDB_IMAGE=ghcr.io/apache/skywalking-banyandb:38932b9113686cddb75739adf2ed2e75324a927a
 OAP_IMAGE=ghcr.io/apache/skywalking/oap:latest
 UI_IMAGE=ghcr.io/apache/skywalking-horizon-ui:latest
diff --git a/docs/en/changes/changes.md b/docs/en/changes/changes.md
index dcd40ce586..96a9800e99 100644
--- a/docs/en/changes/changes.md
+++ b/docs/en/changes/changes.md
@@ -334,6 +334,7 @@
 * Fix Envoy ALS rendering for the LAL live-debugger and the persisted log `content`: an Istio metadata-exchange peer in `common_properties.filter_state_objects` (legacy Wasm `wasm.*_peer` = `Any{BytesValue}` wrapping a FlatBuffer, or modern `*_peer` = `Any{Struct}`) is now decoded into the readable peer metadata (pod / namespace / labels) instead of an opaque `jsonformat-failed` envelope or base64. The serialization is hardened so a single un-printable field can no longer blank the whole [...]
 * Surface the effective BanyanDB configuration (`bydb.yml` / `bydb-topn.yml`) in the `/debugging/config/dump` admin API. Because the BanyanDB config moved to a separate file in 10.2.0, a BanyanDB deployment previously showed an empty `storage.banyandb` block in the dump; its post-environment-resolution values are now merged into the same response under `storage.banyandb.*` (TopN rules under `storage.banyandb.topN.*`), masked by the same secret-keyword list, via a generic `ConfigDumpExten [...]
 * Fix: an MQE `top_n(metric, N, order, attrX='value')` query whose attribute is not a column of the target metric now returns a descriptive MQE error instead of a raw storage `IOException` surfaced as `Internal IO exception, query metrics error.`. Attribute columns (`attr0..attrN`) exist only on decorated metrics (`service_*` / `endpoint_*` / `kubernetes_service_*`, set to the layer name via OAL `.decorator(...)`) and the MAL meter base; metrics such as relations or database / cache / mq [...]
+* Migrate all BanyanDB storage read queries from the typed query-builder API to BydbQL.
 
 #### UI
 * Add Airflow layer dashboards and menu i18n under Workflow Scheduler in Horizon UI (SWIP-7).
diff --git a/oap-server/server-library/library-banyandb-client/src/main/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBClient.java b/oap-server/server-library/library-banyandb-client/src/main/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBClient.java
index 7cc4d92c2b..616ab632f3 100644
--- a/oap-server/server-library/library-banyandb-client/src/main/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBClient.java
+++ b/oap-server/server-library/library-banyandb-client/src/main/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBClient.java
@@ -40,6 +40,8 @@ import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.skywalking.banyandb.bydbql.v1.BanyandbBydbql;
+import org.apache.skywalking.banyandb.bydbql.v1.BydbQLServiceGrpc;
 import org.apache.skywalking.banyandb.common.v1.BanyandbCommon;
 import org.apache.skywalking.banyandb.common.v1.BanyandbCommon.Group;
 import org.apache.skywalking.banyandb.common.v1.BanyandbCommon.Metadata;
@@ -54,6 +56,7 @@ import org.apache.skywalking.banyandb.database.v1.BanyandbDatabase.TopNAggregati
 import org.apache.skywalking.banyandb.database.v1.BanyandbDatabase.Trace;
 import org.apache.skywalking.banyandb.measure.v1.BanyandbMeasure;
 import org.apache.skywalking.banyandb.measure.v1.MeasureServiceGrpc;
+import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
 import org.apache.skywalking.banyandb.property.v1.BanyandbProperty;
 import org.apache.skywalking.banyandb.stream.v1.BanyandbStream;
 import org.apache.skywalking.banyandb.stream.v1.StreamServiceGrpc;
@@ -61,6 +64,7 @@ import org.apache.skywalking.banyandb.trace.v1.BanyandbTrace;
 import org.apache.skywalking.banyandb.trace.v1.TraceServiceGrpc;
 import org.apache.skywalking.library.banyandb.v1.client.auth.AuthInterceptor;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.HandleExceptionsWith;
+import org.apache.skywalking.library.banyandb.v1.client.metadata.Serializable;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.channel.ChannelManager;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.channel.DefaultChannelFactory;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.exception.BanyanDBException;
@@ -141,6 +145,10 @@ public class BanyanDBClient implements Closeable {
      */
     @Getter
     private TraceServiceGrpc.TraceServiceBlockingStub traceServiceBlockingStub;
+    /**
+     * gRPC blocking stub for BydbQL queries.
+     */
+    private BydbQLServiceGrpc.BydbQLServiceBlockingStub bydbQLServiceBlockingStub;
     /**
      * The connection status.
      */
@@ -206,6 +214,7 @@ public class BanyanDBClient implements Closeable {
                 streamServiceStub = StreamServiceGrpc.newStub(this.channel);
                 measureServiceStub = MeasureServiceGrpc.newStub(this.channel);
                 traceServiceStub = TraceServiceGrpc.newStub(this.channel);
+                bydbQLServiceBlockingStub = BydbQLServiceGrpc.newBlockingStub(this.channel);
                 isConnected = true;
             }
         } finally {
@@ -225,6 +234,7 @@ public class BanyanDBClient implements Closeable {
                 streamServiceStub = StreamServiceGrpc.newStub(this.channel);
                 measureServiceStub = MeasureServiceGrpc.newStub(this.channel);
                 traceServiceStub = TraceServiceGrpc.newStub(this.channel);
+                bydbQLServiceBlockingStub = BydbQLServiceGrpc.newBlockingStub(this.channel);
                 isConnected = true;
             }
         } finally {
@@ -360,6 +370,115 @@ public class BanyanDBClient implements Closeable {
         throw new RuntimeException("No metadata found for the query");
     }
 
+    @SafeVarargs
+    private BanyandbBydbql.QueryResponse queryBydbQL(
+        String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        checkState(this.bydbQLServiceBlockingStub != null, "bydbql service is null");
+        final List<BanyandbModel.TagValue> tagValues = new ArrayList<>(params.length);
+        for (final Serializable<BanyandbModel.TagValue> param : params) {
+            tagValues.add(param.serialize());
+        }
+        final BanyandbBydbql.QueryRequest request = BanyandbBydbql.QueryRequest.newBuilder()
+                .setQuery(bydbql)
+                .addAllParams(tagValues)
+                .build();
+        return HandleExceptionsWith.callAndTranslateApiException(() ->
+                this.bydbQLServiceBlockingStub
+                        .withDeadlineAfter(this.getOptions().getDeadline(), TimeUnit.SECONDS)
+                        .query(request));
+    }
+
+    /**
+     * Query measures with a BydbQL statement.
+     *
+     * @param bydbql a BydbQL query whose FROM clause targets a MEASURE
+     * @param params values bound to the {@code ?} placeholders, in order of appearance
+     * @return the measure query response
+     * @throws BanyanDBException if the query fails or the server returns a non-measure result
+     */
+    @SafeVarargs
+    public final MeasureQueryResponse queryMeasure(
+            String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        final BanyandbBydbql.QueryResponse resp = queryBydbQL(bydbql, params);
+        if (resp.getResultCase() != BanyandbBydbql.QueryResponse.ResultCase.MEASURE_RESULT) {
+            throw new IllegalStateException("expected measure_result but got " + resp.getResultCase());
+        }
+        return new MeasureQueryResponse(resp.getMeasureResult());
+    }
+
+    /**
+     * Query a stream with a BydbQL statement.
+     *
+     * @param bydbql a BydbQL query whose FROM clause targets a STREAM
+     * @param params values bound to the {@code ?} placeholders, in order of appearance
+     * @return the stream query response
+     * @throws BanyanDBException if the query fails or the server returns a non-stream result
+     */
+    @SafeVarargs
+    public final StreamQueryResponse queryStream(
+            String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        final BanyandbBydbql.QueryResponse resp = queryBydbQL(bydbql, params);
+        if (resp.getResultCase() != BanyandbBydbql.QueryResponse.ResultCase.STREAM_RESULT) {
+            throw new IllegalStateException("expected stream_result but got " + resp.getResultCase());
+        }
+        return new StreamQueryResponse(resp.getStreamResult());
+    }
+
+    /**
+     * Query traces with a BydbQL statement.
+     *
+     * @param bydbql a BydbQL query whose FROM clause targets a TRACE
+     * @param params values bound to the {@code ?} placeholders, in order of appearance
+     * @return the trace query response
+     * @throws BanyanDBException if the query fails or the server returns a non-trace result
+     */
+    @SafeVarargs
+    public final TraceQueryResponse queryTrace(
+            String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        final BanyandbBydbql.QueryResponse resp = queryBydbQL(bydbql, params);
+        if (resp.getResultCase() != BanyandbBydbql.QueryResponse.ResultCase.TRACE_RESULT) {
+            throw new IllegalStateException("expected trace_result but got " + resp.getResultCase());
+        }
+        return new TraceQueryResponse(resp.getTraceResult());
+    }
+
+    /**
+     * Query TopN with a BydbQL {@code SHOW TOP} statement.
+     *
+     * @param bydbql a BydbQL {@code SHOW TOP} query over a MEASURE
+     * @param params values bound to the {@code ?} placeholders, in order of appearance
+     * @return the TopN query response
+     * @throws BanyanDBException if the query fails or the server returns a non-topn result
+     */
+    @SafeVarargs
+    public final TopNQueryResponse queryTopN(
+            String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        final BanyandbBydbql.QueryResponse resp = queryBydbQL(bydbql, params);
+        if (resp.getResultCase() != BanyandbBydbql.QueryResponse.ResultCase.TOPN_RESULT) {
+            throw new IllegalStateException("expected topn_result but got " + resp.getResultCase());
+        }
+        return new TopNQueryResponse(resp.getTopnResult());
+    }
+
+    /**
+     * Query properties with a BydbQL statement. Properties have no dedicated response wrapper,
+     * so the raw protobuf response is returned, matching {@link #query(BanyandbProperty.QueryRequest)}.
+     *
+     * @param bydbql a BydbQL query whose FROM clause targets a PROPERTY
+     * @param params values bound to the {@code ?} placeholders, in order of appearance
+     * @return the raw property query response
+     * @throws BanyanDBException if the query fails or the server returns a non-property result
+     */
+    @SafeVarargs
+    public final BanyandbProperty.QueryResponse queryProperty(
+            String bydbql, Serializable<BanyandbModel.TagValue>... params) throws BanyanDBException {
+        final BanyandbBydbql.QueryResponse resp = queryBydbQL(bydbql, params);
+        if (resp.getResultCase() != BanyandbBydbql.QueryResponse.ResultCase.PROPERTY_RESULT) {
+            throw new IllegalStateException("expected property_result but got " + resp.getResultCase());
+        }
+        return resp.getPropertyResult();
+    }
+
     /**
      * Define a new group and attach to the current client.
      *
diff --git a/oap-server/server-library/library-banyandb-client/src/main/proto b/oap-server/server-library/library-banyandb-client/src/main/proto
index 7d0b0a5684..73c20c3fbb 160000
--- a/oap-server/server-library/library-banyandb-client/src/main/proto
+++ b/oap-server/server-library/library-banyandb-client/src/main/proto
@@ -1 +1 @@
-Subproject commit 7d0b0a5684812523325a30b2318a026870b45c8f
+Subproject commit 73c20c3fbb00bf9a8501216e116f052c5d137e12
diff --git a/oap-server/server-library/library-banyandb-client/src/test/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBBydbQLQueryTest.java b/oap-server/server-library/library-banyandb-client/src/test/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBBydbQLQueryTest.java
new file mode 100644
index 0000000000..f25b82fc6a
--- /dev/null
+++ b/oap-server/server-library/library-banyandb-client/src/test/java/org/apache/skywalking/library/banyandb/v1/client/BanyanDBBydbQLQueryTest.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ *     http://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.
+ *
+ */
+
+package org.apache.skywalking.library.banyandb.v1.client;
+
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import org.apache.skywalking.banyandb.bydbql.v1.BanyandbBydbql;
+import org.apache.skywalking.banyandb.bydbql.v1.BydbQLServiceGrpc;
+import org.apache.skywalking.banyandb.measure.v1.BanyandbMeasure;
+import org.apache.skywalking.banyandb.property.v1.BanyandbProperty;
+import org.apache.skywalking.banyandb.stream.v1.BanyandbStream;
+import org.apache.skywalking.banyandb.trace.v1.BanyandbTrace;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BanyanDBBydbQLQueryTest extends AbstractBanyanDBClientTest {
+
+    // The last request the fake service received, for asserting query text and params.
+    private BanyandbBydbql.QueryRequest lastRequest;
+
+    // The oneof branch the fake service returns for the next call.
+    private BanyandbBydbql.QueryResponse nextResponse;
+
+    @BeforeEach
+    public void setUp() throws IOException {
+        super.setUp(bindService(new BydbQLServiceGrpc.BydbQLServiceImplBase() {
+            @Override
+            public void query(BanyandbBydbql.QueryRequest request,
+                              StreamObserver<BanyandbBydbql.QueryResponse> responseObserver) {
+                lastRequest = request;
+                responseObserver.onNext(nextResponse);
+                responseObserver.onCompleted();
+            }
+        }));
+    }
+
+    @AfterEach
+    public void tearDown() {
+        if (this.channel != null) {
+            this.channel.shutdownNow();
+        }
+    }
+
+    @Test
+    public void queryMeasure_sendsQueryAndParams_andUnwrapsMeasureResult() throws Exception {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setMeasureResult(BanyandbMeasure.QueryResponse.newBuilder()
+                        .addDataPoints(BanyandbMeasure.DataPoint.newBuilder().build())
+                        .build())
+                .build();
+
+        MeasureQueryResponse resp = client.queryMeasure(
+                "SELECT x FROM MEASURE m IN g TIME BETWEEN ? AND ? WHERE id = ?",
+                Value.timestampTagValue(1000L), Value.timestampTagValue(2000L), Value.stringTagValue("svc"));
+
+        assertEquals(1, resp.size());
+        assertEquals("SELECT x FROM MEASURE m IN g TIME BETWEEN ? AND ? WHERE id = ?", lastRequest.getQuery());
+        assertEquals(3, lastRequest.getParamsCount());
+        assertEquals("svc", lastRequest.getParams(2).getStr().getValue());
+    }
+
+    @Test
+    public void queryMeasure_throwsOnResultCaseMismatch() {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setStreamResult(BanyandbStream.QueryResponse.newBuilder().build())
+                .build();
+
+        assertThrows(IllegalStateException.class,
+                () -> client.queryMeasure("SELECT x FROM MEASURE m IN g TIME > ?", Value.timestampTagValue(1000L)));
+    }
+
+    @Test
+    public void queryStream_unwrapsStreamResult() throws Exception {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setStreamResult(BanyandbStream.QueryResponse.newBuilder()
+                        .addElements(BanyandbStream.Element.newBuilder().build())
+                        .build())
+                .build();
+
+        StreamQueryResponse resp = client.queryStream(
+                "SELECT trace_id FROM STREAM s IN g TIME > ?", Value.timestampTagValue(1000L));
+
+        assertNotNull(resp);
+        assertEquals("SELECT trace_id FROM STREAM s IN g TIME > ?", lastRequest.getQuery());
+        assertEquals(1, lastRequest.getParamsCount());
+    }
+
+    @Test
+    public void queryTrace_unwrapsTraceResult() throws Exception {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setTraceResult(BanyandbTrace.QueryResponse.newBuilder().build())
+                .build();
+
+        TraceQueryResponse resp = client.queryTrace(
+                "SELECT () FROM TRACE t IN g TIME > ?", Value.timestampTagValue(1000L));
+
+        assertNotNull(resp);
+        assertEquals("SELECT () FROM TRACE t IN g TIME > ?", lastRequest.getQuery());
+    }
+
+    @Test
+    public void queryTopN_unwrapsTopNResult() throws Exception {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setTopnResult(BanyandbMeasure.TopNResponse.newBuilder().build())
+                .build();
+
+        TopNQueryResponse resp = client.queryTopN(
+                "SHOW TOP ? FROM MEASURE m IN g TIME > ? ORDER BY DESC",
+                Value.longTagValue(10L), Value.timestampTagValue(1000L));
+
+        assertNotNull(resp);
+        assertEquals(2, lastRequest.getParamsCount());
+    }
+
+    @Test
+    public void queryProperty_returnsRawPropertyResponse() throws Exception {
+        nextResponse = BanyandbBydbql.QueryResponse.newBuilder()
+                .setPropertyResult(BanyandbProperty.QueryResponse.newBuilder().build())
+                .build();
+
+        BanyandbProperty.QueryResponse resp = client.queryProperty(
+                "SELECT ip FROM PROPERTY p IN g WHERE ID = ?", Value.stringTagValue("k"));
+
+        assertNotNull(resp);
+        assertEquals("SELECT ip FROM PROPERTY p IN g WHERE ID = ?", lastRequest.getQuery());
+    }
+}
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBAggregationQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBAggregationQueryDAO.java
index c958df4ec2..0f24223a44 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBAggregationQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBAggregationQueryDAO.java
@@ -24,7 +24,6 @@ import org.apache.skywalking.banyandb.database.v1.BanyandbDatabase;
 import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
 import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.library.banyandb.v1.client.TopNQueryResponse;
@@ -39,17 +38,16 @@ import org.apache.skywalking.oap.server.core.query.type.SelectedRecord;
 import org.apache.skywalking.oap.server.core.storage.query.IAggregationQueryDAO;
 import org.apache.skywalking.oap.server.library.util.CollectionUtils;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.util.ByteUtil;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Set;
 
 @Slf4j
 public class BanyanDBAggregationQueryDAO extends AbstractBanyanDBDAO implements IAggregationQueryDAO {
-    private static final Set<String> TAGS = ImmutableSet.of(Metrics.ENTITY_ID);
 
     public BanyanDBAggregationQueryDAO(BanyanDBStorageClient client) {
         super(client);
@@ -147,34 +145,26 @@ public class BanyanDBAggregationQueryDAO extends AbstractBanyanDBDAO implements
             log.debug("Endpoint direct TopN query, TopNCondition: {}, AdditionalConditions: {}, TimestampRange: {}",
             condition, additionalConditions, timestampRange);
         }
-        MeasureQueryResponse resp = queryDebuggable(isColdStage, schema, TAGS, Collections.singleton(valueColumnName),
-                timestampRange, new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.meanBy(valueColumnName, ImmutableSet.of(Metrics.ENTITY_ID));
-                        if (condition.getOrder() == Order.DES) {
-                            query.topN(condition.getTopN(), valueColumnName);
-                        } else {
-                            query.bottomN(condition.getTopN(), valueColumnName);
-                        }
-                        if (CollectionUtils.isNotEmpty(additionalConditions)) {
-                            additionalConditions.forEach(additionalCondition -> query
-                                    .and(eq(
-                                            additionalCondition.getKey(),
-                                            additionalCondition.getValue()
-                                    )));
-                        }
-                        if (CollectionUtils.isNotEmpty(condition.getAttributes())) {
-                            condition.getAttributes().forEach(attr -> {
-                                if (attr.isEquals()) {
-                                    query.and(eq(attr.getKey(), attr.getValue()));
-                                } else {
-                                    query.and(ne(attr.getKey(), attr.getValue()));
-                                }
-                            });
-                        }
-                    }
-                });
+        // Ad-hoc TopN over the raw measure: MEAN aggregation + TOP N + GROUP BY entity_id, expressed as a
+        // BydbQL `SELECT TOP ? "value" <dir>, MEAN("value"), entity_id ... GROUP BY entity_id, "value"`. The
+        // trailing GROUP BY field is inert server-side (grouping uses the tag projection, aggregation the Agg
+        // field), so this matches the former typed meanBy(value,{entity_id}) + topN/bottomN(N,value) path.
+        final Conditions where = Conditions.create();
+        if (CollectionUtils.isNotEmpty(additionalConditions)) {
+            additionalConditions.forEach(c -> where.eq(qualify(c.getKey()), c.getValue()));
+        }
+        if (CollectionUtils.isNotEmpty(condition.getAttributes())) {
+            condition.getAttributes().forEach(attr -> {
+                if (attr.isEquals()) {
+                    where.eq(qualify(attr.getKey()), attr.getValue());
+                } else {
+                    where.ne(qualify(attr.getKey()), attr.getValue());
+                }
+            });
+        }
+        final MeasureQueryResponse resp = queryDebuggable(isColdStage, schema, timestampRange,
+                valueColumnName, "MEAN", Metrics.ENTITY_ID, condition.getTopN(),
+                condition.getOrder() == Order.DES ? AbstractQuery.Sort.DESC : AbstractQuery.Sort.ASC, where);
 
         if (resp.size() == 0) {
             return Collections.emptyList();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBRecordsQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBRecordsQueryDAO.java
index 61888bcc02..e2cfe33bc4 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBRecordsQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBRecordsQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.topn.TopN;
 import org.apache.skywalking.oap.server.core.query.enumeration.Order;
@@ -31,6 +29,7 @@ import org.apache.skywalking.oap.server.core.query.type.Record;
 import org.apache.skywalking.oap.server.core.storage.query.IRecordsQueryDAO;
 import org.apache.skywalking.oap.server.library.util.StringUtil;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.util.ByteUtil;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -49,19 +48,12 @@ public class BanyanDBRecordsQueryDAO extends AbstractBanyanDBDAO implements IRec
         final boolean isColdStage = duration != null && duration.isColdStage();
         final String modelName = condition.getName();
         final Set<String> tags = ImmutableSet.of(TopN.ENTITY_ID, TopN.STATEMENT, TopN.TRACE_ID, valueColumnName);
-        StreamQueryResponse resp = queryDebuggable(isColdStage, modelName, tags,
-                getTimestampRange(duration), new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        query.and(eq(TopN.ENTITY_ID, condition.getParentEntity().buildId()));
-                        if (condition.getOrder() == Order.DES) {
-                            query.setOrderBy(new StreamQuery.OrderBy(valueColumnName, AbstractQuery.Sort.DESC));
-                        } else {
-                            query.setOrderBy(new StreamQuery.OrderBy(valueColumnName, AbstractQuery.Sort.ASC));
-                        }
-                        query.setLimit(condition.getTopN());
-                    }
-                });
+        final String direction = condition.getOrder() == Order.DES ? "DESC" : "ASC";
+        StreamQueryResponse resp = queryDebuggable(isColdStage, modelName, tags, getTimestampRange(duration),
+                Conditions.create()
+                        .eq(TopN.ENTITY_ID, condition.getParentEntity().buildId())
+                        .orderBy(qualify(valueColumnName), direction)
+                        .limit(condition.getTopN()));
 
         if (resp.size() == 0) {
             return Collections.emptyList();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBStorageClient.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBStorageClient.java
index e8abd2ab1e..e0917ddb4c 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBStorageClient.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBStorageClient.java
@@ -37,22 +37,20 @@ import org.apache.skywalking.banyandb.property.v1.BanyandbProperty.DeleteRespons
 import org.apache.skywalking.banyandb.property.v1.BanyandbProperty.Property;
 import org.apache.skywalking.banyandb.stream.v1.BanyandbStream;
 import org.apache.skywalking.library.banyandb.v1.client.BanyanDBClient;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureWrite;
 import org.apache.skywalking.library.banyandb.v1.client.Options;
 import org.apache.skywalking.library.banyandb.v1.client.PropertyStore;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.StreamWrite;
-import org.apache.skywalking.library.banyandb.v1.client.TopNQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TopNQueryResponse;
-import org.apache.skywalking.library.banyandb.v1.client.TraceQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TraceQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TraceWrite;
+import org.apache.skywalking.library.banyandb.v1.client.Value;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.exception.BanyanDBException;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.exception.InternalException;
 import org.apache.skywalking.library.banyandb.v1.client.grpc.exception.InvalidArgumentException;
+import org.apache.skywalking.library.banyandb.v1.client.metadata.Serializable;
 import org.apache.skywalking.library.banyandb.v1.client.util.StatusUtil;
 import org.apache.skywalking.oap.server.library.client.Client;
 import org.apache.skywalking.oap.server.library.client.healthcheck.DelegatedHealthChecker;
@@ -168,12 +166,9 @@ public class BanyanDBStorageClient implements Client, HealthCheckable {
     public List<Property> listProperties(String name) throws IOException {
         try {
             MetadataRegistry.Schema schema = requireManagementSchema(name);
-            BanyandbProperty.QueryResponse resp
-                = this.client.query(BanyandbProperty.QueryRequest.newBuilder()
-                                                                 .addGroups(schema.getMetadata().getGroup())
-                                                                 .setName(name)
-                                                                 .setLimit(Integer.MAX_VALUE)
-                                                                 .build());
+            BanyandbProperty.QueryResponse resp = this.client.queryProperty(
+                "SELECT * FROM PROPERTY " + name + " IN " + schema.getMetadata().getGroup() + " LIMIT ?",
+                Value.longTagValue((long) Integer.MAX_VALUE));
             this.healthChecker.health();
             return resp.getPropertiesList();
         } catch (BanyanDBException ex) {
@@ -190,11 +185,9 @@ public class BanyanDBStorageClient implements Client, HealthCheckable {
     public Property queryProperty(String name, String id) throws IOException {
         try {
             MetadataRegistry.Schema schema = requireManagementSchema(name);
-            BanyandbProperty.QueryResponse resp = this.client.query(BanyandbProperty.QueryRequest.newBuilder()
-                                                                                                 .addGroups(schema.getMetadata().getGroup())
-                                                                                                 .setName(name)
-                                                                                                 .addIds(id)
-                                                                                                 .build());
+            BanyandbProperty.QueryResponse resp = this.client.queryProperty(
+                "SELECT * FROM PROPERTY " + name + " IN " + schema.getMetadata().getGroup() + " WHERE ID = ?",
+                Value.stringTagValue(id));
             this.healthChecker.health();
             if (resp.getPropertiesCount() == 0) {
                 return null;
@@ -224,31 +217,34 @@ public class BanyanDBStorageClient implements Client, HealthCheckable {
         }
     }
 
-    public StreamQueryResponse query(StreamQuery q) throws IOException {
+    @SafeVarargs
+    public final MeasureQueryResponse queryMeasure(String bydbql, Serializable<BanyandbModel.TagValue>... params) throws IOException {
         try {
-            StreamQueryResponse response = this.client.query(q);
+            MeasureQueryResponse response = this.client.queryMeasure(bydbql, params);
             this.healthChecker.health();
             return response;
         } catch (BanyanDBException ex) {
             healthChecker.unHealth(ex);
-            throw new IOException("fail to query stream", ex);
+            throw new IOException("fail to query measure", ex);
         }
     }
 
-    public MeasureQueryResponse query(MeasureQuery q) throws IOException {
+    @SafeVarargs
+    public final StreamQueryResponse queryStream(String bydbql, Serializable<BanyandbModel.TagValue>... params) throws IOException {
         try {
-            MeasureQueryResponse response = this.client.query(q);
+            StreamQueryResponse response = this.client.queryStream(bydbql, params);
             this.healthChecker.health();
             return response;
         } catch (BanyanDBException ex) {
             healthChecker.unHealth(ex);
-            throw new IOException("fail to query measure", ex);
+            throw new IOException("fail to query stream", ex);
         }
     }
 
-    public TraceQueryResponse query(TraceQuery q) throws IOException {
+    @SafeVarargs
+    public final TraceQueryResponse queryTrace(String bydbql, Serializable<BanyandbModel.TagValue>... params) throws IOException {
         try {
-            TraceQueryResponse response = this.client.query(q);
+            TraceQueryResponse response = this.client.queryTrace(bydbql, params);
             this.healthChecker.health();
             return response;
         } catch (BanyanDBException ex) {
@@ -257,9 +253,10 @@ public class BanyanDBStorageClient implements Client, HealthCheckable {
         }
     }
 
-    public TopNQueryResponse query(TopNQuery q) throws IOException {
+    @SafeVarargs
+    public final TopNQueryResponse queryTopN(String bydbql, Serializable<BanyandbModel.TagValue>... params) throws IOException {
         try {
-            TopNQueryResponse response = this.client.query(q);
+            TopNQueryResponse response = this.client.queryTopN(bydbql, params);
             this.healthChecker.health();
             return response;
         } catch (BanyanDBException ex) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBEBPFProfilingScheduleQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBEBPFProfilingScheduleQueryDAO.java
index 651e45c267..608ecf2fe0 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBEBPFProfilingScheduleQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBEBPFProfilingScheduleQueryDAO.java
@@ -20,9 +20,7 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.measure;
 
  import com.google.common.collect.ImmutableSet;
  import lombok.extern.slf4j.Slf4j;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
  import org.apache.skywalking.oap.server.core.analysis.DownSampling;
  import org.apache.skywalking.oap.server.core.profiling.ebpf.storage.EBPFProfilingScheduleRecord;
@@ -31,6 +29,7 @@ import org.apache.skywalking.oap.server.core.storage.profiling.ebpf.IEBPFProfili
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
  import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
  import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+ import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -53,15 +52,14 @@ import java.util.stream.Collectors;
      @Override
      public List<EBPFProfilingSchedule> querySchedules(String taskId) throws IOException {
          MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(EBPFProfilingScheduleRecord.INDEX_NAME, DownSampling.Minute);
-         MeasureQueryResponse resp = query(false, schema,
+         final Conditions where = Conditions.create()
+                 .eq(EBPFProfilingScheduleRecord.TASK_ID, taskId)
+                 .orderByDesc(EBPFProfilingScheduleRecord.START_TIME);
+         MeasureQueryResponse resp = queryDebuggable(false, schema,
                  TAGS,
-                                           Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-                 @Override
-                 protected void apply(MeasureQuery query) {
-                     query.and(eq(EBPFProfilingScheduleRecord.TASK_ID, taskId));
-                     query.setOrderBy(new AbstractQuery.OrderBy(EBPFProfilingScheduleRecord.START_TIME, AbstractQuery.Sort.DESC));
-                 }
-             }
+                 Collections.emptySet(),
+                 null,
+                 where
          );
 
          return resp.getDataPoints().stream().map(this::buildEBPFProfilingSchedule).collect(Collectors.toList());
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBHierarchyQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBHierarchyQueryDAO.java
index 10d8a8b317..b447e63e5b 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBHierarchyQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBHierarchyQueryDAO.java
@@ -19,14 +19,11 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.measure;
 
 import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractCriteria;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
 import org.apache.skywalking.oap.server.core.analysis.Layer;
@@ -38,6 +35,7 @@ import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageC
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageConfig;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 public class BanyanDBHierarchyQueryDAO extends AbstractBanyanDBDAO implements IHierarchyQueryDAO {
     private static final Set<String> SERVICE_HIERARCHY_RELATION_TAGS = ImmutableSet.of(
@@ -63,14 +61,11 @@ public class BanyanDBHierarchyQueryDAO extends AbstractBanyanDBDAO implements IH
     @Override
     public List<ServiceHierarchyRelationTraffic> readAllServiceHierarchyRelations() throws Exception {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ServiceHierarchyRelationTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                                           SERVICE_HIERARCHY_RELATION_TAGS,
-                                          Collections.emptySet(), new QueryBuilder<>() {
-                @Override
-                protected void apply(MeasureQuery query) {
-                    query.limit(limit);
-                }
-            }
+                                          Collections.emptySet(),
+                                          null,
+                                          Conditions.create().limit(limit)
         );
 
         final List<ServiceHierarchyRelationTraffic> relations = new ArrayList<>();
@@ -87,9 +82,18 @@ public class BanyanDBHierarchyQueryDAO extends AbstractBanyanDBDAO implements IH
     public List<InstanceHierarchyRelationTraffic> readInstanceHierarchyRelations(final String instanceId,
                                                                                  final String layer) throws Exception {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ServiceHierarchyRelationTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        int layerValue = Layer.valueOf(layer).value();
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                                               INSTANCE_HIERARCHY_RELATION_TAGS,
-                                          Collections.emptySet(), buildInstanceRelationsQuery(instanceId, layer)
+                                          Collections.emptySet(),
+                                          null,
+                                          Conditions.create().or(List.of(
+                                              Conditions.group()
+                                                  .eq(InstanceHierarchyRelationTraffic.INSTANCE_ID, instanceId)
+                                                  .eq(InstanceHierarchyRelationTraffic.SERVICE_LAYER, layerValue),
+                                              Conditions.group()
+                                                  .eq(InstanceHierarchyRelationTraffic.RELATED_INSTANCE_ID, instanceId)
+                                                  .eq(InstanceHierarchyRelationTraffic.RELATED_SERVICE_LAYER, layerValue)))
         );
 
         List<InstanceHierarchyRelationTraffic> relations = new ArrayList<>();
@@ -99,27 +103,4 @@ public class BanyanDBHierarchyQueryDAO extends AbstractBanyanDBDAO implements IH
         }
         return relations;
     }
-
-    private QueryBuilder<MeasureQuery> buildInstanceRelationsQuery(String instanceId, String layer) {
-        int layerValue = Layer.valueOf(layer).value();
-        return new QueryBuilder<>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-                List<AbstractCriteria> instanceRelationsQueryConditions = new ArrayList<>(2);
-
-                instanceRelationsQueryConditions.add(
-                    and(Lists.newArrayList(
-                        eq(InstanceHierarchyRelationTraffic.INSTANCE_ID, instanceId),
-                        eq(InstanceHierarchyRelationTraffic.SERVICE_LAYER, layerValue))
-                    ));
-                instanceRelationsQueryConditions.add(
-                    and(Lists.newArrayList(
-                        eq(InstanceHierarchyRelationTraffic.RELATED_INSTANCE_ID, instanceId),
-                        eq(InstanceHierarchyRelationTraffic.RELATED_SERVICE_LAYER, layerValue)
-                    ))
-                );
-                query.criteria(or(instanceRelationsQueryConditions));
-            }
-        };
-    }
 }
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetadataQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetadataQueryDAO.java
index 50a6fb08c6..6175469d95 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetadataQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetadataQueryDAO.java
@@ -23,10 +23,7 @@ import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
@@ -52,6 +49,7 @@ import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageC
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageConfig;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -92,14 +90,12 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
     public List<Service> listServices() throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ServiceTraffic.INDEX_NAME, DownSampling.Minute);
 
-        MeasureQueryResponse resp = query(false, schema,
+        final Conditions where = Conditions.create().limit(limit);
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 SERVICE_TRAFFIC_TAGS,
-                Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.limit(limit);
-                    }
-                });
+                Collections.emptySet(),
+                null,
+                where);
 
         final List<Service> services = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -118,21 +114,24 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
             timestampRange = new TimestampRange(0, duration.getEndTimestamp());
         }
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(InstanceTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(InstanceTraffic.SERVICE_ID, serviceId);
+        }
+        // Mirror the ES/JDBC DAOs: only apply the last-ping lower bound when a duration is given;
+        // a null duration (e.g. HierarchyQueryService.listInstances(null, ...)) keeps the full range.
+        if (duration != null) {
+            final long startTimeBucket = TimeBucket.getMinuteTimeBucket(duration.getStartTimestamp());
+            where.gte(InstanceTraffic.LAST_PING_TIME_BUCKET, startTimeBucket);
+        }
+        where.limit(limit);
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 INSTANCE_TRAFFIC_TAGS,
                 Collections.emptySet(),
                 timestampRange,
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(InstanceTraffic.SERVICE_ID, serviceId));
-                        }
-                        final var startTimeBucket = TimeBucket.getMinuteTimeBucket(duration.getStartTimestamp());
-                        query.and(gte(InstanceTraffic.LAST_PING_TIME_BUCKET, startTimeBucket));
-                        query.limit(limit);
-                    }
-                });
+                where);
 
         final List<ServiceInstance> instances = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -145,30 +144,22 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
     @Override
     public ServiceInstance getInstance(String instanceId) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(InstanceTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 INSTANCE_TRAFFIC_TAGS,
                 Collections.emptySet(),
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ID, instanceId));
-                    }
-                });
+                null,
+                Conditions.create().eq(ID, instanceId));
         return resp.size() > 0 ? buildInstance(resp.getDataPoints().get(0), schema) : null;
     }
 
     @Override
     public List<ServiceInstance> getInstances(List<String> instanceIds) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(InstanceTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 INSTANCE_TRAFFIC_TAGS,
                 Collections.emptySet(),
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(in(ID, instanceIds));
-                    }
-                });
+                null,
+                Conditions.create().in(ID, instanceIds));
         return resp.getDataPoints().stream().map(e -> buildInstance(e, schema)).collect(Collectors.toList());
     }
 
@@ -181,30 +172,25 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
             // It's equals to the condition `query.and(lte(EndpointTraffic.TIME_BUCKET, endTimeBucket))`
             timestampRange = new TimestampRange(0, duration.getEndTimestamp());
         }
-        MeasureQueryResponse resp = query(false, schema,
+
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(EndpointTraffic.SERVICE_ID, serviceId);
+        }
+        if (StringUtil.isNotEmpty(keyword)) {
+            where.match(EndpointTraffic.NAME, "", "AND", keyword);
+        }
+        if (duration != null) {
+            final long startTimeBucket = TimeBucket.getMinuteTimeBucket(duration.getStartTimestamp());
+            where.gte(EndpointTraffic.LAST_PING_TIME_BUCKET, startTimeBucket);
+        }
+        where.orderByDesc().limit(limit);
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 ENDPOINT_TRAFFIC_TAGS,
                 Collections.emptySet(),
                 timestampRange,
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(EndpointTraffic.SERVICE_ID, serviceId));
-                        }
-                        if (StringUtil.isNotEmpty(keyword)) {
-                            query.and(match(EndpointTraffic.NAME, keyword,
-                                            BanyandbModel.Condition.MatchOption.newBuilder().setOperator(
-                                                BanyandbModel.Condition.MatchOption.Operator.OPERATOR_AND).build()
-                            ));
-                        }
-                        if (duration != null) {
-                            final var startTimeBucket = TimeBucket.getMinuteTimeBucket(duration.getStartTimestamp());
-                            query.and(gte(EndpointTraffic.LAST_PING_TIME_BUCKET, startTimeBucket));
-                        }
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                        query.limit(limit);
-                    }
-                });
+                where);
 
         final List<Endpoint> endpoints = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -222,24 +208,23 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
             // It's equals to the condition `query.and(lte(ProcessTraffic.TIME_BUCKET, endTimeBucket))`
             timestampRange = new TimestampRange(0, TimeBucket.getTimestamp(lastPingEndTimeBucket));
         }
-        MeasureQueryResponse resp = query(false, schema,
+
+        final Conditions where = Conditions.create()
+                .eq(ProcessTraffic.SERVICE_ID, serviceId);
+        if (lastPingStartTimeBucket > 0) {
+            where.gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket);
+        }
+        if (supportStatus != null) {
+            where.eq(ProcessTraffic.PROFILING_SUPPORT_STATUS, supportStatus.value());
+        }
+        where.ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value());
+        where.limit(limit);
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
                 timestampRange,
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessTraffic.SERVICE_ID, serviceId));
-                        if (lastPingStartTimeBucket > 0) {
-                            query.and(gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket));
-                        }
-                        if (supportStatus != null) {
-                            query.and(eq(ProcessTraffic.PROFILING_SUPPORT_STATUS, supportStatus.value()));
-                        }
-                        query.and(ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value()));
-                        query.limit(limit);
-                    }
-                });
+                where);
 
         final List<Process> processes = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -258,22 +243,21 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
             // It's equals to the condition `query.and(lte(ProcessTraffic.TIME_BUCKET, endTimeBucket))`
             timestampRange = new TimestampRange(0, duration.getEndTimestamp());
         }
-        long lastPingStartTimeBucket = duration.getStartTimeBucket();
-        MeasureQueryResponse resp = query(false, schema,
+        final long lastPingStartTimeBucket = duration.getStartTimeBucket();
+
+        final Conditions where = Conditions.create()
+                .eq(ProcessTraffic.INSTANCE_ID, serviceInstanceId)
+                .gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket);
+        if (!includeVirtual) {
+            where.ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value());
+        }
+        where.limit(limit);
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
                 timestampRange,
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessTraffic.INSTANCE_ID, serviceInstanceId));
-                        query.and(gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket));
-                        if (!includeVirtual) {
-                            query.and(ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value()));
-                        }
-                        query.limit(limit);
-                    }
-                });
+                where);
 
         final List<Process> processes = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -292,19 +276,18 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
             // It's equals to the condition `query.and(lte(ProcessTraffic.TIME_BUCKET, endTimeBucket))`
             timestampRange = new TimestampRange(0, TimeBucket.getTimestamp(endPingTimeBucket));
         }
-        MeasureQueryResponse resp = query(false, schema,
+
+        final Conditions where = Conditions.create()
+                .eq(ProcessTraffic.AGENT_ID, agentId)
+                .gte(ProcessTraffic.LAST_PING_TIME_BUCKET, startPingTimeBucket)
+                .ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value())
+                .limit(limit);
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
                 timestampRange,
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessTraffic.AGENT_ID, agentId));
-                        query.and(gte(ProcessTraffic.LAST_PING_TIME_BUCKET, startPingTimeBucket));
-                        query.and(ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value()));
-                        query.limit(limit);
-                    }
-                });
+                where);
 
         final List<Process> processes = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
@@ -317,18 +300,17 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
     @Override
     public long getProcessCount(String serviceId, ProfilingSupportStatus profilingSupportStatus, long lastPingStartTimeBucket, long lastPingEndTimeBucket) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ProcessTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        final Conditions where = Conditions.create()
+                .eq(ProcessTraffic.SERVICE_ID, serviceId)
+                .gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket)
+                .eq(ProcessTraffic.PROFILING_SUPPORT_STATUS, profilingSupportStatus.value())
+                .ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value());
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessTraffic.SERVICE_ID, serviceId));
-                        query.and(gte(ProcessTraffic.LAST_PING_TIME_BUCKET, lastPingStartTimeBucket));
-                        query.and(eq(ProcessTraffic.PROFILING_SUPPORT_STATUS, profilingSupportStatus.value()));
-                        query.and(ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value()));
-                    }
-                });
+                null,
+                where);
 
         return resp.getDataPoints()
                 .stream()
@@ -339,16 +321,15 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
     @Override
     public long getProcessCount(String instanceId) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ProcessTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        final Conditions where = Conditions.create()
+                .eq(ProcessTraffic.INSTANCE_ID, instanceId)
+                .ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value());
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessTraffic.INSTANCE_ID, instanceId));
-                        query.and(ne(ProcessTraffic.DETECT_TYPE, ProcessDetectType.VIRTUAL.value()));
-                    }
-                });
+                null,
+                where);
 
         return resp.getDataPoints()
                 .stream()
@@ -359,17 +340,16 @@ public class BanyanDBMetadataQueryDAO extends AbstractBanyanDBDAO implements IMe
     @Override
     public Process getProcess(String processId) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ProcessTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp = query(false, schema,
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(processId)) {
+            where.eq(ID, processId);
+        }
+
+        MeasureQueryResponse resp = queryDebuggable(false, schema,
                 PROCESS_TRAFFIC_TAGS,
                 Collections.emptySet(),
-                new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        if (StringUtil.isNotEmpty(processId)) {
-                            query.and(eq(ID, processId));
-                        }
-                    }
-                });
+                null,
+                where);
 
         return resp.size() > 0 ? buildProcess(resp.getDataPoints().get(0), schema) : null;
     }
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsDAO.java
index d52c70ec5f..87029a9a27 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsDAO.java
@@ -22,7 +22,6 @@ import com.google.common.base.Preconditions;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.logging.log4j.util.Strings;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureWrite;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
@@ -40,6 +39,7 @@ import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBConverte
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -129,26 +129,35 @@ public class BanyanDBMetricsDAO extends AbstractBanyanDBDAO implements IMetricsD
                 end = result.end;
             }
         }
-        TimestampRange timestampRange = null;
+        TimestampRange timestampRange;
         if (begin != 0L || end != 0L) {
             timestampRange = new TimestampRange(begin, end);
         } else {
             if (!model.getBanyanDBModelExtension().isIndexMode()) {
                 log.info("{}[{}] will scan all blocks", model.getName(), idStr);
             }
+            timestampRange = null;
         }
 
-        List<Metrics> metricsInStorage = new ArrayList<>(metrics.size());
-        MeasureQueryResponse resp = query(false, schema, schema.getTags().keySet(), schema.getFields(), timestampRange, new QueryBuilder<MeasureQuery>() {
-                @Override
-            protected void apply(MeasureQuery query) {
-                seriesIDColumns.entrySet().forEach(entry -> {
-                    if (!entry.getValue().isEmpty()) {
-                        query.or(in(entry.getKey(), entry.getValue()));
-                    }
-                });
+        // Sort the present seriesID columns so the emitted WHERE ... IN (?) [OR ...] template is
+        // byte-stable across calls, keeping BanyanDB's prepared-statement cache from fanning out
+        // over column ordering.
+        final List<String> queryColumns = new ArrayList<>(seriesIDColumns.size());
+        seriesIDColumns.forEach((col, values) -> {
+            if (!values.isEmpty()) {
+                queryColumns.add(col);
             }
         });
+        Collections.sort(queryColumns);
+        final List<Conditions> groups = new ArrayList<>(queryColumns.size());
+        for (final String col : queryColumns) {
+            groups.add(Conditions.group().in(qualify(col), seriesIDColumns.get(col)));
+        }
+
+        List<Metrics> metricsInStorage = new ArrayList<>(metrics.size());
+        MeasureQueryResponse resp = queryDebuggable(
+            false, schema, schema.getTags().keySet(), schema.getFields(), timestampRange,
+            Conditions.create().or(groups));
         if (resp.size() == 0) {
             return Collections.emptyList();
         }
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsQueryDAO.java
index ac3d95c767..bf01866699 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBMetricsQueryDAO.java
@@ -28,8 +28,6 @@ import java.util.List;
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.TimeBucket;
 import org.apache.skywalking.oap.server.core.analysis.metrics.DataTable;
@@ -48,6 +46,7 @@ import org.apache.skywalking.oap.server.core.storage.query.IMetricsQueryDAO;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.util.ByteUtil;
 
 @Slf4j
@@ -140,14 +139,11 @@ public class BanyanDBMetricsQueryDAO extends AbstractBanyanDBDAO implements IMet
         if (schema == null) {
             throw new IOException("schema is not registered");
         }
-        MeasureQueryResponse resp = query(
+        final Conditions where = Conditions.create()
+            .limit(METRICS_VALUES_WITHOUT_ENTITY_LIMIT);
+        MeasureQueryResponse resp = queryDebuggable(
             isColdStage, schema, ImmutableSet.of(Metrics.ENTITY_ID), ImmutableSet.of(valueColumnName), getTimestampRange(duration),
-            new QueryBuilder<MeasureQuery>() {
-                @Override
-                protected void apply(MeasureQuery query) {
-                    query.limit(METRICS_VALUES_WITHOUT_ENTITY_LIMIT);
-                }
-            }
+            where
         );
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -193,20 +189,15 @@ public class BanyanDBMetricsQueryDAO extends AbstractBanyanDBDAO implements IMet
                 throw new IOException("schema is not registered");
             }
         }
-        final MeasureQueryResponse resp = query(
+        // Most-recent-first ordering must be explicit — without it BanyanDB returns arbitrary order
+        // and a hot entity that ingested late can be dropped before the LIMIT cap is reached.
+        final Conditions where = Conditions.create()
+            .orderByDesc().limit(limit);
+        final MeasureQueryResponse resp = queryDebuggable(
             isColdStage, schema,
             ImmutableSet.of(Metrics.ENTITY_ID), ImmutableSet.of(valueColumnName),
             getTimestampRange(duration),
-            new QueryBuilder<MeasureQuery>() {
-                @Override
-                protected void apply(final MeasureQuery query) {
-                    // Most-recent-first ordering must be explicit — without it BanyanDB returns
-                    // arbitrary order and a hot entity that ingested late can be dropped before
-                    // the LIMIT cap is reached.
-                    query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    query.limit(limit);
-                }
-            }
+            where
         );
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -261,12 +252,10 @@ public class BanyanDBMetricsQueryDAO extends AbstractBanyanDBDAO implements IMet
     private Map<Long, DataPoint> queryByEntityID(MetadataRegistry.Schema schema, String valueColumnName, Duration duration, String entityID) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
         Map<Long, DataPoint> map = new HashMap<>();
-        MeasureQueryResponse resp = queryDebuggable(isColdStage, schema, ImmutableSet.of(Metrics.ENTITY_ID), ImmutableSet.of(valueColumnName), getTimestampRange(duration), new QueryBuilder<MeasureQuery>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-                query.and(eq(Metrics.ENTITY_ID, entityID));
-            }
-        });
+        final Conditions where = Conditions.create()
+            .eq(Metrics.ENTITY_ID, entityID);
+        MeasureQueryResponse resp = queryDebuggable(isColdStage, schema, ImmutableSet.of(Metrics.ENTITY_ID), ImmutableSet.of(valueColumnName), getTimestampRange(duration),
+            where);
         for (final DataPoint dp : resp.getDataPoints()) {
             long timeBucket = TimeBucket.getTimeBucket(dp.getTimestamp(), schema.getMetadata().getDownSampling());
             DataPoint preDp = map.putIfAbsent(timeBucket, dp);
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBNetworkAddressAliasDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBNetworkAddressAliasDAO.java
index 8d34767144..270211dec8 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBNetworkAddressAliasDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBNetworkAddressAliasDAO.java
@@ -27,7 +27,6 @@ import java.util.Set;
 import java.util.stream.Collectors;
 
 import lombok.extern.slf4j.Slf4j;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
 import org.apache.skywalking.oap.server.core.analysis.manual.networkalias.NetworkAddressAlias;
@@ -37,6 +36,7 @@ import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageC
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageConfig;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 @Slf4j
 public class BanyanDBNetworkAddressAliasDAO extends AbstractBanyanDBDAO implements INetworkAddressAliasDAO {
@@ -64,18 +64,16 @@ public class BanyanDBNetworkAddressAliasDAO extends AbstractBanyanDBDAO implemen
     @Override
     public List<NetworkAddressAlias> loadLastUpdate(long timeBucket) {
         try {
-            MeasureQueryResponse resp = query(
-                false,
+            final Conditions where = Conditions.create()
+                    .gte(NetworkAddressAlias.LAST_UPDATE_TIME_BUCKET, timeBucket)
+                    .limit(limit);
+            MeasureQueryResponse resp = queryDebuggable(
+                    false,
                     getSchema(),
                     TAGS,
                     Collections.emptySet(),
-                    new QueryBuilder<MeasureQuery>() {
-                        @Override
-                        protected void apply(final MeasureQuery query) {
-                            query.and(gte(NetworkAddressAlias.LAST_UPDATE_TIME_BUCKET, timeBucket));
-                            query.limit(limit);
-                        }
-                    }
+                    null,
+                    where
             );
             /**
              * Currently, only used by {@link org.apache.skywalking.oap.server.storage.plugin.banyandb.measure.BanyanDBNetworkAddressAliasDAO}.
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBServiceLabelDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBServiceLabelDAO.java
index bf73fafcf9..d54275ea51 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBServiceLabelDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBServiceLabelDAO.java
@@ -26,7 +26,6 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
 import org.apache.skywalking.oap.server.core.analysis.manual.process.ServiceLabelRecord;
 import org.apache.skywalking.oap.server.core.storage.profiling.ebpf.IServiceLabelDAO;
@@ -34,6 +33,7 @@ import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageC
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageConfig;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 public class BanyanDBServiceLabelDAO extends AbstractBanyanDBDAO implements IServiceLabelDAO {
     private static final Set<String> TAGS = ImmutableSet.of(ServiceLabelRecord.LABEL, ServiceLabelRecord.SERVICE_ID);
@@ -47,14 +47,12 @@ public class BanyanDBServiceLabelDAO extends AbstractBanyanDBDAO implements ISer
     @Override
     public List<String> queryAllLabels(String serviceId) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ServiceLabelRecord.INDEX_NAME, DownSampling.Minute);
-        return query(false, schema, TAGS,
-                Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(final MeasureQuery query) {
-                        query.and(eq(ServiceLabelRecord.SERVICE_ID, serviceId));
-                        query.limit(limit);
-                    }
-                }).getDataPoints()
+        final Conditions where = Conditions.create()
+                .eq(ServiceLabelRecord.SERVICE_ID, serviceId)
+                .limit(limit);
+        return queryDebuggable(false, schema, TAGS, Collections.emptySet(),
+                null,
+                where).getDataPoints()
                 .stream()
                 .map(point -> (String) point.getTagValue(ServiceLabelRecord.LABEL))
                 .collect(Collectors.toList());
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTagAutocompleteQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTagAutocompleteQueryDAO.java
index 53c23a3b78..9e8fc53250 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTagAutocompleteQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTagAutocompleteQueryDAO.java
@@ -20,7 +20,6 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.measure;
 
 import com.google.common.collect.ImmutableSet;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
@@ -32,6 +31,7 @@ import org.apache.skywalking.oap.server.core.storage.query.ITagAutoCompleteQuery
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -69,18 +69,13 @@ public class BanyanDBTagAutocompleteQueryDAO extends AbstractBanyanDBDAO impleme
         if (startTB > 0 && endTB > 0) {
             range = new TimestampRange(TimeBucket.getTimestamp(startTB), TimeBucket.getTimestamp(endTB));
         }
-        MeasureQueryResponse resp = query(isColdStage, schema,
+        MeasureQueryResponse resp = queryDebuggable(isColdStage, schema,
                                           TAGS_KEY, Collections.emptySet(),
                                           range,
-                                          new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.groupBy(ImmutableSet.of(TagAutocompleteData.TAG_KEY));
-                        query.setLimit(limit);
-                        query.and(eq(TagAutocompleteData.TAG_TYPE, tagType.name()));
-                    }
-                }
-        );
+                                          Conditions.create()
+                                                  .eq(TagAutocompleteData.TAG_TYPE, tagType.name())
+                                                  .groupBy(TagAutocompleteData.TAG_KEY)
+                                                  .limit(limit));
 
         if (resp.size() == 0) {
             return Collections.emptySet();
@@ -111,19 +106,14 @@ public class BanyanDBTagAutocompleteQueryDAO extends AbstractBanyanDBDAO impleme
         if (startTB > 0 && endTB > 0) {
             range = new TimestampRange(TimeBucket.getTimestamp(startTB), TimeBucket.getTimestamp(endTB));
         }
-        MeasureQueryResponse resp = query(isColdStage, schema,
+        MeasureQueryResponse resp = queryDebuggable(isColdStage, schema,
                                           TAGS_KV, Collections.emptySet(),
                                           range,
-                                          new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.groupBy(ImmutableSet.of(TagAutocompleteData.TAG_VALUE));
-                        query.setLimit(limit);
-                        query.and(eq(TagAutocompleteData.TAG_TYPE, tagType.name()));
-                        query.and(eq(TagAutocompleteData.TAG_KEY, tagKey));
-                    }
-                }
-        );
+                                          Conditions.create()
+                                                  .eq(TagAutocompleteData.TAG_TYPE, tagType.name())
+                                                  .eq(TagAutocompleteData.TAG_KEY, tagKey)
+                                                  .groupBy(TagAutocompleteData.TAG_VALUE)
+                                                  .limit(limit));
 
         if (resp.size() == 0) {
             return Collections.emptySet();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTopologyQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTopologyQueryDAO.java
index 3204c0da07..fd9d320043 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTopologyQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/measure/BanyanDBTopologyQueryDAO.java
@@ -22,15 +22,10 @@ import com.google.common.collect.ImmutableSet;
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractCriteria;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.oap.server.core.UnexpectedException;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
@@ -51,6 +46,7 @@ import org.apache.skywalking.oap.server.library.util.CollectionUtils;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITopologyQueryDAO {
 
@@ -65,9 +61,7 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
             throw new UnexpectedException("Service id is empty");
         }
 
-        QueryBuilder<MeasureQuery> queryBuilder = buildServiceRelationsQuery(serviceIds);
-
-        return queryServiceRelation(duration, queryBuilder, DetectPoint.SERVER);
+        return queryServiceRelation(duration, serviceRelationsWhere(serviceIds), DetectPoint.SERVER);
     }
 
     @Override
@@ -77,34 +71,28 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
             throw new UnexpectedException("Service id is empty");
         }
 
-        QueryBuilder<MeasureQuery> queryBuilder = buildServiceRelationsQuery(serviceIds);
-
-        return queryServiceRelation(duration, queryBuilder, DetectPoint.CLIENT);
+        return queryServiceRelation(duration, serviceRelationsWhere(serviceIds), DetectPoint.CLIENT);
     }
 
     @Override
     public List<Call.CallDetail> loadServiceRelationsDetectedAtServerSide(Duration duration) throws IOException {
-        return queryServiceRelation(duration, emptyMeasureQuery(), DetectPoint.SERVER);
+        return queryServiceRelation(duration, Conditions.create(), DetectPoint.SERVER);
     }
 
     @Override
     public List<Call.CallDetail> loadServiceRelationDetectedAtClientSide(Duration duration) throws IOException {
-        return queryServiceRelation(duration, emptyMeasureQuery(), DetectPoint.CLIENT);
+        return queryServiceRelation(duration, Conditions.create(), DetectPoint.CLIENT);
     }
 
-    private QueryBuilder<MeasureQuery> buildServiceRelationsQuery(List<String> serviceIds) {
-        return new QueryBuilder<MeasureQuery>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-                query.or(in(ServiceRelationServerSideMetrics.SOURCE_SERVICE_ID, serviceIds))
-                        .or(in(ServiceRelationServerSideMetrics.DEST_SERVICE_ID, serviceIds));
-                query.groupBy(Sets.newLinkedHashSet(Arrays.asList(Metrics.ENTITY_ID, ServiceRelationServerSideMetrics.COMPONENT_IDS)));
-            }
-        };
+    private Conditions serviceRelationsWhere(List<String> serviceIds) {
+        return Conditions.create().or(List.of(
+                Conditions.group().in(ServiceRelationServerSideMetrics.SOURCE_SERVICE_ID, serviceIds),
+                Conditions.group().in(ServiceRelationServerSideMetrics.DEST_SERVICE_ID, serviceIds)))
+                .groupBy(Metrics.ENTITY_ID, ServiceRelationServerSideMetrics.COMPONENT_IDS);
     }
 
     List<Call.CallDetail> queryServiceRelation(Duration duration,
-                                               QueryBuilder<MeasureQuery> queryBuilder,
+                                               Conditions where,
                                                DetectPoint detectPoint) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
         final String modelName = detectPoint == DetectPoint.SERVER ? ServiceRelationServerSideMetrics.INDEX_NAME :
@@ -115,7 +103,7 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
                         ServiceRelationClientSideMetrics.COMPONENT_IDS,
                         Metrics.ENTITY_ID
                 ),
-                Collections.emptySet(), getTimestampRange(duration), queryBuilder
+                Collections.emptySet(), getTimestampRange(duration), where
         );
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -138,47 +126,32 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
     public List<Call.CallDetail> loadInstanceRelationDetectedAtServerSide(String clientServiceId,
                                                                           String serverServiceId,
                                                                           Duration duration) throws IOException {
-        QueryBuilder<MeasureQuery> queryBuilder = buildInstanceRelationsQuery(
-                clientServiceId, serverServiceId);
-        return queryInstanceRelation(duration, queryBuilder, DetectPoint.SERVER);
+        return queryInstanceRelation(duration, instanceRelationsWhere(clientServiceId, serverServiceId),
+                DetectPoint.SERVER);
     }
 
     @Override
     public List<Call.CallDetail> loadInstanceRelationDetectedAtClientSide(String clientServiceId,
                                                                           String serverServiceId,
                                                                           Duration duration) throws IOException {
-        QueryBuilder<MeasureQuery> queryBuilder = buildInstanceRelationsQuery(
-                clientServiceId, serverServiceId);
-        return queryInstanceRelation(duration, queryBuilder, DetectPoint.CLIENT);
+        return queryInstanceRelation(duration, instanceRelationsWhere(clientServiceId, serverServiceId),
+                DetectPoint.CLIENT);
     }
 
-    private QueryBuilder<MeasureQuery> buildInstanceRelationsQuery(String clientServiceId,
-                                                                   String serverServiceId) {
-        return new QueryBuilder<MeasureQuery>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-                List<AbstractCriteria> instanceRelationsQueryConditions = new ArrayList<>(2);
-
-                instanceRelationsQueryConditions.add(
-                        // source_service_id = clientServiceId AND dest_service_id = serverServiceId
-                        and(Lists.newArrayList(
-                                eq(ServiceInstanceRelationServerSideMetrics.SOURCE_SERVICE_ID, clientServiceId),
-                                eq(ServiceInstanceRelationServerSideMetrics.DEST_SERVICE_ID, serverServiceId))
-                        ));
-                instanceRelationsQueryConditions.add(
-                        // dest_service_id = clientServiceId AND source_service_id = serverServiceId
-                        and(Lists.newArrayList(
-                                eq(ServiceInstanceRelationServerSideMetrics.DEST_SERVICE_ID, clientServiceId),
-                                eq(ServiceInstanceRelationServerSideMetrics.SOURCE_SERVICE_ID, serverServiceId)
-                        ))
-                );
-                query.criteria(or(instanceRelationsQueryConditions));
-            }
-        };
+    private Conditions instanceRelationsWhere(String clientServiceId, String serverServiceId) {
+        // (source_service_id = clientServiceId AND dest_service_id = serverServiceId)
+        //   OR (dest_service_id = clientServiceId AND source_service_id = serverServiceId)
+        return Conditions.create().or(List.of(
+                Conditions.group()
+                        .eq(ServiceInstanceRelationServerSideMetrics.SOURCE_SERVICE_ID, clientServiceId)
+                        .eq(ServiceInstanceRelationServerSideMetrics.DEST_SERVICE_ID, serverServiceId),
+                Conditions.group()
+                        .eq(ServiceInstanceRelationServerSideMetrics.DEST_SERVICE_ID, clientServiceId)
+                        .eq(ServiceInstanceRelationServerSideMetrics.SOURCE_SERVICE_ID, serverServiceId)));
     }
 
     List<Call.CallDetail> queryInstanceRelation(Duration duration,
-                                                QueryBuilder<MeasureQuery> queryBuilder,
+                                                Conditions where,
                                                 DetectPoint detectPoint) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
         final String modelName = detectPoint == DetectPoint.SERVER ? ServiceInstanceRelationServerSideMetrics.INDEX_NAME :
@@ -188,7 +161,7 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
                 ImmutableSet.of(
                         Metrics.ENTITY_ID
                 ),
-                Collections.emptySet(), getTimestampRange(duration), queryBuilder
+                Collections.emptySet(), getTimestampRange(duration), where
         );
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -206,8 +179,7 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
 
     @Override
     public List<Call.CallDetail> loadEndpointRelation(Duration duration, String destEndpointId) throws IOException {
-        QueryBuilder<MeasureQuery> queryBuilder = buildEndpointRelationsQueries(destEndpointId);
-        return queryEndpointRelation(duration, queryBuilder, DetectPoint.SERVER);
+        return queryEndpointRelation(duration, destEndpointId, DetectPoint.SERVER);
     }
 
     @Override
@@ -222,20 +194,8 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
         return queryProcessRelation(duration, serviceInstanceId, DetectPoint.SERVER);
     }
 
-    private QueryBuilder<MeasureQuery> buildEndpointRelationsQueries(String destEndpointId) {
-        return new QueryBuilder<MeasureQuery>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-                query.or(eq(EndpointRelationServerSideMetrics.SOURCE_ENDPOINT, destEndpointId))
-                        .or(eq(EndpointRelationServerSideMetrics.DEST_ENDPOINT, destEndpointId));
-
-                query.groupBy(Sets.newHashSet(Metrics.ENTITY_ID));
-            }
-        };
-    }
-
     List<Call.CallDetail> queryEndpointRelation(Duration duration,
-                                                QueryBuilder<MeasureQuery> queryBuilder,
+                                                String destEndpointId,
                                                 DetectPoint detectPoint) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(EndpointRelationServerSideMetrics.INDEX_NAME, duration.getStep());
@@ -243,7 +203,11 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
                 ImmutableSet.of(
                         Metrics.ENTITY_ID
                 ),
-                Collections.emptySet(), getTimestampRange(duration), queryBuilder
+                Collections.emptySet(), getTimestampRange(duration),
+                Conditions.create().or(List.of(
+                        Conditions.group().eq(EndpointRelationServerSideMetrics.SOURCE_ENDPOINT, destEndpointId),
+                        Conditions.group().eq(EndpointRelationServerSideMetrics.DEST_ENDPOINT, destEndpointId)))
+                        .groupBy(Metrics.ENTITY_ID)
         );
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -268,13 +232,10 @@ public class BanyanDBTopologyQueryDAO extends AbstractBanyanDBDAO implements ITo
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(modelName, DownSampling.Minute);
         MeasureQueryResponse resp = queryDebuggable(isColdStage, schema,
                 ImmutableSet.of(Metrics.ENTITY_ID, ProcessRelationClientSideMetrics.COMPONENT_ID),
-                Collections.emptySet(), getTimestampRange(duration), new QueryBuilder<MeasureQuery>() {
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.and(eq(ProcessRelationServerSideMetrics.SERVICE_INSTANCE_ID, serviceInstanceId));
-                        query.groupBy(Sets.newLinkedHashSet(Arrays.asList(Metrics.ENTITY_ID, ProcessRelationClientSideMetrics.COMPONENT_ID)));
-                    }
-                }
+                Collections.emptySet(), getTimestampRange(duration),
+                Conditions.create()
+                        .eq(ProcessRelationServerSideMetrics.SERVICE_INSTANCE_ID, serviceInstanceId)
+                        .groupBy(Metrics.ENTITY_ID, ProcessRelationClientSideMetrics.COMPONENT_ID)
         );
 
         if (resp.size() == 0) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/AbstractBanyanDBDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/AbstractBanyanDBDAO.java
index 2a47f734fb..245cb6bcdb 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/AbstractBanyanDBDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/AbstractBanyanDBDAO.java
@@ -20,26 +20,19 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.gson.Gson;
 import java.util.Collections;
-import java.util.Map;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractCriteria;
 import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
-import org.apache.skywalking.library.banyandb.v1.client.And;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
-import org.apache.skywalking.library.banyandb.v1.client.Or;
-import org.apache.skywalking.library.banyandb.v1.client.PairQueryCondition;
 import org.apache.skywalking.library.banyandb.v1.client.Span;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
-import org.apache.skywalking.library.banyandb.v1.client.TopNQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TopNQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.Trace;
-import org.apache.skywalking.library.banyandb.v1.client.TraceQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TraceQueryResponse;
+import org.apache.skywalking.library.banyandb.v1.client.Value;
+import org.apache.skywalking.library.banyandb.v1.client.metadata.Serializable;
 import org.apache.skywalking.oap.server.core.query.input.AttrCondition;
 import org.apache.skywalking.oap.server.core.query.input.Duration;
 import org.apache.skywalking.oap.server.core.query.type.KeyValue;
@@ -55,7 +48,6 @@ import java.time.Instant;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
-import java.util.function.BiFunction;
 
 public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageClient> {
     private static final Instant UPPER_BOUND = Instant.ofEpochSecond(0, Long.MAX_VALUE);
@@ -70,73 +62,52 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         super(client);
     }
 
-    protected StreamQueryResponse query(boolean isColdStage,
-                                        String streamModelName,
-                                        Set<String> tags,
-                                        QueryBuilder<StreamQuery> builder) throws IOException {
-        return this.query(isColdStage, streamModelName, tags, null, builder);
-    }
-
-    protected StreamQueryResponse query(boolean isColdStage,
-                                        String streamModelName,
-                                        Set<String> tags,
-                                        TimestampRange timestampRange,
-                                        QueryBuilder<StreamQuery> builder) throws IOException {
-        MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(streamModelName);
-        if (schema == null) {
-            throw new IllegalArgumentException("schema is not registered");
-        }
-        final StreamQuery query;
-        Map<String, String> tagProjections = tags.stream().collect(Collectors.toMap(
-            tagName -> tagName,
-            tagName -> schema.getTags().get(tagName)
-        ));
-        if (timestampRange == null) {
-            query = new StreamQuery(List.of(schema.getMetadata().getGroup()), schema.getMetadata().name(), LARGEST_TIME_RANGE, tagProjections);
-        } else {
-            query = new StreamQuery(List.of(schema.getMetadata().getGroup()), schema.getMetadata().name(), timestampRange, tagProjections);
-        }
-        if (isColdStage) {
-            query.setStages(Set.of(BanyanDBStorageConfig.StageName.cold.name()));
-        }
-
-        builder.apply(query);
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
-        if (traceContext != null && traceContext.isDebug()) {
-            query.enableTrace();
-        }
-        return getClient().query(query);
-    }
-
+    /**
+     * Query a stream via BydbQL. Projects the given tags (or {@code *} when empty) and appends the
+     * WHERE / ORDER BY / LIMIT tail carried by {@code where}.
+     *
+     * @param isColdStage     whether to target the cold lifecycle stage
+     * @param streamModelName the record/stream model name to resolve the schema
+     * @param tags            tag columns to project
+     * @param timestampRange  the time range bound to {@code TIME BETWEEN ? AND ?}
+     * @param where           the fluent condition builder holding the clause tail and its params
+     * @return the stream query response
+     * @throws IOException if the query fails
+     */
     protected StreamQueryResponse queryDebuggable(boolean isColdStage,
-                                                  String modelName,
+                                                  String streamModelName,
                                                   Set<String> tags,
                                                   TimestampRange timestampRange,
-                                                  QueryBuilder<StreamQuery> queryBuilder) throws IOException {
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
+                                                  Conditions where) throws IOException {
+        final MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(streamModelName);
+        if (schema == null) {
+            throw new IllegalArgumentException("schema is not registered");
+        }
+        final DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
         DebuggingSpan span = null;
         try {
-            StringBuilder builder = new StringBuilder();
+            final boolean debug = traceContext != null && traceContext.isDebug();
             if (traceContext != null) {
                 span = traceContext.createSpan("Query BanyanDB Stream");
-                MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(modelName);
-                builder.append("Condition: ")
-                       .append("modelName:")
-                       .append(modelName)
-                       .append(", Schema: ")
-                       .append(schema)
-                       .append(", Tags: ")
-                       .append(tags)
-                       .append(", TimestampRange: ")
-                       .append(timestampRange)
-                       .append(", Is cold data query: ")
-                       .append(isColdStage);
-                span.setMsg(builder.toString());
             }
-            StreamQueryResponse response = query(isColdStage, modelName, tags, timestampRange, queryBuilder);
-            if (traceContext != null && traceContext.isDumpStorageRsp()) {
-                builder.append("\n").append(" Response: ").append(new Gson().toJson(response.getElements()));
-                span.setMsg(builder.toString());
+            final StringBuilder ql = new StringBuilder("SELECT ").append(projection(tags, Collections.emptySet()))
+                .append(" FROM STREAM ").append(schema.getMetadata().name())
+                .append(" IN ").append(schema.getMetadata().getGroup());
+            if (isColdStage) {
+                ql.append(" ON ").append(BanyanDBStorageConfig.StageName.cold.name()).append(" STAGES");
+            }
+            ql.append(" TIME BETWEEN ? AND ?");
+            appendBodyWithTrace(ql, where.buildQl(), debug);
+            final List<Serializable<BanyandbModel.TagValue>> params = timeBoundedParams(timestampRange, where.params());
+            final StreamQueryResponse response =
+                getClient().queryStream(ql.toString(), params.toArray(new Serializable[0]));
+            if (span != null) {
+                final StringBuilder msg = new StringBuilder("BydbQL: ").append(ql)
+                    .append("\n Params: ").append(bindings(params));
+                if (traceContext.isDumpStorageRsp()) {
+                    msg.append("\n Response: ").append(new Gson().toJson(response.getElements()));
+                }
+                span.setMsg(msg.toString());
             }
             addDBTrace2DebuggingTrace(response.getTrace(), traceContext, span);
             return response;
@@ -147,6 +118,22 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         }
     }
 
+    /**
+     * Server-side TopN over a pre-aggregated TopN rule via BydbQL {@code SHOW TOP} (MEAN aggregation).
+     * Only equality conditions/attributes are applied — not-equals is handled by a separate exclude rule,
+     * as in the typed path.
+     *
+     * @param isColdStage          whether to target the cold lifecycle stage
+     * @param schema               the source measure schema (its group hosts the TopN rule)
+     * @param timestampRange       the time range bound to {@code TIME BETWEEN ? AND ?}
+     * @param number               the TopN count bound to {@code SHOW TOP ?}
+     * @param sort                 the ranking direction
+     * @param additionalConditions equality conditions to AND into the WHERE clause
+     * @param attributes           attribute conditions; only equality ones are applied
+     * @param topNRuleName         the pre-aggregated TopN measure name in the FROM clause
+     * @return the TopN query response
+     * @throws IOException if the query fails
+     */
     protected TopNQueryResponse topNQueryDebuggable(boolean isColdStage,
                                                     MetadataRegistry.Schema schema,
                                                     TimestampRange timestampRange,
@@ -155,35 +142,52 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
                                                     List<KeyValue> additionalConditions,
                                                     List<AttrCondition> attributes,
                                                     String topNRuleName) throws IOException {
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
+        final DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
         DebuggingSpan span = null;
         try {
-            StringBuilder builder = new StringBuilder();
+            final boolean debug = traceContext != null && traceContext.isDebug();
             if (traceContext != null) {
-                span = traceContext.createSpan("Query BanyanDB TopNQuery");
-                builder.append("Condition: ")
-                       .append("Schema: ")
-                       .append(schema)
-                       .append(", TopNRuleName: ")
-                       .append(topNRuleName)
-                       .append(", TimestampRange: ")
-                       .append(timestampRange)
-                       .append(", Number: ")
-                       .append(number)
-                       .append(", Sort: ")
-                       .append(sort)
-                       .append(", AdditionalConditions: ")
-                       .append(additionalConditions)
-                       .append(", Attributes: ")
-                       .append(attributes)
-                       .append(", Is cold data query: ")
-                       .append(isColdStage);
-                span.setMsg(builder.toString());
+                span = traceContext.createSpan("Query BanyanDB TopN");
+            }
+            final Conditions where = Conditions.create();
+            if (CollectionUtils.isNotEmpty(additionalConditions)) {
+                for (final KeyValue kv : additionalConditions) {
+                    where.eq(qualify(kv.getKey()), kv.getValue());
+                }
             }
-            TopNQueryResponse response = topNQuery(isColdStage, schema, timestampRange, number, sort, additionalConditions, attributes, topNRuleName);
-            if (traceContext != null && traceContext.isDumpStorageRsp()) {
-                builder.append("\n").append(" Response: ").append(new Gson().toJson(response.getTopNLists()));
-                span.setMsg(builder.toString());
+            if (CollectionUtils.isNotEmpty(attributes)) {
+                for (final AttrCondition attr : attributes) {
+                    // server-side TopN does not support not-equals; those are handled by a dedicated
+                    // exclude rule, so only equality attributes are applied here (matches the typed path).
+                    if (attr.isEquals()) {
+                        where.eq(qualify(attr.getKey()), attr.getValue());
+                    }
+                }
+            }
+            final List<Serializable<BanyandbModel.TagValue>> params = new ArrayList<>();
+            params.add(Value.longTagValue((long) number));
+            params.add(Value.timestampTagValue(timestampRange.getBegin()));
+            params.add(Value.timestampTagValue(timestampRange.getEnd()));
+            params.addAll(where.params());
+            final StringBuilder ql = new StringBuilder("SHOW TOP ? FROM MEASURE ")
+                .append(topNRuleName).append(" IN ").append(schema.getMetadata().getGroup());
+            if (isColdStage) {
+                ql.append(" ON ").append(BanyanDBStorageConfig.StageName.cold.name()).append(" STAGES");
+            }
+            ql.append(" TIME BETWEEN ? AND ?").append(where.buildQl())
+              .append(" AGGREGATE BY MEAN ORDER BY ").append(sort == AbstractQuery.Sort.DESC ? "DESC" : "ASC");
+            if (debug) {
+                ql.append(" WITH QUERY_TRACE");
+            }
+            final TopNQueryResponse response =
+                getClient().queryTopN(ql.toString(), params.toArray(new Serializable[0]));
+            if (span != null) {
+                final StringBuilder msg = new StringBuilder("BydbQL: ").append(ql)
+                    .append("\n Params: ").append(bindings(params));
+                if (traceContext.isDumpStorageRsp()) {
+                    msg.append("\n Response: ").append(new Gson().toJson(response.getTopNLists()));
+                }
+                span.setMsg(msg.toString());
             }
             return response;
         } finally {
@@ -193,71 +197,126 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         }
     }
 
-    private TopNQueryResponse topNQuery(boolean isColdStage,
-                                        MetadataRegistry.Schema schema,
-                                        TimestampRange timestampRange,
-                                        int number,
-                                        AbstractQuery.Sort sort,
-                                        List<KeyValue> additionalConditions,
-                                        List<AttrCondition> attributes,
-                                        String topNRuleName) throws IOException {
-        final TopNQuery q = new TopNQuery(List.of(schema.getMetadata().getGroup()),
-                                          topNRuleName,
-                                          timestampRange,
-                                          number, sort);
-        q.setAggregationType(MeasureQuery.Aggregation.Type.MEAN);
-        List<PairQueryCondition<?>> conditions = new ArrayList<>();
-        if (CollectionUtils.isNotEmpty(additionalConditions)) {
-            for (final KeyValue kv : additionalConditions) {
-                conditions.add(PairQueryCondition.StringQueryCondition.eq(kv.getKey(), kv.getValue()));
+    /**
+     * Ad-hoc TopN over a raw measure via BydbQL {@code SELECT TOP} (no pre-aggregated rule), returning
+     * measure DataPoints. Unlike the general measure {@code queryDebuggable}, this supports not-equals
+     * conditions in {@code where}.
+     *
+     * @param isColdStage    whether to target the cold lifecycle stage
+     * @param schema         the source measure schema
+     * @param timestampRange the time range bound to {@code TIME BETWEEN ? AND ?}; null means all time
+     * @param valueColumn       the field to rank by and aggregate
+     * @param aggregateFunction the BydbQL aggregate function applied to {@code valueColumn}, chosen by the
+     *                          caller (e.g. {@code MEAN})
+     * @param groupByColumn     the tag to group by (e.g. entity_id)
+     * @param number            the TopN count bound to {@code SELECT TOP ?}
+     * @param sort              the ranking direction
+     * @param where             the WHERE conditions (equality and not-equality)
+     * @return the measure query response (DataPoints)
+     * @throws IOException if the query fails
+     */
+    protected MeasureQueryResponse queryDebuggable(boolean isColdStage,
+                                                   MetadataRegistry.Schema schema,
+                                                   TimestampRange timestampRange,
+                                                   String valueColumn,
+                                                   String aggregateFunction,
+                                                   String groupByColumn,
+                                                   int number,
+                                                   AbstractQuery.Sort sort,
+                                                   Conditions where) throws IOException {
+        final DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
+        DebuggingSpan span = null;
+        try {
+            final boolean debug = traceContext != null && traceContext.isDebug();
+            if (traceContext != null) {
+                span = traceContext.createSpan("Query BanyanDB TopN Measure");
             }
-        }
-        if (CollectionUtils.isNotEmpty(attributes)) {
-            attributes.forEach(attr -> {
-                if (attr.isEquals()) {
-                    conditions.add(PairQueryCondition.StringQueryCondition.eq(attr.getKey(), attr.getValue()));
+            final String value = qualify(valueColumn);
+            // GROUP BY <value> needs <value> in the field projection, but the transformer projects only plain
+            // columns (not the TOP order field or the aggregate) — so project value plainly in addition to the aggregate.
+            final StringBuilder ql = new StringBuilder("SELECT TOP ? ")
+                .append(value).append(sort == AbstractQuery.Sort.DESC ? " DESC" : " ASC")
+                .append(", ").append(aggregateFunction).append("(").append(value).append("), ")
+                .append(value).append(", ").append(groupByColumn)
+                .append(" FROM MEASURE ").append(schema.getMetadata().name())
+                .append(" IN ").append(schema.getMetadata().getGroup());
+            if (isColdStage) {
+                ql.append(" ON ").append(BanyanDBStorageConfig.StageName.cold.name()).append(" STAGES");
+            }
+            ql.append(" TIME BETWEEN ? AND ?").append(where.buildQl())
+              .append(" GROUP BY ").append(groupByColumn).append(", ").append(value);
+            if (debug) {
+                ql.append(" WITH QUERY_TRACE");
+            }
+            final List<Serializable<BanyandbModel.TagValue>> params = new ArrayList<>();
+            params.add(Value.longTagValue((long) number));
+            params.addAll(timeBoundedParams(timestampRange, where.params()));
+            final MeasureQueryResponse response =
+                getClient().queryMeasure(ql.toString(), params.toArray(new Serializable[0]));
+            if (span != null) {
+                final StringBuilder msg = new StringBuilder("BydbQL: ").append(ql)
+                    .append("\n Params: ").append(bindings(params));
+                if (traceContext.isDumpStorageRsp()) {
+                    msg.append("\n Response: ").append(new Gson().toJson(response.getDataPoints()));
                 }
-                //server side topn query does not support not equals condition
-                //the not equals condition should be handled by a specific topN rule by adding exclude condition.
-            });
-        }
-        q.setConditions(conditions);
-        if (isColdStage) {
-            q.setStages(List.of(BanyanDBStorageConfig.StageName.cold.name()));
+                span.setMsg(msg.toString());
+            }
+            addDBTrace2DebuggingTrace(response.getTrace(), traceContext, span);
+            return response;
+        } finally {
+            if (traceContext != null && span != null) {
+                traceContext.stopSpan(span);
+            }
         }
-
-        return getClient().query(q);
     }
 
+    /**
+     * Query a measure via BydbQL. Projects the given tags/fields and appends the WHERE / GROUP BY /
+     * ORDER BY / LIMIT tail carried by {@code where}.
+     *
+     * @param isColdStage    whether to target the cold lifecycle stage
+     * @param schema         the resolved measure schema (group + name)
+     * @param tags           tag columns to project
+     * @param fields         field columns to project
+     * @param timestampRange the time range bound to {@code TIME BETWEEN ? AND ?}
+     * @param where          the fluent condition builder holding the clause tail and its params
+     * @return the measure query response
+     * @throws IOException if the query fails
+     */
     protected MeasureQueryResponse queryDebuggable(boolean isColdStage,
                                                    MetadataRegistry.Schema schema,
                                                    Set<String> tags,
                                                    Set<String> fields,
                                                    TimestampRange timestampRange,
-                                                   QueryBuilder<MeasureQuery> queryBuilder) throws IOException {
+                                                   Conditions where) throws IOException {
+        if (schema == null) {
+            throw new IllegalArgumentException("measure is not registered");
+        }
         DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
         DebuggingSpan span = null;
         try {
-            StringBuilder builder = new StringBuilder();
+            final boolean debug = traceContext != null && traceContext.isDebug();
             if (traceContext != null) {
                 span = traceContext.createSpan("Query BanyanDB Measure");
-                builder.append("Condition: ")
-                       .append("Schema: ")
-                       .append(schema)
-                       .append(", Tags: ")
-                       .append(tags)
-                       .append(", Fields: ")
-                       .append(fields)
-                       .append(", TimestampRange: ")
-                       .append(timestampRange)
-                       .append(", Is cold data query: ")
-                       .append(isColdStage);
-                span.setMsg(builder.toString());
             }
-            MeasureQueryResponse response = query(isColdStage, schema, tags, fields, timestampRange, queryBuilder);
-            if (traceContext != null && traceContext.isDumpStorageRsp()) {
-                builder.append("\n").append(" Response: ").append(new Gson().toJson(response.getDataPoints()));
-                span.setMsg(builder.toString());
+            final StringBuilder ql = new StringBuilder("SELECT ").append(projection(tags, fields))
+                .append(" FROM MEASURE ").append(schema.getMetadata().name())
+                .append(" IN ").append(schema.getMetadata().getGroup());
+            if (isColdStage) {
+                ql.append(" ON ").append(BanyanDBStorageConfig.StageName.cold.name()).append(" STAGES");
+            }
+            ql.append(" TIME BETWEEN ? AND ?");
+            appendBodyWithTrace(ql, where.buildQl(), debug);
+            final List<Serializable<BanyandbModel.TagValue>> params = timeBoundedParams(timestampRange, where.params());
+            final MeasureQueryResponse response =
+                getClient().queryMeasure(ql.toString(), params.toArray(new Serializable[0]));
+            if (span != null) {
+                final StringBuilder msg = new StringBuilder("BydbQL: ").append(ql)
+                    .append("\n Params: ").append(bindings(params));
+                if (traceContext.isDumpStorageRsp()) {
+                    msg.append("\n Response: ").append(new Gson().toJson(response.getDataPoints()));
+                }
+                span.setMsg(msg.toString());
             }
             addDBTrace2DebuggingTrace(response.getTrace(), traceContext, span);
             return response;
@@ -268,71 +327,127 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         }
     }
 
-    protected MeasureQueryResponse query(boolean isColdStage,
-                                         MetadataRegistry.Schema schema,
-                                         Set<String> tags,
-                                         Set<String> fields,
-                                         QueryBuilder<MeasureQuery> builder) throws IOException {
-        return query(isColdStage, schema, tags, fields, null, builder);
+    private static String projection(Set<String> tags, Set<String> fields) {
+        final List<String> cols = new ArrayList<>(tags.size() + fields.size());
+        cols.addAll(tags);
+        cols.addAll(fields);
+        if (cols.isEmpty()) {
+            return "*";
+        }
+        Collections.sort(cols);
+        return cols.stream().map(AbstractBanyanDBDAO::qualify).collect(Collectors.joining(", "));
     }
 
-    protected MeasureQueryResponse query(boolean isColdStage,
-                                         MetadataRegistry.Schema schema,
-                                         Set<String> tags,
-                                         Set<String> fields,
-                                         TimestampRange timestampRange,
-                                         QueryBuilder<MeasureQuery> builder) throws IOException {
-        if (schema == null) {
-            throw new IllegalArgumentException("measure is not registered");
+    /**
+     * Build the bound-parameter list for a BydbQL SELECT: the two {@code TIME BETWEEN ? AND ?} bounds first
+     * (in that order, matching the two leading placeholders), then the caller's condition params.
+     *
+     * @param timestampRange the time range whose begin/end bind the two leading placeholders
+     * @param originParams   params for the placeholders in the caller's condition clause, or null
+     * @return the ordered param list ready to pass to the query stub
+     */
+    private static List<Serializable<BanyandbModel.TagValue>> timeBoundedParams(
+        TimestampRange timestampRange, List<Serializable<BanyandbModel.TagValue>> originParams) {
+        // A null range means "all time": callers querying the full history pass null instead of
+        // constructing an explicit full-bound TimestampRange (which equals LARGEST_TIME_RANGE).
+        final TimestampRange range = timestampRange == null ? LARGEST_TIME_RANGE : timestampRange;
+        final List<Serializable<BanyandbModel.TagValue>> params =
+            new ArrayList<>(2 + (originParams == null ? 0 : originParams.size()));
+        params.add(Value.timestampTagValue(range.getBegin()));
+        params.add(Value.timestampTagValue(range.getEnd()));
+        if (originParams != null) {
+            params.addAll(originParams);
+        }
+        return params;
+    }
+
+    /**
+     * Append the clause tail, inserting {@code WITH QUERY_TRACE} (when debugging) before any
+     * {@code LIMIT}/{@code OFFSET} — BydbQL requires the trace marker ahead of LIMIT/OFFSET or the parser
+     * rejects it with {@code unexpected token "WITH"}.
+     */
+    private static void appendBodyWithTrace(StringBuilder ql, String body, boolean debug) {
+        final String tail = body == null ? "" : body;
+        if (!debug) {
+            ql.append(tail);
+            return;
         }
-        final MeasureQuery query;
-        Map<String, String> tagProjections = tags.stream().collect(Collectors.toMap(
-            tagName -> tagName,
-            tagName -> schema.getTags().get(tagName)
-        ));
-        if (timestampRange == null) {
-            query = new MeasureQuery(List.of(schema.getMetadata().getGroup()), schema.getMetadata().name(), LARGEST_TIME_RANGE, tagProjections, fields);
+        final int limitIdx = tail.indexOf(" LIMIT ");
+        if (limitIdx >= 0) {
+            ql.append(tail, 0, limitIdx).append(" WITH QUERY_TRACE").append(tail, limitIdx, tail.length());
         } else {
-            query = new MeasureQuery(List.of(schema.getMetadata().getGroup()), schema.getMetadata().name(), timestampRange, tagProjections, fields);
-        }
-        if (isColdStage) {
-            query.setStages(Set.of(BanyanDBStorageConfig.StageName.cold.name()));
+            ql.append(tail).append(" WITH QUERY_TRACE");
         }
+    }
 
-        builder.apply(query);
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
-        if (traceContext != null && traceContext.isDebug()) {
-            query.enableTrace();
-        }
-        return getClient().query(query);
+    /**
+     * Double-quote a column identifier for BydbQL. Quoting unconditionally sidesteps the reserved-keyword
+     * check (e.g. a column named {@code count}) without tracking BanyanDB's keyword list.
+     *
+     * @param column the column name to emit in a BydbQL clause
+     * @return the column wrapped in double quotes
+     */
+    protected static String qualify(String column) {
+        return "\"" + column + "\"";
+    }
+
+    /**
+     * Render the bound {@code ?} values for a debug-span message. Only called when a span exists, so
+     * {@code serialize()} stays off the hot path.
+     *
+     * @param params the ordered bound parameters
+     * @return a compact single-line list of the serialized parameter values
+     */
+    private static String bindings(List<Serializable<BanyandbModel.TagValue>> params) {
+        return params.stream()
+                     .map(p -> p.serialize().toString().replaceAll("\\s+", " ").trim())
+                     .collect(Collectors.joining(", ", "[", "]"));
     }
 
+    /**
+     * Query a trace via BydbQL. Projects only raw span data ({@code SELECT ()}); tags remain usable in
+     * the {@code where} tail (WHERE / ORDER BY).
+     *
+     * @param isColdStage    whether to target the cold lifecycle stage
+     * @param traceModelName the trace model name to resolve the schema
+     * @param timestampRange the time range bound to {@code TIME BETWEEN ? AND ?}
+     * @param where          the fluent condition builder holding the clause tail and its params
+     * @return the trace query response
+     * @throws IOException if the query fails
+     */
     protected TraceQueryResponse queryTraceDebuggable(boolean isColdStage,
-                                                    String modelName,
-                                                    TimestampRange timestampRange,
-                                                    QueryBuilder<TraceQuery> queryBuilder) throws IOException {
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
+                                                      String traceModelName,
+                                                      TimestampRange timestampRange,
+                                                      Conditions where) throws IOException {
+        final MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(traceModelName);
+        if (schema == null) {
+            throw new IllegalArgumentException("schema is not registered");
+        }
+        final DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
         DebuggingSpan span = null;
         try {
-            StringBuilder builder = new StringBuilder();
+            final boolean debug = traceContext != null && traceContext.isDebug();
             if (traceContext != null) {
                 span = traceContext.createSpan("Query BanyanDB Trace");
-                MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(modelName);
-                builder.append("Condition: ")
-                       .append("modelName:")
-                       .append(modelName)
-                       .append(", Schema: ")
-                       .append(schema)
-                       .append(", TimestampRange: ")
-                       .append(timestampRange)
-                       .append(", Is cold data query: ")
-                       .append(isColdStage);
-                span.setMsg(builder.toString());
             }
-            TraceQueryResponse response = queryTrace(isColdStage, modelName, timestampRange, queryBuilder);
-            if (traceContext != null && traceContext.isDumpStorageRsp()) {
-                builder.append("\n").append(" Response: ").append(new Gson().toJson(response.getTraces()));
-                span.setMsg(builder.toString());
+            final StringBuilder ql = new StringBuilder("SELECT () FROM TRACE ")
+                .append(schema.getMetadata().name())
+                .append(" IN ").append(schema.getMetadata().getGroup());
+            if (isColdStage) {
+                ql.append(" ON ").append(BanyanDBStorageConfig.StageName.cold.name()).append(" STAGES");
+            }
+            ql.append(" TIME BETWEEN ? AND ?");
+            appendBodyWithTrace(ql, where.buildQl(), debug);
+            final List<Serializable<BanyandbModel.TagValue>> params = timeBoundedParams(timestampRange, where.params());
+            final TraceQueryResponse response =
+                getClient().queryTrace(ql.toString(), params.toArray(new Serializable[0]));
+            if (span != null) {
+                final StringBuilder msg = new StringBuilder("BydbQL: ").append(ql)
+                    .append("\n Params: ").append(bindings(params));
+                if (traceContext.isDumpStorageRsp()) {
+                    msg.append("\n Response: ").append(new Gson().toJson(response.getTraces()));
+                }
+                span.setMsg(msg.toString());
             }
             addDBTrace2DebuggingTrace(response.getTraceResult(), traceContext, span);
             return response;
@@ -343,31 +458,6 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         }
     }
 
-    /**
-     * Trace query doesn't recommend to set query tags, if you need to debug, you can set tags here.
-     */
-    private TraceQueryResponse queryTrace(boolean isColdStage,
-                                       String traceModelName,
-                                       TimestampRange timestampRange,
-                                       QueryBuilder<TraceQuery> builder) throws IOException {
-        MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findRecordMetadata(traceModelName);
-        if (schema == null) {
-            throw new IllegalArgumentException("schema is not registered");
-        }
-        final TraceQuery query = new TraceQuery(List.of(schema.getMetadata().getGroup()), schema.getMetadata().name(), timestampRange, Collections.emptySet());
-
-        if (isColdStage) {
-            query.setStages(Set.of(BanyanDBStorageConfig.StageName.cold.name()));
-        }
-
-        builder.apply(query);
-        DebuggingTraceContext traceContext = DebuggingTraceContext.TRACE_CONTEXT.get();
-        if (traceContext != null && traceContext.isDebug()) {
-           query.enableTrace();
-        }
-        return getClient().query(query);
-    }
-
     private void addDBTrace2DebuggingTrace(Trace trace, DebuggingTraceContext traceContext, DebuggingSpan parentSpan) {
         if (traceContext == null || parentSpan == null || trace == null) {
             return;
@@ -388,93 +478,6 @@ public abstract class AbstractBanyanDBDAO extends AbstractDAO<BanyanDBStorageCli
         span.getChildren().forEach(child -> addDBSpan2DebuggingTrace(child, traceContext, debuggingSpan));
     }
 
-    protected static QueryBuilder<MeasureQuery> emptyMeasureQuery() {
-        return new QueryBuilder<MeasureQuery>() {
-            @Override
-            protected void apply(MeasureQuery query) {
-            }
-        };
-    }
-
-    protected abstract static class QueryBuilder<T extends AbstractQuery<? extends com.google.protobuf.GeneratedMessage>> {
-        protected abstract void apply(final T query);
-
-        protected PairQueryCondition<Long> eq(String name, long value) {
-            return PairQueryCondition.LongQueryCondition.eq(name, value);
-        }
-
-        protected PairQueryCondition<List<String>> having(String name, List<String> value) {
-            return PairQueryCondition.StringArrayQueryCondition.having(name, value);
-        }
-
-        protected PairQueryCondition<Long> lte(String name, long value) {
-            return PairQueryCondition.LongQueryCondition.le(name, value);
-        }
-
-        protected PairQueryCondition<Long> gte(String name, long value) {
-            return PairQueryCondition.LongQueryCondition.ge(name, value);
-        }
-
-        protected PairQueryCondition<Long> gt(String name, long value) {
-            return PairQueryCondition.LongQueryCondition.gt(name, value);
-        }
-
-        protected PairQueryCondition<String> eq(String name, String value) {
-            return PairQueryCondition.StringQueryCondition.eq(name, value);
-        }
-
-        protected PairQueryCondition<String> ne(String name, String value) {
-            return PairQueryCondition.StringQueryCondition.ne(name, value);
-        }
-
-        protected PairQueryCondition<String> match(String name, String value) {
-            return PairQueryCondition.StringQueryCondition.match(name, value);
-        }
-
-        protected PairQueryCondition<String> match(String name, String value, BanyandbModel.Condition.MatchOption matchOption) {
-            return PairQueryCondition.StringQueryCondition.match(name, value, matchOption);
-        }
-
-        protected PairQueryCondition<List<String>> in(String name, List<String> values) {
-            return PairQueryCondition.StringArrayQueryCondition.in(name, values);
-        }
-
-        protected PairQueryCondition<List<String>> notIn(String name, List<String> values) {
-            return PairQueryCondition.StringArrayQueryCondition.in(name, values);
-        }
-
-        protected PairQueryCondition<Long> ne(String name, long value) {
-            return PairQueryCondition.LongQueryCondition.ne(name, value);
-        }
-
-        protected AbstractCriteria and(List<? extends AbstractCriteria> conditions) {
-            if (conditions.isEmpty()) {
-                return null;
-            }
-            if (conditions.size() == 1) {
-                return conditions.get(0);
-            }
-
-            return conditions.subList(2, conditions.size()).stream().reduce(
-                    And.create(conditions.get(0), conditions.get(1)),
-                    (BiFunction<AbstractCriteria, AbstractCriteria, AbstractCriteria>) And::create,
-                    And::create);
-        }
-
-        protected AbstractCriteria or(List<? extends AbstractCriteria> conditions) {
-            if (conditions.isEmpty()) {
-                return null;
-            }
-            if (conditions.size() == 1) {
-                return conditions.get(0);
-            }
-            return conditions.subList(2, conditions.size()).stream().reduce(
-                    Or.create(conditions.get(0), conditions.get(1)),
-                    (BiFunction<AbstractCriteria, AbstractCriteria, AbstractCriteria>) Or::create,
-                    Or::create);
-        }
-    }
-
     protected TimestampRange getTimestampRange(@Nullable Duration duration) {
         long startTimeMillis = 0;
         long endTimeMillis = 0;
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAlarmQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAlarmQueryDAO.java
index 29e1878214..58cc2c9d2b 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAlarmQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAlarmQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.alarm.AlarmRecord;
 import org.apache.skywalking.oap.server.core.alarm.AlarmRecoveryRecord;
@@ -68,30 +66,24 @@ public class BanyanDBAlarmQueryDAO extends AbstractBanyanDBDAO implements IAlarm
     @Override
     public Alarms getAlarm(Integer scopeId, String keyword, int limit, int from, Duration duration, List<Tag> tags) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
-        StreamQueryResponse resp = query(isColdStage, AlarmRecord.INDEX_NAME, TAGS,
-                getTimestampRange(duration),
-                new QueryBuilder<>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        if (Objects.nonNull(scopeId)) {
-                            query.and(eq(AlarmRecord.SCOPE, (long) scopeId));
-                        }
-                        if (StringUtil.isNotEmpty(keyword)) {
-                            query.and(match(AlarmRecord.ALARM_MESSAGE, keyword));
-                        }
-                        if (CollectionUtils.isNotEmpty(tags)) {
-                            List<String> tagsConditions = new ArrayList<>(tags.size());
-                            for (final Tag tag : tags) {
-                                tagsConditions.add(tag.toString());
-                            }
-                            query.and(having(AlarmRecord.TAGS, tagsConditions));
-                        }
+        final Conditions where = Conditions.create();
+        if (Objects.nonNull(scopeId)) {
+            where.eq(AlarmRecord.SCOPE, (long) scopeId);
+        }
+        if (StringUtil.isNotEmpty(keyword)) {
+            where.match(AlarmRecord.ALARM_MESSAGE, keyword);
+        }
+        if (CollectionUtils.isNotEmpty(tags)) {
+            List<String> tagsConditions = new ArrayList<>(tags.size());
+            for (final Tag tag : tags) {
+                tagsConditions.add(tag.toString());
+            }
+            where.having(AlarmRecord.TAGS, tagsConditions);
+        }
+        where.orderByDesc().limit(limit).offset(from);
 
-                        query.setLimit(limit);
-                        query.setOffset(from);
-                        query.setOrderBy(new StreamQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(isColdStage, AlarmRecord.INDEX_NAME, TAGS,
+                getTimestampRange(duration), where);
 
         Alarms alarms = new Alarms();
 
@@ -170,40 +162,35 @@ public class BanyanDBAlarmQueryDAO extends AbstractBanyanDBDAO implements IAlarm
                          final EntityIdConstraint entityConstraint,
                          final int queryLimit,
                          final int queryOffset) throws IOException {
-        final StreamQueryResponse resp = query(isColdStage, AlarmRecord.INDEX_NAME, TAGS,
-                getTimestampRange(duration),
-                new QueryBuilder<>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(condition.getKeyword())) {
-                            query.and(match(AlarmRecord.ALARM_MESSAGE, condition.getKeyword()));
-                        }
-                        if (StringUtil.isNotEmpty(condition.getLayer())) {
-                            query.and(eq(AlarmRecord.LAYER, (long) Layer.nameOf(condition.getLayer()).value()));
-                        }
-                        if (CollectionUtils.isNotEmpty(condition.getRuleNames())) {
-                            query.and(in(AlarmRecord.RULE_NAME, condition.getRuleNames()));
-                        }
-                        if (entityConstraint != null) {
-                            if (entityConstraint.getId0() != null) {
-                                query.and(eq(AlarmRecord.ID0, entityConstraint.getId0()));
-                            }
-                            if (entityConstraint.getId1() != null) {
-                                query.and(eq(AlarmRecord.ID1, entityConstraint.getId1()));
-                            }
-                        }
-                        if (CollectionUtils.isNotEmpty(condition.getTags())) {
-                            List<String> tagsConditions = new ArrayList<>(condition.getTags().size());
-                            for (final Tag tag : condition.getTags()) {
-                                tagsConditions.add(tag.toString());
-                            }
-                            query.and(having(AlarmRecord.TAGS, tagsConditions));
-                        }
-                        query.setLimit(queryLimit);
-                        query.setOffset(queryOffset);
-                        query.setOrderBy(new StreamQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(condition.getKeyword())) {
+            where.match(AlarmRecord.ALARM_MESSAGE, condition.getKeyword());
+        }
+        if (StringUtil.isNotEmpty(condition.getLayer())) {
+            where.eq(AlarmRecord.LAYER, Layer.nameOf(condition.getLayer()).value());
+        }
+        if (CollectionUtils.isNotEmpty(condition.getRuleNames())) {
+            where.in(AlarmRecord.RULE_NAME, condition.getRuleNames());
+        }
+        if (entityConstraint != null) {
+            if (entityConstraint.getId0() != null) {
+                where.eq(AlarmRecord.ID0, entityConstraint.getId0());
+            }
+            if (entityConstraint.getId1() != null) {
+                where.eq(AlarmRecord.ID1, entityConstraint.getId1());
+            }
+        }
+        if (CollectionUtils.isNotEmpty(condition.getTags())) {
+            List<String> tagsConditions = new ArrayList<>(condition.getTags().size());
+            for (final Tag tag : condition.getTags()) {
+                tagsConditions.add(tag.toString());
+            }
+            where.having(AlarmRecord.TAGS, tagsConditions);
+        }
+        where.orderByDesc().limit(queryLimit).offset(queryOffset);
+
+        final StreamQueryResponse resp = queryDebuggable(isColdStage, AlarmRecord.INDEX_NAME, TAGS,
+                getTimestampRange(duration), where);
         for (final RowEntity rowEntity : resp.getElements()) {
             final AlarmRecord.Builder builder = new AlarmRecord.Builder();
             final AlarmRecord alarmRecord = builder.storage2Entity(
@@ -250,14 +237,9 @@ public class BanyanDBAlarmQueryDAO extends AbstractBanyanDBDAO implements IAlarm
         }
         final boolean isColdStage = duration != null && duration.isColdStage();
         List<String> uuids = msgs.stream().map(AlarmMessage::getUuid).collect(Collectors.toList());
-        StreamQueryResponse resp = query(isColdStage, AlarmRecoveryRecord.INDEX_NAME, RECOVERY_TAGS,
-                getTimestampRange(duration),
-                new QueryBuilder<>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.and(in(AlarmRecoveryRecord.UUID, uuids));
-                    }
-                });
+        final Conditions where = Conditions.create().in(AlarmRecoveryRecord.UUID, uuids);
+        StreamQueryResponse resp = queryDebuggable(isColdStage, AlarmRecoveryRecord.INDEX_NAME, RECOVERY_TAGS,
+                getTimestampRange(duration), where);
 
         for (final RowEntity rowEntity : resp.getElements()) {
             AlarmRecoveryRecord.Builder builder = new AlarmRecoveryRecord.Builder();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskLogQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskLogQueryDAO.java
index b1ab61dd22..b106cd852f 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskLogQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskLogQueryDAO.java
@@ -20,7 +20,6 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
 import org.apache.skywalking.library.banyandb.v1.client.Element;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.asyncprofiler.storage.AsyncProfilerTaskLogRecord;
 import org.apache.skywalking.oap.server.core.query.AsyncProfilerTaskLog;
@@ -54,14 +53,11 @@ public class BanyanDBAsyncProfilerTaskLogQueryDAO extends AbstractBanyanDBDAO im
 
     @Override
     public List<AsyncProfilerTaskLog> getTaskLogList(String taskId) throws IOException {
-        StreamQueryResponse resp = query(false, AsyncProfilerTaskLogRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.and(eq(AsyncProfilerTaskLogRecord.TASK_ID, taskId));
-                        query.setLimit(BanyanDBAsyncProfilerTaskLogQueryDAO.this.queryMaxSize);
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(false, AsyncProfilerTaskLogRecord.INDEX_NAME, TAGS,
+                null,
+                Conditions.create()
+                        .eq(AsyncProfilerTaskLogRecord.TASK_ID, taskId)
+                        .limit(queryMaxSize));
 
         final LinkedList<AsyncProfilerTaskLog> tasks = new LinkedList<>();
         for (final Element element : resp.getElements()) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskQueryDAO.java
index c8155ed98b..d2fba2aba8 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBAsyncProfilerTaskQueryDAO.java
@@ -21,9 +21,7 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 import com.google.common.collect.ImmutableSet;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.TimeBucket;
@@ -70,22 +68,13 @@ public class BanyanDBAsyncProfilerTaskQueryDAO extends AbstractBanyanDBDAO imple
         if (endTimeBucket != null) {
             endTS = TimeBucket.getTimestamp(endTimeBucket);
         }
-        StreamQueryResponse resp = query(false, AsyncProfilerTaskRecord.INDEX_NAME, TAGS, new TimestampRange(startTS, endTS),
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(AsyncProfilerTaskRecord.SERVICE_ID, serviceId));
-                        }
-
-                        if (limit != null) {
-                            query.setLimit(limit);
-                        } else {
-                            query.setLimit(BanyanDBAsyncProfilerTaskQueryDAO.this.queryMaxSize);
-                        }
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(AsyncProfilerTaskRecord.SERVICE_ID, serviceId);
+        }
+        where.orderByDesc().limit(limit != null ? limit : queryMaxSize);
+        StreamQueryResponse resp = queryDebuggable(false, AsyncProfilerTaskRecord.INDEX_NAME, TAGS,
+                new TimestampRange(startTS, endTS), where);
 
         List<AsyncProfilerTask> tasks = new ArrayList<>(resp.size());
         for (final RowEntity entity : resp.getElements()) {
@@ -96,16 +85,13 @@ public class BanyanDBAsyncProfilerTaskQueryDAO extends AbstractBanyanDBDAO imple
 
     @Override
     public AsyncProfilerTask getById(String id) throws IOException {
-        StreamQueryResponse resp = query(false, AsyncProfilerTaskRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(id)) {
-                            query.and(eq(AsyncProfilerTaskRecord.TASK_ID, id));
-                        }
-                        query.setLimit(1);
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(id)) {
+            where.eq(AsyncProfilerTaskRecord.TASK_ID, id);
+        }
+        where.limit(1L);
+        StreamQueryResponse resp = queryDebuggable(false, AsyncProfilerTaskRecord.INDEX_NAME, TAGS,
+                null, where);
 
         if (resp.size() == 0) {
             return null;
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBBrowserLogQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBBrowserLogQueryDAO.java
index e2ccda8956..b72a163028 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBBrowserLogQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBBrowserLogQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.browser.manual.errorlog.BrowserErrorLogRecord;
 import org.apache.skywalking.oap.server.core.browser.source.BrowserErrorCategory;
@@ -52,31 +50,23 @@ public class BanyanDBBrowserLogQueryDAO extends AbstractBanyanDBDAO implements I
                                                   BrowserErrorCategory category, Duration duration,
                                                   int limit, int from) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
-        StreamQueryResponse resp = query(isColdStage, BrowserErrorLogRecord.INDEX_NAME, TAGS,
-                getTimestampRange(duration), new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(BrowserErrorLogRecord.SERVICE_ID, serviceId));
-                        }
-
-                        if (StringUtil.isNotEmpty(serviceVersionId)) {
-                            query.and(eq(BrowserErrorLogRecord.SERVICE_VERSION_ID, serviceVersionId));
-                        }
-
-                        if (StringUtil.isNotEmpty(pagePathId)) {
-                            query.and(eq(BrowserErrorLogRecord.PAGE_PATH_ID, pagePathId));
-                        }
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(BrowserErrorLogRecord.SERVICE_ID, serviceId);
+        }
+        if (StringUtil.isNotEmpty(serviceVersionId)) {
+            where.eq(BrowserErrorLogRecord.SERVICE_VERSION_ID, serviceVersionId);
+        }
+        if (StringUtil.isNotEmpty(pagePathId)) {
+            where.eq(BrowserErrorLogRecord.PAGE_PATH_ID, pagePathId);
+        }
+        if (Objects.nonNull(category)) {
+            where.eq(BrowserErrorLogRecord.ERROR_CATEGORY, category.getValue());
+        }
+        where.orderByDesc().limit(limit).offset(from);
 
-                        if (Objects.nonNull(category)) {
-                            query.and(eq(BrowserErrorLogRecord.ERROR_CATEGORY, category.getValue()));
-                        }
-                        query.setOrderBy(
-                            new StreamQuery.OrderBy(AbstractQuery.Sort.DESC));
-                        query.setOffset(from);
-                        query.setLimit(limit);
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(isColdStage, BrowserErrorLogRecord.INDEX_NAME, TAGS,
+                getTimestampRange(duration), where);
 
         BrowserErrorLogs logs = new BrowserErrorLogs();
 
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingDataDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingDataDAO.java
index e840ec466d..92e96275be 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingDataDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingDataDAO.java
@@ -20,7 +20,6 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.ebpf.storage.EBPFProfilingDataRecord;
 import org.apache.skywalking.oap.server.core.storage.profiling.ebpf.IEBPFProfilingDataDAO;
@@ -51,18 +50,12 @@ public class BanyanDBEBPFProfilingDataDAO extends AbstractBanyanDBDAO implements
     public List<EBPFProfilingDataRecord> queryData(List<String> scheduleIdList, long beginTime, long endTime) throws IOException {
         List<EBPFProfilingDataRecord> records = new ArrayList<>();
         for (final String scheduleId : scheduleIdList) {
-            StreamQueryResponse resp = query(false, EBPFProfilingDataRecord.INDEX_NAME,
-                    TAGS,
-                    new QueryBuilder<StreamQuery>() {
-                        @Override
-                        protected void apply(StreamQuery query) {
-                            query.and(eq(EBPFProfilingDataRecord.SCHEDULE_ID, scheduleId));
-                            query.and(gte(EBPFProfilingDataRecord.UPLOAD_TIME, beginTime));
-                            query.and(lte(EBPFProfilingDataRecord.UPLOAD_TIME, endTime));
-                            query.setLimit(profileDataQueryBatchSize);
-                        }
-                    }
-            );
+            final Conditions where = Conditions.create()
+                    .eq(EBPFProfilingDataRecord.SCHEDULE_ID, scheduleId)
+                    .gte(EBPFProfilingDataRecord.UPLOAD_TIME, beginTime)
+                    .lte(EBPFProfilingDataRecord.UPLOAD_TIME, endTime)
+                    .limit(profileDataQueryBatchSize);
+            StreamQueryResponse resp = queryDebuggable(false, EBPFProfilingDataRecord.INDEX_NAME, TAGS, null, where);
 
             records.addAll(resp.getElements().stream().map(this::buildDataRecord).collect(Collectors.toList()));
         }
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingTaskDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingTaskDAO.java
index a585223a76..d6665b36df 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingTaskDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEBPFProfilingTaskDAO.java
@@ -19,15 +19,12 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.ebpf.storage.EBPFProfilingTargetType;
 import org.apache.skywalking.oap.server.core.profiling.ebpf.storage.EBPFProfilingTaskRecord;
 import org.apache.skywalking.oap.server.core.profiling.ebpf.storage.EBPFProfilingTriggerType;
 import org.apache.skywalking.oap.server.core.storage.profiling.ebpf.IEBPFProfilingTaskDAO;
-import org.apache.skywalking.oap.server.library.util.CollectionUtils;
 import org.apache.skywalking.oap.server.library.util.StringUtil;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBConverter;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
@@ -62,18 +59,15 @@ public class BanyanDBEBPFProfilingTaskDAO extends AbstractBanyanDBDAO implements
                                                         long taskStartTime, long latestUpdateTime) throws IOException {
         List<EBPFProfilingTaskRecord> tasks = new ArrayList<>();
         for (final String serviceId : serviceIdList) {
-            StreamQueryResponse resp = query(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        query.and(eq(EBPFProfilingTaskRecord.SERVICE_ID, serviceId));
-                        appendTimeQuery(this, query, taskStartTime, latestUpdateTime);
-                        if (triggerType != null) {
-                            query.and(eq(EBPFProfilingTaskRecord.TRIGGER_TYPE, triggerType.value()));
-                        }
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+            Conditions where = Conditions.create();
+            where.eq(EBPFProfilingTaskRecord.SERVICE_ID, serviceId);
+            appendTimeQuery(where, taskStartTime, latestUpdateTime);
+            if (triggerType != null) {
+                where.eq(EBPFProfilingTaskRecord.TRIGGER_TYPE, triggerType.value());
+            }
+            where.orderByDesc();
+            StreamQueryResponse resp = queryDebuggable(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
+                null, where);
             tasks.addAll(resp.getElements().stream().map(this::buildTask).collect(Collectors.toList()));
         }
 
@@ -85,24 +79,21 @@ public class BanyanDBEBPFProfilingTaskDAO extends AbstractBanyanDBDAO implements
                                                        EBPFProfilingTriggerType triggerType, long taskStartTime, long latestUpdateTime) throws IOException {
         List<EBPFProfilingTaskRecord> tasks = new ArrayList<>();
         for (final EBPFProfilingTargetType targetType : targetTypes) {
-            StreamQueryResponse resp = query(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(EBPFProfilingTaskRecord.SERVICE_ID, serviceId));
-                        }
-                        if (StringUtil.isNotEmpty(serviceInstanceId)) {
-                            query.and(eq(EBPFProfilingTaskRecord.INSTANCE_ID, serviceInstanceId));
-                        }
-                        if (CollectionUtils.isNotEmpty(targetTypes)) {
-                            query.and(eq(EBPFProfilingTaskRecord.TRIGGER_TYPE, triggerType.value()));
-                        }
-                        query.and(eq(EBPFProfilingTaskRecord.TARGET_TYPE, targetType.value()));
-                        appendTimeQuery(this, query, taskStartTime, latestUpdateTime);
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+            Conditions where = Conditions.create();
+            if (StringUtil.isNotEmpty(serviceId)) {
+                where.eq(EBPFProfilingTaskRecord.SERVICE_ID, serviceId);
+            }
+            if (StringUtil.isNotEmpty(serviceInstanceId)) {
+                where.eq(EBPFProfilingTaskRecord.INSTANCE_ID, serviceInstanceId);
+            }
+            if (triggerType != null) {
+                where.eq(EBPFProfilingTaskRecord.TRIGGER_TYPE, triggerType.value());
+            }
+            where.eq(EBPFProfilingTaskRecord.TARGET_TYPE, targetType.value());
+            appendTimeQuery(where, taskStartTime, latestUpdateTime);
+            where.orderByDesc();
+            StreamQueryResponse resp = queryDebuggable(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
+                null, where);
             tasks.addAll(resp.getElements().stream().map(this::buildTask).collect(Collectors.toList()));
         }
 
@@ -111,22 +102,18 @@ public class BanyanDBEBPFProfilingTaskDAO extends AbstractBanyanDBDAO implements
 
     @Override
     public List<EBPFProfilingTaskRecord> getTaskRecord(String id) throws IOException {
-        StreamQueryResponse resp = query(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
-            new QueryBuilder<StreamQuery>() {
-                @Override
-                protected void apply(StreamQuery query) {
-                    query.and(eq(EBPFProfilingTaskRecord.LOGICAL_ID, id));
-                }
-            });
+        StreamQueryResponse resp = queryDebuggable(false, EBPFProfilingTaskRecord.INDEX_NAME, TAGS,
+            null,
+            Conditions.create().eq(EBPFProfilingTaskRecord.LOGICAL_ID, id));
         return resp.getElements().stream().map(this::buildTask).collect(Collectors.toList());
     }
 
-    private void appendTimeQuery(QueryBuilder<StreamQuery> builder, StreamQuery query, long taskStartTime, long latestUpdateTime) {
+    private void appendTimeQuery(Conditions where, long taskStartTime, long latestUpdateTime) {
         if (taskStartTime > 0) {
-            query.and(builder.gte(EBPFProfilingTaskRecord.START_TIME, taskStartTime));
+            where.gte(EBPFProfilingTaskRecord.START_TIME, taskStartTime);
         }
         if (latestUpdateTime > 0) {
-            query.and(builder.gt(EBPFProfilingTaskRecord.LAST_UPDATE_TIME, latestUpdateTime));
+            where.gt(EBPFProfilingTaskRecord.LAST_UPDATE_TIME, latestUpdateTime);
         }
     }
 
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEventQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEventQueryDAO.java
index 14330aee90..fb3494315a 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEventQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBEventQueryDAO.java
@@ -18,17 +18,14 @@
 
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractCriteria;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.Element;
-import org.apache.skywalking.library.banyandb.v1.client.PairQueryCondition;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.Layer;
 import org.apache.skywalking.oap.server.core.query.PaginationUtils;
@@ -56,26 +53,62 @@ public class BanyanDBEventQueryDAO extends AbstractBanyanDBDAO implements IEvent
 
     @Override
     public Events queryEvents(EventQueryCondition condition) throws Exception {
-        final Duration time = condition.getTime();
-        boolean isColdStage = time != null && time.isColdStage();
-        StreamQueryResponse resp = query(isColdStage, Event.INDEX_NAME, TAGS, getTimestampRange(time), buildQuery(Collections.singletonList(condition)));
-        Events events = new Events();
-        if (resp.size() == 0) {
-            return events;
-        }
-        for (final Element e : resp.getElements()) {
-            events.getEvents().add(buildEventView(e));
-        }
-        return events;
+        return doQuery(Collections.singletonList(condition));
     }
 
     @Override
     public Events queryEvents(List<EventQueryCondition> conditionList) throws Exception {
+        return doQuery(conditionList);
+    }
+
+    private Events doQuery(final List<EventQueryCondition> conditionList) throws IOException {
         // Duration should be same for all conditions
-        final Duration time = conditionList.get(0).getTime();
-        boolean isColdStage = time != null && time.isColdStage();
-        StreamQueryResponse resp = query(isColdStage, Event.INDEX_NAME, TAGS, getTimestampRange(time), buildQuery(conditionList));
-        Events events = new Events();
+        final EventQueryCondition first = conditionList.get(0);
+        final Duration time = first.getTime();
+        final boolean isColdStage = time != null && time.isColdStage();
+        final Order queryOrder = isNull(first.getOrder()) ? Order.DES : first.getOrder();
+        final PaginationUtils.Page page = PaginationUtils.INSTANCE.exchange(first.getPaging());
+
+        final List<Conditions> groups = new ArrayList<>(conditionList.size());
+        for (final EventQueryCondition condition : conditionList) {
+            final Conditions group = Conditions.group();
+            if (!isNullOrEmpty(condition.getUuid())) {
+                group.eq(Event.UUID, condition.getUuid());
+            }
+            final Source source = condition.getSource();
+            if (source != null) {
+                if (!isNullOrEmpty(source.getService())) {
+                    group.eq(Event.SERVICE, source.getService());
+                }
+                if (!isNullOrEmpty(source.getServiceInstance())) {
+                    group.eq(Event.SERVICE_INSTANCE, source.getServiceInstance());
+                }
+                if (!isNullOrEmpty(source.getEndpoint())) {
+                    group.eq(Event.ENDPOINT, source.getEndpoint());
+                }
+            }
+            if (!isNullOrEmpty(condition.getName())) {
+                group.eq(Event.NAME, condition.getName());
+            }
+            if (condition.getType() != null) {
+                group.eq(Event.TYPE, condition.getType().name());
+            }
+            if (!isNullOrEmpty(condition.getLayer())) {
+                group.eq(Event.LAYER, Layer.valueOf(condition.getLayer()).value());
+            }
+            groups.add(group);
+        }
+        final Conditions where = Conditions.create().or(groups);
+        if (queryOrder == Order.ASC) {
+            where.orderByAsc();
+        } else {
+            where.orderByDesc();
+        }
+        where.limit(page.getLimit()).offset(page.getFrom());
+
+        final StreamQueryResponse resp = queryDebuggable(isColdStage, Event.INDEX_NAME, TAGS,
+                getTimestampRange(time), where);
+        final Events events = new Events();
         if (resp.size() == 0) {
             return events;
         }
@@ -85,64 +118,6 @@ public class BanyanDBEventQueryDAO extends AbstractBanyanDBDAO implements IEvent
         return events;
     }
 
-    public QueryBuilder<StreamQuery> buildQuery(final List<EventQueryCondition> conditionList) {
-        EventQueryCondition condition = conditionList.get(0);
-        final Order queryOrder = isNull(condition.getOrder()) ? Order.DES : condition.getOrder();
-        final PaginationUtils.Page page = PaginationUtils.INSTANCE.exchange(condition.getPaging());
-
-        return new QueryBuilder<StreamQuery>() {
-            @Override
-            protected void apply(StreamQuery query) {
-                List<AbstractCriteria> eventsQueryConditions = new ArrayList<>(conditionList.size());
-                query.setLimit(page.getLimit());
-                query.setOffset(page.getFrom());
-                if (queryOrder == Order.ASC) {
-                    query.setOrderBy(
-                        new AbstractQuery.OrderBy(AbstractQuery.Sort.ASC));
-                } else {
-                    query.setOrderBy(
-                        new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                }
-                for (final EventQueryCondition condition : conditionList) {
-                    List<PairQueryCondition<?>> queryConditions = new ArrayList<>();
-                    if (!isNullOrEmpty(condition.getUuid())) {
-                        queryConditions.add(eq(Event.UUID, condition.getUuid()));
-                    }
-                    final Source source = condition.getSource();
-                    if (source != null) {
-                        if (!isNullOrEmpty(source.getService())) {
-                            queryConditions.add(eq(Event.SERVICE, source.getService()));
-                        }
-                        if (!isNullOrEmpty(source.getServiceInstance())) {
-                            queryConditions.add(eq(Event.SERVICE_INSTANCE, source.getServiceInstance()));
-                        }
-                        if (!isNullOrEmpty(source.getEndpoint())) {
-                            queryConditions.add(eq(Event.ENDPOINT, source.getEndpoint()));
-                        }
-                    }
-
-                    if (!isNullOrEmpty(condition.getName())) {
-                        queryConditions.add(eq(Event.NAME, condition.getName()));
-                    }
-
-                    if (condition.getType() != null) {
-                        queryConditions.add(eq(Event.TYPE, condition.getType().name()));
-                    }
-
-                    if (!isNullOrEmpty(condition.getLayer())) {
-                        queryConditions.add(eq(Event.LAYER, Layer.valueOf(condition.getLayer()).value()));
-                    }
-                    eventsQueryConditions.add(and(queryConditions));
-                }
-                if (eventsQueryConditions.size() == 1) {
-                    query.criteria(eventsQueryConditions.get(0));
-                } else if (eventsQueryConditions.size() > 1) {
-                    query.criteria(or(eventsQueryConditions));
-                }
-            }
-        };
-    }
-
     protected org.apache.skywalking.oap.server.core.query.type.event.Event buildEventView(
             final Element e) {
         final org.apache.skywalking.oap.server.core.query.type.event.Event event =
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBJFRDataQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBJFRDataQueryDAO.java
index c8f35dac78..0a38fc3ba8 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBJFRDataQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBJFRDataQueryDAO.java
@@ -20,7 +20,6 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.asyncprofiler.storage.JFRProfilingDataRecord;
 import org.apache.skywalking.oap.server.core.storage.profiling.asyncprofiler.IJFRDataQueryDAO;
@@ -53,17 +52,14 @@ public class BanyanDBJFRDataQueryDAO extends AbstractBanyanDBDAO implements IJFR
         if (StringUtil.isBlank(taskId) || StringUtil.isBlank(eventType)) {
             return new ArrayList<>();
         }
-        StreamQueryResponse resp = query(false, JFRProfilingDataRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        query.and(eq(JFRProfilingDataRecord.TASK_ID, taskId));
-                        query.and(eq(JFRProfilingDataRecord.EVENT_TYPE, eventType));
-                        if (CollectionUtils.isNotEmpty(instanceIds)) {
-                            query.and(in(JFRProfilingDataRecord.INSTANCE_ID, instanceIds));
-                        }
-                    }
-                });
+        Conditions where = Conditions.create()
+                .eq(JFRProfilingDataRecord.TASK_ID, taskId)
+                .eq(JFRProfilingDataRecord.EVENT_TYPE, eventType);
+        if (CollectionUtils.isNotEmpty(instanceIds)) {
+            where.in(JFRProfilingDataRecord.INSTANCE_ID, instanceIds);
+        }
+        StreamQueryResponse resp = queryDebuggable(false, JFRProfilingDataRecord.INDEX_NAME, TAGS,
+                null, where);
         List<JFRProfilingDataRecord> records = new ArrayList<>(resp.size());
         for (final RowEntity entity : resp.getElements()) {
             records.add(buildProfilingDataRecord(entity));
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBLogQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBLogQueryDAO.java
index 7acc097f80..559c860f6f 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBLogQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBLogQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.IDManager;
 import org.apache.skywalking.oap.server.core.analysis.manual.log.AbstractLogRecord;
@@ -69,61 +67,53 @@ public class BanyanDBLogQueryDAO extends AbstractBanyanDBDAO implements ILogQuer
                           Duration duration, List<Tag> tags, List<String> keywordsOfContent,
                           List<String> excludingKeywordsOfContent) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
-        final QueryBuilder<StreamQuery> query = new QueryBuilder<StreamQuery>() {
-            @Override
-            public void apply(StreamQuery query) {
-                if (StringUtil.isNotEmpty(serviceId)) {
-                    query.and(eq(AbstractLogRecord.SERVICE_ID, serviceId));
-                }
-
-                if (StringUtil.isNotEmpty(serviceInstanceId)) {
-                    if (StringUtil.isEmpty(serviceId)) {
-                        IDManager.ServiceInstanceID.InstanceIDDefinition instanceIDDefinition = IDManager.ServiceInstanceID.analysisId(
-                            serviceInstanceId);
-                        query.and(eq(AbstractLogRecord.SERVICE_ID, instanceIDDefinition.getServiceId()));
-                    }
-                    query.and(eq(AbstractLogRecord.SERVICE_INSTANCE_ID, serviceInstanceId));
-                }
-                if (StringUtil.isNotEmpty(endpointId)) {
-                    if (StringUtil.isEmpty(serviceId)) {
-                        IDManager.EndpointID.EndpointIDDefinition endpointIDDefinition = IDManager.EndpointID.analysisId(
-                            endpointId);
-                        query.and(eq(AbstractLogRecord.SERVICE_ID, endpointIDDefinition.getServiceId()));
-                    }
-                    query.and(eq(AbstractLogRecord.ENDPOINT_ID, endpointId));
-                }
-                if (Objects.nonNull(relatedTrace)) {
-                    if (StringUtil.isNotEmpty(relatedTrace.getTraceId())) {
-                        query.and(eq(AbstractLogRecord.TRACE_ID, relatedTrace.getTraceId()));
-                    }
-                    if (StringUtil.isNotEmpty(relatedTrace.getSegmentId())) {
-                        query.and(eq(AbstractLogRecord.TRACE_SEGMENT_ID, relatedTrace.getSegmentId()));
-                    }
-                    if (Objects.nonNull(relatedTrace.getSpanId())) {
-                        query.and(eq(AbstractLogRecord.SPAN_ID, (long) relatedTrace.getSpanId()));
-                    }
-                }
-
-                if (CollectionUtils.isNotEmpty(tags)) {
-                    List<String> tagsConditions = new ArrayList<>(tags.size());
-                    for (final Tag tag : tags) {
-                        tagsConditions.add(tag.toString());
-                    }
-                    query.and(having(LogRecord.TAGS, tagsConditions));
-                }
-                if (queryOrder == Order.ASC) {
-                    query.setOrderBy(
-                        new AbstractQuery.OrderBy(AbstractQuery.Sort.ASC));
-                } else {
-                    query.setOrderBy(
-                        new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                }
-                query.setLimit(limit);
-                query.setOffset(from);
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(AbstractLogRecord.SERVICE_ID, serviceId);
+        }
+        if (StringUtil.isNotEmpty(serviceInstanceId)) {
+            if (StringUtil.isEmpty(serviceId)) {
+                IDManager.ServiceInstanceID.InstanceIDDefinition instanceIDDefinition = IDManager.ServiceInstanceID.analysisId(
+                    serviceInstanceId);
+                where.eq(AbstractLogRecord.SERVICE_ID, instanceIDDefinition.getServiceId());
+            }
+            where.eq(AbstractLogRecord.SERVICE_INSTANCE_ID, serviceInstanceId);
+        }
+        if (StringUtil.isNotEmpty(endpointId)) {
+            if (StringUtil.isEmpty(serviceId)) {
+                IDManager.EndpointID.EndpointIDDefinition endpointIDDefinition = IDManager.EndpointID.analysisId(
+                    endpointId);
+                where.eq(AbstractLogRecord.SERVICE_ID, endpointIDDefinition.getServiceId());
+            }
+            where.eq(AbstractLogRecord.ENDPOINT_ID, endpointId);
+        }
+        if (Objects.nonNull(relatedTrace)) {
+            if (StringUtil.isNotEmpty(relatedTrace.getTraceId())) {
+                where.eq(AbstractLogRecord.TRACE_ID, relatedTrace.getTraceId());
             }
-        };
+            if (StringUtil.isNotEmpty(relatedTrace.getSegmentId())) {
+                where.eq(AbstractLogRecord.TRACE_SEGMENT_ID, relatedTrace.getSegmentId());
+            }
+            if (Objects.nonNull(relatedTrace.getSpanId())) {
+                where.eq(AbstractLogRecord.SPAN_ID, (long) relatedTrace.getSpanId());
+            }
+        }
+        if (CollectionUtils.isNotEmpty(tags)) {
+            List<String> tagsConditions = new ArrayList<>(tags.size());
+            for (final Tag tag : tags) {
+                tagsConditions.add(tag.toString());
+            }
+            where.having(LogRecord.TAGS, tagsConditions);
+        }
+        if (queryOrder == Order.ASC) {
+            where.orderByAsc();
+        } else {
+            where.orderByDesc();
+        }
+        where.limit(limit).offset(from);
 
-        StreamQueryResponse resp = queryDebuggable(isColdStage, LogRecord.INDEX_NAME, TAGS, getTimestampRange(duration), query);
+        StreamQueryResponse resp = queryDebuggable(isColdStage, LogRecord.INDEX_NAME, TAGS,
+                getTimestampRange(duration), where);
 
         Logs logs = new Logs();
 
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofDataQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofDataQueryDAO.java
index 817199400c..a0344e6860 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofDataQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofDataQueryDAO.java
@@ -24,7 +24,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.pprof.storage.PprofProfilingDataRecord;
 import org.apache.skywalking.oap.server.core.storage.profiling.pprof.IPprofDataQueryDAO;
@@ -51,18 +50,12 @@ public class BanyanDBPprofDataQueryDAO extends AbstractBanyanDBDAO implements IP
         if (StringUtil.isBlank(taskId)) {
             return new ArrayList<>();
         }
-        StreamQueryResponse resp = query(
-            false, PprofProfilingDataRecord.INDEX_NAME, TAGS,
-            new QueryBuilder<StreamQuery>() {
-                @Override
-                protected void apply(StreamQuery query) {
-                    query.and(eq(PprofProfilingDataRecord.TASK_ID, taskId));
-                    if (CollectionUtils.isNotEmpty(instanceIds)) {
-                        query.and(in(PprofProfilingDataRecord.INSTANCE_ID, instanceIds));
-                    }
-                }
-            }
-        );
+        Conditions where = Conditions.create().eq(PprofProfilingDataRecord.TASK_ID, taskId);
+        if (CollectionUtils.isNotEmpty(instanceIds)) {
+            where.in(PprofProfilingDataRecord.INSTANCE_ID, instanceIds);
+        }
+        StreamQueryResponse resp = queryDebuggable(false, PprofProfilingDataRecord.INDEX_NAME, TAGS,
+            null, where);
         List<PprofProfilingDataRecord> records = new ArrayList<>(resp.size());
         for (final RowEntity entity : resp.getElements()) {
             records.add(buildProfilingDataRecord(entity));
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskLogQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskLogQueryDAO.java
index 5f4054da1c..b1365f4015 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskLogQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskLogQueryDAO.java
@@ -25,7 +25,6 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 import org.apache.skywalking.library.banyandb.v1.client.Element;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.pprof.storage.PprofTaskLogRecord;
 import org.apache.skywalking.oap.server.core.query.PprofTaskLog;
@@ -58,16 +57,12 @@ public class BanyanDBPprofTaskLogQueryDAO extends AbstractBanyanDBDAO implements
         if (StringUtil.isBlank(taskId)) {
             return Collections.emptyList();
         }
-        StreamQueryResponse resp = query(
-            false, PprofTaskLogRecord.INDEX_NAME, TAGS,
-            new QueryBuilder<StreamQuery>() {
-                @Override
-                public void apply(StreamQuery query) {
-                    query.and(eq(PprofTaskLogRecord.TASK_ID, taskId));
-                    query.setLimit(BanyanDBPprofTaskLogQueryDAO.this.queryMaxSize);
-                }
-            }
-        );
+        final Conditions where = Conditions.create()
+            .eq(PprofTaskLogRecord.TASK_ID, taskId)
+            .limit(queryMaxSize);
+        StreamQueryResponse resp = queryDebuggable(false, PprofTaskLogRecord.INDEX_NAME, TAGS,
+            null,
+            where);
 
         final LinkedList<PprofTaskLog> tasks = new LinkedList<>();
         for (final Element element : resp.getElements()) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskQueryDAO.java
index 97274742b6..e3df457b2d 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBPprofTaskQueryDAO.java
@@ -27,9 +27,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.TimeBucket;
@@ -70,22 +68,13 @@ public class BanyanDBPprofTaskQueryDAO extends AbstractBanyanDBDAO implements IP
         if (endTimeBucket != null) {
             endTS = TimeBucket.getTimestamp(endTimeBucket);
         }
-        StreamQueryResponse resp = query(false, PprofTaskRecord.INDEX_NAME, TAGS, new TimestampRange(startTS, endTS),
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(PprofTaskRecord.SERVICE_ID, serviceId));
-                        }
-
-                        if (limit != null) {
-                            query.setLimit(limit);
-                        } else {
-                            query.setLimit(BanyanDBPprofTaskQueryDAO.this.queryMaxSize);
-                        }
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(PprofTaskRecord.SERVICE_ID, serviceId);
+        }
+        where.orderByDesc().limit(limit != null ? limit : queryMaxSize);
+        StreamQueryResponse resp = queryDebuggable(false, PprofTaskRecord.INDEX_NAME, TAGS,
+                new TimestampRange(startTS, endTS), where);
 
         List<PprofTask> tasks = new ArrayList<>(resp.size());
         for (final RowEntity entity : resp.getElements()) {
@@ -96,16 +85,13 @@ public class BanyanDBPprofTaskQueryDAO extends AbstractBanyanDBDAO implements IP
 
     @Override
     public PprofTask getById(String id) throws IOException {
-        StreamQueryResponse resp = query(false, PprofTaskRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(id)) {
-                            query.and(eq(PprofTaskRecord.TASK_ID, id));
-                        }
-                        query.setLimit(1);
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(id)) {
+            where.eq(PprofTaskRecord.TASK_ID, id);
+        }
+        where.limit(1L);
+        StreamQueryResponse resp = queryDebuggable(false, PprofTaskRecord.INDEX_NAME, TAGS,
+                null, where);
 
         if (resp.size() == 0) {
             return null;
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskLogQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskLogQueryDAO.java
index c8287d6218..d2c764b9d8 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskLogQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskLogQueryDAO.java
@@ -20,7 +20,6 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
 import org.apache.skywalking.library.banyandb.v1.client.Element;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.profiling.trace.ProfileTaskLogRecord;
 import org.apache.skywalking.oap.server.core.query.type.ProfileTaskLog;
@@ -50,13 +49,9 @@ public class BanyanDBProfileTaskLogQueryDAO extends AbstractBanyanDBDAO implemen
 
     @Override
     public List<ProfileTaskLog> getTaskLogList() throws IOException {
-        StreamQueryResponse resp = query(false, ProfileTaskLogRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.setLimit(BanyanDBProfileTaskLogQueryDAO.this.queryMaxSize);
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(false, ProfileTaskLogRecord.INDEX_NAME, TAGS,
+                null,
+                Conditions.create().limit(queryMaxSize));
 
         final LinkedList<ProfileTaskLog> tasks = new LinkedList<>();
         for (final Element element : resp.getElements()) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskQueryDAO.java
index 2c119ab9c6..3178c33db5 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileTaskQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.TimeBucket;
@@ -67,25 +65,16 @@ public class BanyanDBProfileTaskQueryDAO extends AbstractBanyanDBDAO implements
         if (endTimeBucket != null) {
             endTS = TimeBucket.getTimestamp(endTimeBucket);
         }
-        StreamQueryResponse resp = query(false, ProfileTaskRecord.INDEX_NAME, TAGS, new TimestampRange(startTS, endTS),
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(serviceId)) {
-                            query.and(eq(ProfileTaskRecord.SERVICE_ID, serviceId));
-                        }
-                        if (StringUtil.isNotEmpty(endpointName)) {
-                            query.and(eq(ProfileTaskRecord.ENDPOINT_NAME, endpointName));
-                        }
-
-                        if (limit != null) {
-                            query.setLimit(limit);
-                        } else {
-                            query.setLimit(BanyanDBProfileTaskQueryDAO.this.queryMaxSize);
-                        }
-                        query.setOrderBy(new AbstractQuery.OrderBy(AbstractQuery.Sort.DESC));
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceId)) {
+            where.eq(ProfileTaskRecord.SERVICE_ID, serviceId);
+        }
+        if (StringUtil.isNotEmpty(endpointName)) {
+            where.eq(ProfileTaskRecord.ENDPOINT_NAME, endpointName);
+        }
+        where.orderByDesc().limit(limit != null ? limit : queryMaxSize);
+        StreamQueryResponse resp = queryDebuggable(false, ProfileTaskRecord.INDEX_NAME, TAGS,
+                new TimestampRange(startTS, endTS), where);
 
         if (resp.size() == 0) {
             return Collections.emptyList();
@@ -101,16 +90,13 @@ public class BanyanDBProfileTaskQueryDAO extends AbstractBanyanDBDAO implements
 
     @Override
     public ProfileTask getById(String id) throws IOException {
-        StreamQueryResponse resp = query(false, ProfileTaskRecord.INDEX_NAME, TAGS,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        if (StringUtil.isNotEmpty(id)) {
-                            query.and(eq(ProfileTaskRecord.TASK_ID, id));
-                        }
-                        query.setLimit(1);
-                    }
-                });
+        Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(id)) {
+            where.eq(ProfileTaskRecord.TASK_ID, id);
+        }
+        where.limit(1L);
+        StreamQueryResponse resp = queryDebuggable(false, ProfileTaskRecord.INDEX_NAME, TAGS,
+                null, where);
 
         if (resp.size() == 0) {
             return null;
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileThreadSnapshotQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileThreadSnapshotQueryDAO.java
index 9cb6ed049e..bfffa8c19d 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileThreadSnapshotQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBProfileThreadSnapshotQueryDAO.java
@@ -19,9 +19,7 @@
 package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
 import org.apache.skywalking.oap.server.core.analysis.manual.segment.SegmentRecord;
@@ -78,17 +76,13 @@ public class BanyanDBProfileThreadSnapshotQueryDAO extends AbstractBanyanDBDAO i
 
     @Override
     public List<ProfileThreadSnapshotRecord> queryRecords(String taskId) throws IOException {
-        StreamQueryResponse resp = query(false, ProfileThreadSnapshotRecord.INDEX_NAME,
-                TAGS_BASIC,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.and(eq(ProfileThreadSnapshotRecord.TASK_ID, taskId))
-                                .and(eq(ProfileThreadSnapshotRecord.SEQUENCE, 0L));
-                        query.setOrderBy(new StreamQuery.OrderBy(AbstractQuery.Sort.DESC));
-                        query.setLimit(querySegmentMaxSize);
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(false, ProfileThreadSnapshotRecord.INDEX_NAME, TAGS_BASIC,
+                null,
+                Conditions.create()
+                    .eq(ProfileThreadSnapshotRecord.TASK_ID, taskId)
+                    .eq(ProfileThreadSnapshotRecord.SEQUENCE, 0L)
+                    .orderByDesc()
+                    .limit(querySegmentMaxSize));
 
         if (resp.getElements().isEmpty()) {
             return Collections.emptyList();
@@ -115,16 +109,12 @@ public class BanyanDBProfileThreadSnapshotQueryDAO extends AbstractBanyanDBDAO i
 
     @Override
     public List<ProfileThreadSnapshotRecord> queryRecords(String segmentId, int minSequence, int maxSequence) throws IOException {
-        StreamQueryResponse resp = query(false, ProfileThreadSnapshotRecord.INDEX_NAME,
-                TAGS_ALL,
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.and(eq(ProfileThreadSnapshotRecord.SEGMENT_ID, segmentId))
-                                .and(lte(ProfileThreadSnapshotRecord.SEQUENCE, maxSequence))
-                                .and(gte(ProfileThreadSnapshotRecord.SEQUENCE, minSequence));
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(false, ProfileThreadSnapshotRecord.INDEX_NAME, TAGS_ALL,
+                null,
+                Conditions.create()
+                    .eq(ProfileThreadSnapshotRecord.SEGMENT_ID, segmentId)
+                    .lte(ProfileThreadSnapshotRecord.SEQUENCE, maxSequence)
+                    .gte(ProfileThreadSnapshotRecord.SEQUENCE, minSequence));
 
         List<ProfileThreadSnapshotRecord> result = new ArrayList<>(maxSequence - minSequence);
         for (final RowEntity rowEntity : resp.getElements()) {
@@ -139,14 +129,9 @@ public class BanyanDBProfileThreadSnapshotQueryDAO extends AbstractBanyanDBDAO i
         // Clamp the time range to safe bounds for BanyanDB
         long safeStart = Math.max(start, LOWER_BOUND_TIME);
         long safeEnd = Math.min(end, UPPER_BOUND_TIME);
-        StreamQueryResponse resp = query(false, ProfileThreadSnapshotRecord.INDEX_NAME,
-                TAGS_ALL, new TimestampRange(safeStart, safeEnd),
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    public void apply(StreamQuery query) {
-                        query.and(eq(ProfileThreadSnapshotRecord.SEGMENT_ID, segmentId));
-                    }
-                });
+        StreamQueryResponse resp = queryDebuggable(false, ProfileThreadSnapshotRecord.INDEX_NAME, TAGS_ALL,
+                new TimestampRange(safeStart, safeEnd),
+                Conditions.create().eq(ProfileThreadSnapshotRecord.SEGMENT_ID, segmentId));
 
         List<ProfileThreadSnapshotRecord> records = new ArrayList<>();
         for (final RowEntity rowEntity : resp.getElements()) {
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBSpanAttachedEventQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBSpanAttachedEventQueryDAO.java
index 43c8a64600..7d0b95422c 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBSpanAttachedEventQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/BanyanDBSpanAttachedEventQueryDAO.java
@@ -20,9 +20,7 @@ package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
 
 import com.google.common.collect.ImmutableSet;
 import javax.annotation.Nullable;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.RowEntity;
-import org.apache.skywalking.library.banyandb.v1.client.StreamQuery;
 import org.apache.skywalking.library.banyandb.v1.client.StreamQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.manual.spanattach.SWSpanAttachedEventRecord;
 import org.apache.skywalking.oap.server.core.analysis.manual.spanattach.SpanAttachedEventRecord;
@@ -73,14 +71,10 @@ public class BanyanDBSpanAttachedEventQueryDAO extends AbstractBanyanDBDAO imple
         final boolean isColdStage = duration != null && duration.isColdStage();
         final StreamQueryResponse resp = queryDebuggable(
                 isColdStage, SWSpanAttachedEventRecord.INDEX_NAME, ZK_TAGS, getTimestampRange(duration),
-                new QueryBuilder<StreamQuery>() {
-                    @Override
-                    protected void apply(StreamQuery query) {
-                        query.and(in(SWSpanAttachedEventRecord.RELATED_TRACE_ID, traceIds));
-                        query.setOrderBy(new StreamQuery.OrderBy(AbstractQuery.Sort.ASC));
-                        query.setLimit(batchSize);
-                    }
-                });
+                Conditions.create()
+                        .in(SWSpanAttachedEventRecord.RELATED_TRACE_ID, traceIds)
+                        .orderByAsc()
+                        .limit(batchSize));
 
         return resp.getElements().stream().map(this::buildSWRecord).collect(Collectors.toList());
     }
@@ -90,14 +84,10 @@ public class BanyanDBSpanAttachedEventQueryDAO extends AbstractBanyanDBDAO imple
         final boolean isColdStage = duration != null && duration.isColdStage();
         final StreamQueryResponse resp = queryDebuggable(
             isColdStage, SpanAttachedEventRecord.INDEX_NAME, ZK_TAGS, getTimestampRange(duration),
-            new QueryBuilder<StreamQuery>() {
-            @Override
-            protected void apply(StreamQuery query) {
-                query.and(in(SpanAttachedEventRecord.RELATED_TRACE_ID, traceIds));
-                query.setOrderBy(new StreamQuery.OrderBy(AbstractQuery.Sort.ASC));
-                query.setLimit(batchSize);
-            }
-        });
+            Conditions.create()
+                    .in(SpanAttachedEventRecord.RELATED_TRACE_ID, traceIds)
+                    .orderByAsc()
+                    .limit(batchSize));
 
         return resp.getElements().stream().map(this::buildZKRecord).collect(Collectors.toList());
     }
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/Conditions.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/Conditions.java
new file mode 100644
index 0000000000..bee77a96df
--- /dev/null
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/Conditions.java
@@ -0,0 +1,218 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ *     http://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.
+ *
+ */
+
+package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
+import org.apache.skywalking.library.banyandb.v1.client.Value;
+import org.apache.skywalking.library.banyandb.v1.client.metadata.Serializable;
+
+/**
+ * Fluent builder for the body of a BydbQL query — the {@code WHERE ... ORDER BY ... LIMIT ...}
+ * fragment appended after the {@code SELECT ... FROM ...} projection. Each condition method
+ * appends both the QL text (with the correct {@code WHERE}/{@code AND} connector and {@code ?}
+ * placeholder) and the bound parameter, so callers write one line per condition instead of the
+ * two-line "append fragment + params.add" idiom. Mirrors the equality/match/in vocabulary of the
+ * previous typed query-builder API. Not thread-safe; build one instance per query.
+ */
+public final class Conditions {
+    private final StringBuilder ql = new StringBuilder();
+    private final List<Serializable<BanyandbModel.TagValue>> params = new ArrayList<>();
+    private final boolean groupMode;
+
+    private Conditions(boolean groupMode) {
+        this.groupMode = groupMode;
+    }
+
+    public static Conditions create() {
+        return new Conditions(false);
+    }
+
+    /**
+     * A condition group for use inside {@link #or(List)}: its conditions are joined by {@code AND} with no
+     * leading {@code WHERE}, so groups can be OR'd together into {@code WHERE (a AND b) OR (c AND d)}.
+     *
+     * @return a new group builder
+     */
+    public static Conditions group() {
+        return new Conditions(true);
+    }
+
+    public Conditions eq(String column, long value) {
+        return condition(column, " = ?", Value.longTagValue(value));
+    }
+
+    public Conditions eq(String column, String value) {
+        return condition(column, " = ?", Value.stringTagValue(value));
+    }
+
+    public Conditions ne(String column, String value) {
+        return condition(column, " != ?", Value.stringTagValue(value));
+    }
+
+    public Conditions ne(String column, long value) {
+        return condition(column, " != ?", Value.longTagValue(value));
+    }
+
+    public Conditions gte(String column, long value) {
+        return condition(column, " >= ?", Value.longTagValue(value));
+    }
+
+    public Conditions gt(String column, long value) {
+        return condition(column, " > ?", Value.longTagValue(value));
+    }
+
+    public Conditions lte(String column, long value) {
+        return condition(column, " <= ?", Value.longTagValue(value));
+    }
+
+    public Conditions in(String column, List<String> values) {
+        return condition(column, " IN (?)", Value.stringArrayTagValue(values));
+    }
+
+    public Conditions match(String column, String value) {
+        return condition(column, " MATCH(?)", Value.stringTagValue(value));
+    }
+
+    /**
+     * MATCH with an explicit analyzer and logical operator, e.g. {@code name MATCH(?, 'url', 'AND')}.
+     * The analyzer and operator are QL literals; only the match text is a bound {@code ?} parameter.
+     *
+     * @param column   the column to match
+     * @param analyzer the analyzer name (e.g. {@code url}), emitted as a single-quoted literal
+     * @param logicalOp the logical operator (e.g. {@code AND}), emitted as a single-quoted literal
+     * @param value    the match text, bound to the {@code ?} placeholder
+     * @return this builder
+     */
+    public Conditions match(String column, String analyzer, String logicalOp, String value) {
+        return condition(column, " MATCH(?, '" + analyzer + "', '" + logicalOp + "')", Value.stringTagValue(value));
+    }
+
+    public Conditions having(String column, List<String> values) {
+        return condition(column, " HAVING (?)", Value.stringArrayTagValue(values));
+    }
+
+    public Conditions orderByDesc() {
+        ql.append(" ORDER BY DESC");
+        return this;
+    }
+
+    public Conditions orderByAsc() {
+        ql.append(" ORDER BY ASC");
+        return this;
+    }
+
+    public Conditions orderByDesc(String column) {
+        ql.append(" ORDER BY ").append(column).append(" DESC");
+        return this;
+    }
+
+    /**
+     * {@code ORDER BY <column> <direction>} where the direction (e.g. {@code ASC}/{@code DESC}) is a
+     * QL literal resolved by the caller — for queries whose sort direction is dynamic.
+     *
+     * @param column    the column to order by
+     * @param direction the sort direction literal ({@code ASC} or {@code DESC})
+     * @return this builder
+     */
+    public Conditions orderBy(String column, String direction) {
+        ql.append(" ORDER BY ").append(column).append(" ").append(direction);
+        return this;
+    }
+
+    /**
+     * {@code GROUP BY col1, col2, ...} — appended after the WHERE clause. No parameters.
+     *
+     * @param columns the group-by columns, in order
+     * @return this builder
+     */
+    public Conditions groupBy(String... columns) {
+        ql.append(" GROUP BY ").append(String.join(", ", columns));
+        return this;
+    }
+
+    public Conditions limit(long value) {
+        ql.append(" LIMIT ?");
+        params.add(Value.longTagValue(value));
+        return this;
+    }
+
+    public Conditions offset(long value) {
+        ql.append(" OFFSET ?");
+        params.add(Value.longTagValue(value));
+        return this;
+    }
+
+    /**
+     * @return the assembled QL body ({@code WHERE ... ORDER BY ... LIMIT ...}), to be appended
+     * after the {@code SELECT ... FROM ...} projection.
+     */
+    public String buildQl() {
+        return ql.toString();
+    }
+
+    /**
+     * @return the bound parameters, in the order their {@code ?} placeholders appear in {@link #buildQl()}.
+     */
+    public List<Serializable<BanyandbModel.TagValue>> params() {
+        return params;
+    }
+
+    /**
+     * Combine condition {@link #group() groups} with OR: {@code WHERE (g1) OR (g2) OR ...}. A single non-empty
+     * group is emitted without parentheses ({@code WHERE g1}); empty groups are skipped; if every group is empty
+     * no clause is emitted. Params are appended in group order.
+     *
+     * @param groups the condition groups, each built via {@link #group()}
+     * @return this builder
+     */
+    public Conditions or(List<Conditions> groups) {
+        final List<Conditions> nonEmpty = new ArrayList<>();
+        for (final Conditions g : groups) {
+            if (g.ql.length() > 0) {
+                nonEmpty.add(g);
+            }
+        }
+        if (nonEmpty.isEmpty()) {
+            return this;
+        }
+        ql.append(ql.length() == 0 ? " WHERE " : " AND ");
+        if (nonEmpty.size() == 1) {
+            ql.append(nonEmpty.get(0).ql);
+            params.addAll(nonEmpty.get(0).params);
+        } else {
+            for (int i = 0; i < nonEmpty.size(); i++) {
+                if (i > 0) {
+                    ql.append(" OR ");
+                }
+                ql.append("(").append(nonEmpty.get(i).ql).append(")");
+                params.addAll(nonEmpty.get(i).params);
+            }
+        }
+        return this;
+    }
+
+    private Conditions condition(String column, String operator, Serializable<BanyandbModel.TagValue> value) {
+        final String connector = ql.length() == 0 ? (groupMode ? "" : " WHERE ") : " AND ";
+        ql.append(connector).append(column).append(operator);
+        params.add(value);
+        return this;
+    }
+}
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBTraceQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBTraceQueryDAO.java
index 2f02c4918c..5e32dfcaf4 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBTraceQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBTraceQueryDAO.java
@@ -22,9 +22,7 @@ import javax.annotation.Nullable;
 import org.apache.skywalking.apm.network.language.agent.v3.SegmentObject;
 import org.apache.skywalking.apm.network.language.agent.v3.SpanObject;
 import org.apache.skywalking.apm.network.language.agent.v3.SpanType;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
-import org.apache.skywalking.library.banyandb.v1.client.TraceQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TraceQueryResponse;
 import org.apache.skywalking.oap.server.core.Const;
 import org.apache.skywalking.oap.server.core.CoreModule;
@@ -55,6 +53,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 
 public class BanyanDBTraceQueryDAO extends AbstractBanyanDBDAO implements ITraceQueryV2DAO {
     private final int segmentQueryMaxSize;
@@ -83,15 +82,12 @@ public class BanyanDBTraceQueryDAO extends AbstractBanyanDBDAO implements ITrace
             return Collections.emptyList();
         }
         final boolean isColdStage = duration != null && duration.isColdStage();
-        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration),
-            new QueryBuilder<TraceQuery>() {
-                @Override
-                public void apply(TraceQuery query) {
-                    query.and(in(SegmentRecord.SEGMENT_ID, segmentIdList));
-                    query.setLimit(segmentQueryMaxSize);
-                    query.setOrderBy(new TraceQuery.OrderBy(SegmentRecord.START_TIME, AbstractQuery.Sort.DESC));
-                }
-            });
+        final Conditions where = Conditions.create()
+            .in(SegmentRecord.SEGMENT_ID, segmentIdList)
+            .orderByDesc(SegmentRecord.START_TIME)
+            .limit(segmentQueryMaxSize);
+        TraceQueryResponse resp = queryTraceDebuggable(
+            isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration), where);
         return buildRecords(resp, segmentIdList, null, true);
     }
 
@@ -101,15 +97,12 @@ public class BanyanDBTraceQueryDAO extends AbstractBanyanDBDAO implements ITrace
             return Collections.emptyList();
         }
         final boolean isColdStage = duration != null && duration.isColdStage();
-        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration),
-                                         new QueryBuilder<TraceQuery>() {
-                                             @Override
-                                             public void apply(TraceQuery query) {
-                                                 query.and(in(SegmentRecord.TRACE_ID, traceIdList));
-                                                 query.and(in(SegmentRecord.SERVICE_INSTANCE_ID, instanceIdList));
-                                                 query.setLimit(segmentQueryMaxSize);
-                                             }
-                                         });
+        final Conditions where = Conditions.create()
+            .in(SegmentRecord.TRACE_ID, traceIdList)
+            .in(SegmentRecord.SERVICE_INSTANCE_ID, instanceIdList)
+            .limit(segmentQueryMaxSize);
+        TraceQueryResponse resp = queryTraceDebuggable(
+            isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration), where);
 
         return buildRecords(resp, null, instanceIdList, false);
     }
@@ -123,14 +116,11 @@ public class BanyanDBTraceQueryDAO extends AbstractBanyanDBDAO implements ITrace
     public List<SpanWrapper> queryByTraceIdV2(final String traceId,
                                               @Nullable final Duration duration) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
-        final QueryBuilder<TraceQuery> query = new QueryBuilder<TraceQuery>() {
-            @Override
-            public void apply(TraceQuery query) {
-                query.and(eq(SegmentRecord.TRACE_ID, traceId));
-                query.setLimit(segmentQueryMaxSize);
-            }
-        };
-        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration), query);
+        final Conditions where = Conditions.create()
+            .eq(SegmentRecord.TRACE_ID, traceId)
+            .limit(segmentQueryMaxSize);
+        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, SegmentRecord.INDEX_NAME, getTimestampRange(duration),
+            where);
         if (resp.getTraces().isEmpty()) {
             return new ArrayList<>();
         }
@@ -148,76 +138,67 @@ public class BanyanDBTraceQueryDAO extends AbstractBanyanDBDAO implements ITrace
     public TracesQueryResult queryTraces(final TraceQueryCondition condition) throws IOException {
         Duration duration = condition.getQueryDuration();
         final boolean isColdStage = duration != null && duration.isColdStage();
-        final QueryBuilder<TraceQuery> query = new QueryBuilder<TraceQuery>() {
-                @Override
-                public void apply(TraceQuery query) {
-                    if (StringUtil.isNotBlank(condition.getTraceId())) {
-                        query.and(eq(SegmentRecord.TRACE_ID, condition.getTraceId()));
-                    }
-                    if (condition.getMinTraceDuration() != 0) {
-                        // duration >= minDuration
-                        query.and(gte(SegmentRecord.LATENCY, condition.getMinTraceDuration()));
-                    }
-                    if (condition.getMaxTraceDuration() != 0) {
-                        // duration <= maxDuration
-                        query.and(lte(SegmentRecord.LATENCY, condition.getMaxTraceDuration()));
-                    }
-
-                    if (StringUtil.isNotEmpty(condition.getServiceId())) {
-                        query.and(eq(SegmentRecord.SERVICE_ID, condition.getServiceId()));
-                    }
-
-                    if (StringUtil.isNotEmpty(condition.getServiceInstanceId())) {
-                        if (StringUtil.isEmpty(condition.getServiceId())) {
-                            IDManager.ServiceInstanceID.InstanceIDDefinition instanceIDDefinition = IDManager.ServiceInstanceID.analysisId(
-                                condition.getServiceInstanceId());
-                            query.and(eq(SegmentRecord.SERVICE_ID, instanceIDDefinition.getServiceId()));
-                        }
-                        query.and(eq(SegmentRecord.SERVICE_INSTANCE_ID, condition.getServiceInstanceId()));
-                    }
-
-                    if (StringUtil.isNotEmpty(condition.getEndpointId())) {
-                        if (StringUtil.isEmpty(condition.getServiceId())) {
-                            IDManager.EndpointID.EndpointIDDefinition endpointIDDefinition = IDManager.EndpointID.analysisId(
-                                condition.getEndpointId());
-                            query.and(eq(SegmentRecord.SERVICE_ID, endpointIDDefinition.getServiceId()));
-                        }
-                        query.and(eq(SegmentRecord.ENDPOINT_ID, condition.getEndpointId()));
-                    }
-
-                    switch (condition.getTraceState()) {
-                        case ERROR:
-                            query.and(eq(SegmentRecord.IS_ERROR, BooleanUtils.TRUE));
-                            break;
-                        case SUCCESS:
-                            query.and(eq(SegmentRecord.IS_ERROR, BooleanUtils.FALSE));
-                            break;
-                    }
-
-                    switch (condition.getQueryOrder()) {
-                        case BY_START_TIME:
-                            query.setOrderBy(new TraceQuery.OrderBy(SegmentRecord.START_TIME, AbstractQuery.Sort.DESC));
-                            break;
-                        case BY_DURATION:
-                            query.setOrderBy(new TraceQuery.OrderBy(SegmentRecord.LATENCY, AbstractQuery.Sort.DESC));
-                            break;
-                    }
-                    List<Tag> tags = condition.getTags();
-                    if (CollectionUtils.isNotEmpty(tags)) {
-                        List<String> tagsConditions = new ArrayList<>(tags.size());
-                        for (final Tag tag : tags) {
-                            tagsConditions.add(tag.toString());
-                        }
-                        query.and(having(SegmentRecord.TAGS, tagsConditions));
-                    }
-                    PaginationUtils.Page page = PaginationUtils.INSTANCE.exchange(condition.getPaging());
-                    query.setLimit(page.getLimit());
-                    query.setOffset(page.getFrom());
-                }
-            };
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotBlank(condition.getTraceId())) {
+            where.eq(SegmentRecord.TRACE_ID, condition.getTraceId());
+        }
+        if (condition.getMinTraceDuration() != 0) {
+            where.gte(SegmentRecord.LATENCY, condition.getMinTraceDuration());
+        }
+        if (condition.getMaxTraceDuration() != 0) {
+            where.lte(SegmentRecord.LATENCY, condition.getMaxTraceDuration());
+        }
+        if (StringUtil.isNotEmpty(condition.getServiceId())) {
+            where.eq(SegmentRecord.SERVICE_ID, condition.getServiceId());
+        }
+        if (StringUtil.isNotEmpty(condition.getServiceInstanceId())) {
+            if (StringUtil.isEmpty(condition.getServiceId())) {
+                IDManager.ServiceInstanceID.InstanceIDDefinition instanceIDDefinition =
+                    IDManager.ServiceInstanceID.analysisId(condition.getServiceInstanceId());
+                where.eq(SegmentRecord.SERVICE_ID, instanceIDDefinition.getServiceId());
+            }
+            where.eq(SegmentRecord.SERVICE_INSTANCE_ID, condition.getServiceInstanceId());
+        }
+        if (StringUtil.isNotEmpty(condition.getEndpointId())) {
+            if (StringUtil.isEmpty(condition.getServiceId())) {
+                IDManager.EndpointID.EndpointIDDefinition endpointIDDefinition =
+                    IDManager.EndpointID.analysisId(condition.getEndpointId());
+                where.eq(SegmentRecord.SERVICE_ID, endpointIDDefinition.getServiceId());
+            }
+            where.eq(SegmentRecord.ENDPOINT_ID, condition.getEndpointId());
+        }
+        switch (condition.getTraceState()) {
+            case ERROR:
+                where.eq(SegmentRecord.IS_ERROR, BooleanUtils.TRUE);
+                break;
+            case SUCCESS:
+                where.eq(SegmentRecord.IS_ERROR, BooleanUtils.FALSE);
+                break;
+            default:
+                break;
+        }
+        List<Tag> tags = condition.getTags();
+        if (CollectionUtils.isNotEmpty(tags)) {
+            List<String> tagsConditions = new ArrayList<>(tags.size());
+            for (final Tag tag : tags) {
+                tagsConditions.add(tag.toString());
+            }
+            where.having(SegmentRecord.TAGS, tagsConditions);
+        }
+        switch (condition.getQueryOrder()) {
+            case BY_START_TIME:
+                where.orderByDesc(SegmentRecord.START_TIME);
+                break;
+            case BY_DURATION:
+                where.orderByDesc(SegmentRecord.LATENCY);
+                break;
+        }
+        PaginationUtils.Page page = PaginationUtils.INSTANCE.exchange(condition.getPaging());
+        where.limit(page.getLimit())
+            .offset(page.getFrom());
         TimestampRange timestampRange = getTimestampRange(duration);
         TraceQueryResponse resp = queryTraceDebuggable(
-            isColdStage, SegmentRecord.INDEX_NAME, timestampRange, query);
+            isColdStage, SegmentRecord.INDEX_NAME, timestampRange, where);
         List<List<SpanWrapper>> traces = new ArrayList<>();
         for (var t : resp.getTraces()) {
             List<SpanWrapper> trace = new ArrayList<>();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBZipkinQueryDAO.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBZipkinQueryDAO.java
index be1a5c16f3..fa3167cba5 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBZipkinQueryDAO.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/main/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/trace/BanyanDBZipkinQueryDAO.java
@@ -26,11 +26,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.annotation.Nullable;
-import org.apache.skywalking.library.banyandb.v1.client.AbstractQuery;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
-import org.apache.skywalking.library.banyandb.v1.client.TraceQuery;
 import org.apache.skywalking.library.banyandb.v1.client.TraceQueryResponse;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
 import org.apache.skywalking.oap.server.core.query.input.Duration;
@@ -45,6 +42,7 @@ import org.apache.skywalking.oap.server.library.util.StringUtil;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.BanyanDBStorageClient;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.MetadataRegistry;
 import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.AbstractBanyanDBDAO;
+import org.apache.skywalking.oap.server.storage.plugin.banyandb.stream.Conditions;
 import zipkin2.Span;
 import zipkin2.storage.QueryRequest;
 
@@ -62,17 +60,10 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
     @Override
     public List<String> getServiceNames() throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ZipkinServiceTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp =
-            query(false, schema,
-                  SERVICE_TRAFFIC_TAGS,
-                  Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        query.setLimit(QUERY_MAX_SIZE);
-                    }
-                }
-            );
+        MeasureQueryResponse resp = queryDebuggable(
+            false, schema, SERVICE_TRAFFIC_TAGS, Collections.emptySet(),
+            null,
+            Conditions.create().limit(QUERY_MAX_SIZE));
         final List<String> services = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
             services.add(dataPoint.getTagValue(ZipkinServiceTraffic.SERVICE_NAME));
@@ -83,20 +74,15 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
     @Override
     public List<String> getRemoteServiceNames(final String serviceName) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ZipkinServiceRelationTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp =
-            query(false, schema,
-                  REMOTE_SERVICE_TRAFFIC_TAGS,
-                  Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        if (StringUtil.isNotEmpty(serviceName)) {
-                            query.and(eq(ZipkinServiceRelationTraffic.SERVICE_NAME, serviceName));
-                        }
-                        query.setLimit(QUERY_MAX_SIZE);
-                    }
-                }
-            );
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceName)) {
+            where.eq(ZipkinServiceRelationTraffic.SERVICE_NAME, serviceName);
+        }
+        where.limit(QUERY_MAX_SIZE);
+        MeasureQueryResponse resp = queryDebuggable(
+            false, schema, REMOTE_SERVICE_TRAFFIC_TAGS, Collections.emptySet(),
+            null,
+            where);
         final List<String> remoteServices = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
             remoteServices.add(dataPoint.getTagValue(ZipkinServiceRelationTraffic.REMOTE_SERVICE_NAME));
@@ -107,20 +93,15 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
     @Override
     public List<String> getSpanNames(final String serviceName) throws IOException {
         MetadataRegistry.Schema schema = MetadataRegistry.INSTANCE.findMetricMetadata(ZipkinServiceSpanTraffic.INDEX_NAME, DownSampling.Minute);
-        MeasureQueryResponse resp =
-            query(false, schema,
-                  SPAN_TRAFFIC_TAGS,
-                  Collections.emptySet(), new QueryBuilder<MeasureQuery>() {
-
-                    @Override
-                    protected void apply(MeasureQuery query) {
-                        if (StringUtil.isNotEmpty(serviceName)) {
-                            query.and(eq(ZipkinServiceSpanTraffic.SERVICE_NAME, serviceName));
-                        }
-                        query.setLimit(QUERY_MAX_SIZE);
-                    }
-                }
-            );
+        final Conditions where = Conditions.create();
+        if (StringUtil.isNotEmpty(serviceName)) {
+            where.eq(ZipkinServiceSpanTraffic.SERVICE_NAME, serviceName);
+        }
+        where.limit(QUERY_MAX_SIZE);
+        MeasureQueryResponse resp = queryDebuggable(
+            false, schema, SPAN_TRAFFIC_TAGS, Collections.emptySet(),
+            null,
+            where);
         final List<String> spanNames = new ArrayList<>();
         for (final DataPoint dataPoint : resp.getDataPoints()) {
             spanNames.add(dataPoint.getTagValue(ZipkinServiceSpanTraffic.SPAN_NAME));
@@ -146,14 +127,10 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
     @Override
     public List<SpanWrapper> getTraceV2(final String traceId, @Nullable final Duration duration) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
-        final QueryBuilder<TraceQuery> query = new QueryBuilder<TraceQuery>() {
-            @Override
-            protected void apply(TraceQuery query) {
-                query.and(eq(ZipkinSpanRecord.TRACE_ID, traceId));
-                query.setLimit(QUERY_MAX_SIZE);
-            }
-        };
-        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration), query);
+        final Conditions where = Conditions.create()
+            .eq(ZipkinSpanRecord.TRACE_ID, traceId)
+            .limit(QUERY_MAX_SIZE);
+        TraceQueryResponse resp = queryTraceDebuggable(isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration), where);
         if (resp.getTraces().isEmpty()) {
             return new ArrayList<>();
         }
@@ -174,19 +151,12 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
             return Collections.emptyList();
         }
         final boolean isColdStage = duration != null && duration.isColdStage();
-        final QueryBuilder<TraceQuery> query = new QueryBuilder<TraceQuery>() {
-
-            @Override
-            protected void apply(TraceQuery query) {
-                query.and(in(ZipkinSpanRecord.TRACE_ID, new ArrayList<>(traceIds)));
-                query.setOrderBy(new TraceQuery.OrderBy(ZipkinSpanRecord.TIMESTAMP_MILLIS, AbstractQuery.Sort.DESC));
-                query.setLimit(QUERY_MAX_SIZE);
-            }
-        };
+        final Conditions where = Conditions.create()
+            .in(ZipkinSpanRecord.TRACE_ID, new ArrayList<>(traceIds))
+            .orderByDesc(ZipkinSpanRecord.TIMESTAMP_MILLIS)
+            .limit(QUERY_MAX_SIZE);
         TraceQueryResponse resp = queryTraceDebuggable(
-                isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration),
-                query
-            );
+            isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration), where);
         List<List<SpanWrapper>> traces = new ArrayList<>();
         for (var t : resp.getTraces()) {
             List<SpanWrapper> trace = new ArrayList<>();
@@ -203,47 +173,36 @@ public class BanyanDBZipkinQueryDAO extends AbstractBanyanDBDAO implements IZipk
     public List<List<SpanWrapper>> getTracesV2(final QueryRequest request, final Duration duration) throws IOException {
         final boolean isColdStage = duration != null && duration.isColdStage();
 
-        final QueryBuilder<TraceQuery> queryBuilder = new QueryBuilder<TraceQuery>() {
-            @Override
-            public void apply(final TraceQuery query) {
-                if (!StringUtil.isEmpty(request.serviceName())) {
-                    query.and(eq(ZipkinSpanRecord.LOCAL_ENDPOINT_SERVICE_NAME, request.serviceName()));
-                }
-
-                if (!StringUtil.isEmpty(request.remoteServiceName())) {
-                    query.and(eq(ZipkinSpanRecord.REMOTE_ENDPOINT_SERVICE_NAME, request.remoteServiceName()));
-                }
-
-                if (!StringUtil.isEmpty(request.spanName())) {
-                    query.and(eq(ZipkinSpanRecord.NAME, request.spanName()));
-                }
-
-                if (!CollectionUtils.isEmpty(request.annotationQuery())) {
-                    List<String> queryConditions = new ArrayList<>();
-                    for (Map.Entry<String, String> annotation : request.annotationQuery().entrySet()) {
-                        if (annotation.getValue().isEmpty()) {
-                            queryConditions.add(annotation.getKey());
-                        } else {
-                            queryConditions.add(annotation.getKey() + "=" + annotation.getValue());
-                        }
-                    }
-                    query.and(having(ZipkinSpanRecord.QUERY, queryConditions));
-                }
-
-                if (request.minDuration() != null) {
-                    query.and(gte(ZipkinSpanRecord.DURATION, request.minDuration()));
-                }
-                if (request.maxDuration() != null) {
-                    query.and(lte(ZipkinSpanRecord.DURATION, request.maxDuration()));
+        final Conditions where = Conditions.create();
+        if (!StringUtil.isEmpty(request.serviceName())) {
+            where.eq(ZipkinSpanRecord.LOCAL_ENDPOINT_SERVICE_NAME, request.serviceName());
+        }
+        if (!StringUtil.isEmpty(request.remoteServiceName())) {
+            where.eq(ZipkinSpanRecord.REMOTE_ENDPOINT_SERVICE_NAME, request.remoteServiceName());
+        }
+        if (!StringUtil.isEmpty(request.spanName())) {
+            where.eq(ZipkinSpanRecord.NAME, request.spanName());
+        }
+        if (!CollectionUtils.isEmpty(request.annotationQuery())) {
+            List<String> queryConditions = new ArrayList<>();
+            for (Map.Entry<String, String> annotation : request.annotationQuery().entrySet()) {
+                if (annotation.getValue().isEmpty()) {
+                    queryConditions.add(annotation.getKey());
+                } else {
+                    queryConditions.add(annotation.getKey() + "=" + annotation.getValue());
                 }
-                query.setOrderBy(new TraceQuery.OrderBy(ZipkinSpanRecord.TIMESTAMP_MILLIS, AbstractQuery.Sort.DESC));
-                query.setLimit(request.limit());
             }
-        };
+            where.having(ZipkinSpanRecord.QUERY, queryConditions);
+        }
+        if (request.minDuration() != null) {
+            where.gte(ZipkinSpanRecord.DURATION, request.minDuration());
+        }
+        if (request.maxDuration() != null) {
+            where.lte(ZipkinSpanRecord.DURATION, request.maxDuration());
+        }
+        where.orderByDesc(ZipkinSpanRecord.TIMESTAMP_MILLIS).limit(request.limit());
         TraceQueryResponse resp = queryTraceDebuggable(
-            isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration),
-            queryBuilder
-        );
+            isColdStage, ZipkinSpanRecord.INDEX_NAME, getTimestampRange(duration), where);
         List<List<SpanWrapper>> traces = new ArrayList<>();
         for (var t : resp.getTraces()) {
             List<SpanWrapper> trace = new ArrayList<>();
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBIT.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBIT.java
index 5ddd1d2bf1..4e282730ea 100644
--- a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBIT.java
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/BanyanDBIT.java
@@ -18,9 +18,6 @@
 
 package org.apache.skywalking.oap.server.storage.plugin.banyandb;
 
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
@@ -33,11 +30,10 @@ import org.apache.skywalking.banyandb.common.v1.BanyandbCommon;
 import org.apache.skywalking.banyandb.database.v1.BanyandbDatabase;
 import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
 import org.apache.skywalking.library.banyandb.v1.client.DataPoint;
-import org.apache.skywalking.library.banyandb.v1.client.MeasureQuery;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureQueryResponse;
 import org.apache.skywalking.library.banyandb.v1.client.MeasureWrite;
 import org.apache.skywalking.library.banyandb.v1.client.TagAndValue;
-import org.apache.skywalking.library.banyandb.v1.client.TimestampRange;
+import org.apache.skywalking.library.banyandb.v1.client.Value;
 import org.apache.skywalking.oap.server.core.CoreModule;
 import org.apache.skywalking.oap.server.core.analysis.DownSampling;
 import org.apache.skywalking.oap.server.core.analysis.Stream;
@@ -223,15 +219,12 @@ public class BanyanDBIT {
         });
         f.get(10, TimeUnit.SECONDS);
 
-        MeasureQuery query = new MeasureQuery(Lists.newArrayList(groupName), "testMetric_minute",
-                                              new TimestampRange(
-                                                  begin.toEpochMilli(),
-                                                  now.plus(1, ChronoUnit.MINUTES).toEpochMilli()
-                                              ), ImmutableMap.of("service_id", "storage-only", "tag", "searchable"),
-                                              ImmutableSet.of("value")
-        );
+        final String ql = "SELECT \"service_id\", \"tag\", \"value\" FROM MEASURE testMetric_minute IN "
+            + groupName + " TIME BETWEEN ? AND ?";
         await().atMost(10, TimeUnit.SECONDS).untilAsserted(() -> {
-            MeasureQueryResponse resp = client.query(query);
+            MeasureQueryResponse resp = client.queryMeasure(ql,
+                Value.timestampTagValue(begin.toEpochMilli()),
+                Value.timestampTagValue(now.plus(1, ChronoUnit.MINUTES).toEpochMilli()));
             assertNotNull(resp);
             assertEquals(1, resp.getDataPoints().size());
             assertEquals("service1", resp.getDataPoints().get(0).getTagValue("service_id"));
@@ -298,18 +291,16 @@ public class BanyanDBIT {
             return null;
         });
         cf.get(10, TimeUnit.SECONDS);
-        MeasureQuery updatedQuery = new MeasureQuery(
-            Lists.newArrayList(groupName), "testMetric_minute",
-            new TimestampRange(begin.toEpochMilli(), now.plus(15, ChronoUnit.MINUTES).toEpochMilli()),
-            ImmutableMap.of("service_id", "storage-only", "tag", "searchable", "new_tag", "searchable"),
-                                                     ImmutableSet.of("value", "new_value")
-        );
+        final String updatedQl = "SELECT \"service_id\", \"tag\", \"new_tag\", \"value\", \"new_value\" "
+            + "FROM MEASURE testMetric_minute IN " + groupName + " TIME BETWEEN ? AND ?";
         await().atMost(10, TimeUnit.SECONDS).untilAsserted(() -> {
-            MeasureQueryResponse updatedResp = client.query(updatedQuery);
+            MeasureQueryResponse updatedResp = client.queryMeasure(updatedQl,
+                Value.timestampTagValue(begin.toEpochMilli()),
+                Value.timestampTagValue(now.plus(15, ChronoUnit.MINUTES).toEpochMilli()));
             assertNotNull(updatedResp);
             assertEquals(2, updatedResp.getDataPoints().size());
             // Index by service_id so the assertions don't depend on server-side ordering
-            // (MeasureQuery doesn't set an orderBy and BanyanDB result order is not contractually stable).
+            // (the query sets no ORDER BY and BanyanDB result order is not contractually stable).
             Map<String, DataPoint> byService = updatedResp.getDataPoints().stream()
                 .collect(Collectors.toMap(dp -> (String) dp.getTagValue("service_id"), dp -> dp));
             DataPoint dp1 = byService.get("service1");
diff --git a/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/ConditionsTest.java b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/ConditionsTest.java
new file mode 100644
index 0000000000..25f71ab1ff
--- /dev/null
+++ b/oap-server/server-storage-plugin/storage-banyandb-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/banyandb/stream/ConditionsTest.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ *     http://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.
+ *
+ */
+
+package org.apache.skywalking.oap.server.storage.plugin.banyandb.stream;
+
+import java.util.List;
+import org.apache.skywalking.banyandb.model.v1.BanyandbModel;
+import org.apache.skywalking.library.banyandb.v1.client.metadata.Serializable;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ConditionsTest {
+
+    private static String str(Serializable<BanyandbModel.TagValue> param) {
+        return param.serialize().getStr().getValue();
+    }
+
+    private static long lng(Serializable<BanyandbModel.TagValue> param) {
+        return param.serialize().getInt().getValue();
+    }
+
+    @Test
+    public void emptyProducesNoClauseAndNoParams() {
+        final Conditions where = Conditions.create();
+        assertEquals("", where.buildQl());
+        assertTrue(where.params().isEmpty());
+    }
+
+    @Test
+    public void firstPredicateUsesWhereConnector() {
+        final Conditions where = Conditions.create().eq("a", "x");
+        assertEquals(" WHERE a = ?", where.buildQl());
+        assertEquals(1, where.params().size());
+        assertEquals("x", str(where.params().get(0)));
+    }
+
+    @Test
+    public void secondPredicateUsesAndConnectorAndParamsKeepOrder() {
+        final Conditions where = Conditions.create().eq("a", "x").gte("b", 5L);
+        assertEquals(" WHERE a = ? AND b >= ?", where.buildQl());
+        final List<Serializable<BanyandbModel.TagValue>> params = where.params();
+        assertEquals(2, params.size());
+        assertEquals("x", str(params.get(0)));
+        assertEquals(5L, lng(params.get(1)));
+    }
+
+    @Test
+    public void comparisonOperatorsRenderExpectedSymbols() {
+        assertEquals(" WHERE a != ?", Conditions.create().ne("a", "x").buildQl());
+        assertEquals(" WHERE a > ?", Conditions.create().gt("a", 1L).buildQl());
+        assertEquals(" WHERE a >= ?", Conditions.create().gte("a", 1L).buildQl());
+        assertEquals(" WHERE a <= ?", Conditions.create().lte("a", 1L).buildQl());
+    }
+
+    @Test
+    public void inMatchAndHavingRenderExpectedClauses() {
+        assertEquals(" WHERE a IN (?)", Conditions.create().in("a", List.of("x", "y")).buildQl());
+        assertEquals(" WHERE a MATCH(?)", Conditions.create().match("a", "kw").buildQl());
+        assertEquals(" WHERE a MATCH(?, 'url', 'AND')",
+                     Conditions.create().match("a", "url", "AND", "kw").buildQl());
+        assertEquals(" WHERE a HAVING (?)", Conditions.create().having("a", List.of("x")).buildQl());
+    }
+
+    @Test
+    public void inBindsAStringArrayParam() {
+        final Conditions where = Conditions.create().in("a", List.of("x", "y"));
+        assertEquals(1, where.params().size());
+        assertEquals(List.of("x", "y"), where.params().get(0).serialize().getStrArray().getValueList());
+    }
+
+    @Test
+    public void tailClausesComposeInOrderWithParams() {
+        final Conditions where = Conditions.create()
+                .eq("a", "x")
+                .groupBy("g1", "g2")
+                .orderByDesc("t")
+                .limit(10)
+                .offset(20);
+        assertEquals(" WHERE a = ? GROUP BY g1, g2 ORDER BY t DESC LIMIT ? OFFSET ?", where.buildQl());
+        final List<Serializable<BanyandbModel.TagValue>> params = where.params();
+        assertEquals(3, params.size());
+        assertEquals("x", str(params.get(0)));
+        assertEquals(10L, lng(params.get(1)));
+        assertEquals(20L, lng(params.get(2)));
+    }
+
+    @Test
+    public void directionOnlyAndColumnOrderBy() {
+        assertEquals(" ORDER BY DESC", Conditions.create().orderByDesc().buildQl());
+        assertEquals(" ORDER BY ASC", Conditions.create().orderByAsc().buildQl());
+        assertEquals(" ORDER BY t ASC", Conditions.create().orderBy("t", "ASC").buildQl());
+    }
+
+    @Test
+    public void groupModeOmitsLeadingWhere() {
+        final Conditions group = Conditions.group().eq("a", "x").eq("b", "y");
+        assertEquals("a = ? AND b = ?", group.buildQl());
+    }
+
+    @Test
+    public void orWithNoGroupsEmitsNothing() {
+        final Conditions where = Conditions.create().or(List.of());
+        assertEquals("", where.buildQl());
+        assertTrue(where.params().isEmpty());
+    }
+
+    @Test
+    public void orWithOnlyEmptyGroupsEmitsNothing() {
+        final Conditions where = Conditions.create().or(List.of(Conditions.group(), Conditions.group()));
+        assertEquals("", where.buildQl());
+        assertTrue(where.params().isEmpty());
+    }
+
+    @Test
+    public void orWithSingleNonEmptyGroupHasNoParentheses() {
+        final Conditions where = Conditions.create().or(List.of(
+                Conditions.group().in("a", List.of("x"))));
+        assertEquals(" WHERE a IN (?)", where.buildQl());
+        assertEquals(1, where.params().size());
+    }
+
+    @Test
+    public void orWithMultipleGroupsWrapsInParenthesesAndOrdersParams() {
+        final Conditions where = Conditions.create().or(List.of(
+                Conditions.group().eq("a", "x"),
+                Conditions.group().eq("b", "y")));
+        assertEquals(" WHERE (a = ?) OR (b = ?)", where.buildQl());
+        final List<Serializable<BanyandbModel.TagValue>> params = where.params();
+        assertEquals(2, params.size());
+        assertEquals("x", str(params.get(0)));
+        assertEquals("y", str(params.get(1)));
+    }
+
+    @Test
+    public void orSkipsEmptyGroupsAndCollapsesToSingle() {
+        final Conditions where = Conditions.create().or(List.of(
+                Conditions.group(),
+                Conditions.group().eq("a", "x"),
+                Conditions.group()));
+        assertEquals(" WHERE a = ?", where.buildQl());
+        assertEquals(1, where.params().size());
+    }
+}
diff --git a/test/e2e-v2/script/env b/test/e2e-v2/script/env
index 8642e4c684..32fc063bd1 100644
--- a/test/e2e-v2/script/env
+++ b/test/e2e-v2/script/env
@@ -23,7 +23,7 @@ SW_AGENT_CLIENT_JS_COMMIT=f08776d909eb1d9bc79c600e493030651b97e491
 SW_AGENT_CLIENT_JS_TEST_COMMIT=4f1eb1dcdbde3ec4a38534bf01dded4ab5d2f016
 SW_KUBERNETES_COMMIT_SHA=da0e267f877b9b8e5f7728ae4ea7dc7723a2a073
 SW_ROVER_COMMIT=79292fe07f17f98f486e0c4471213e1961fb2d1d
-SW_BANYANDB_COMMIT=c2d925e4eae4d77edda94e1fd438243483960150
+SW_BANYANDB_COMMIT=38932b9113686cddb75739adf2ed2e75324a927a
 SW_AGENT_PHP_COMMIT=de311c9cd084e21becade0742cd289bc0f43181d
 SW_PREDICTOR_COMMIT=54a0197654a3781a6f73ce35146c712af297c994