From a7fc535149af0cfa48805ba35887ee4ec09f8204 Mon Sep 17 00:00:00 2001 From: Sudharsan_K Date: Thu, 23 Jul 2026 18:23:08 +0530 Subject: [PATCH 1/4] [fix](show) apply ORDER BY to SHOW TABLETS result set --- .../commands/ShowTabletsFromTableCommand.java | 27 ++++---- .../doris/nereids/util/RecordPickerUtils.java | 67 +++++++++++++++++++ 2 files changed, 80 insertions(+), 14 deletions(-) create mode 100644 fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java index a844455e9326aa..e5b7f6b8619ede 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java @@ -27,8 +27,6 @@ import org.apache.doris.catalog.Partition; import org.apache.doris.catalog.Replica; import org.apache.doris.catalog.ScalarType; -import org.apache.doris.catalog.info.PartitionNamesInfo; -import org.apache.doris.catalog.info.TableNameInfo; import org.apache.doris.common.AnalysisException; import org.apache.doris.common.ErrorCode; import org.apache.doris.common.ErrorReport; @@ -37,6 +35,8 @@ import org.apache.doris.common.util.ListComparator; import org.apache.doris.common.util.OrderByPair; import org.apache.doris.common.util.Util; +import org.apache.doris.info.PartitionNamesInfo; +import org.apache.doris.info.TableNameInfo; import org.apache.doris.mysql.privilege.PrivPredicate; import org.apache.doris.nereids.analyzer.UnboundSlot; import org.apache.doris.nereids.properties.OrderKey; @@ -48,23 +48,28 @@ import org.apache.doris.nereids.trees.plans.PlanType; import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor; import org.apache.doris.nereids.util.ExpressionUtils; +import org.apache.doris.nereids.util.RecordPickerUtils; import org.apache.doris.qe.ConnectContext; import org.apache.doris.qe.ShowResultSet; import org.apache.doris.qe.ShowResultSetMetaData; import org.apache.doris.qe.StmtExecutor; import com.google.common.collect.Lists; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Locale; +import java.util.Optional; /** * ShowTabletsFromTableCommand */ public class ShowTabletsFromTableCommand extends ShowCommand { + private static final Logger LOG = LogManager.getLogger(ShowTabletsFromTableCommand.class); private TableNameInfo dbTableName; private PartitionNamesInfo partitionNames; private Expression whereClause; @@ -105,7 +110,7 @@ public void validate(ConnectContext ctx) throws UserException { ErrorReport.reportAnalysisException(ErrorCode.ERR_SPECIFIC_ACCESS_DENIED_ERROR, "SHOW TABLETS"); } - dbTableName.analyze(ctx.getNameSpaceContext()); + dbTableName.analyze(ctx); Util.prohibitExternalCatalog(dbTableName.getCtl(), this.getClass().getSimpleName()); if (partitionNames != null) { @@ -232,13 +237,9 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc TabletsProcDir procDir = new TabletsProcDir(olapTable, index); tabletInfos.addAll(procDir.fetchComparableResult( version, backendId, replicaState)); - if (sizeLimit > -1 && tabletInfos.size() >= sizeLimit) { - stop = true; - break; - } } } - if (offset >= tabletInfos.size()) { + if (offset >= tabletInfos.size()) {// tabletInfos.clear(); } else { // order by @@ -250,13 +251,10 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc // order by tabletId, replicaId comparator = new ListComparator<>(0, 1); } - Collections.sort(tabletInfos, comparator); - if (sizeLimit > -1) { - tabletInfos = tabletInfos.subList((int) offset, - Math.min((int) sizeLimit, tabletInfos.size())); - } + + List> orderedTableInfos = RecordPickerUtils.getQualifiedRecords(tabletInfos, comparator, Optional.of((int) sizeLimit)); - for (List tabletInfo : tabletInfos) { + for (List tabletInfo : orderedTableInfos) { List oneTablet = new ArrayList(tabletInfo.size()); for (Comparable column : tabletInfo) { oneTablet.add(column.toString()); @@ -296,3 +294,4 @@ public RedirectStatus toRedirectStatus() { } } } + diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java new file mode 100644 index 00000000000000..9e0f9a3edfcdaf --- /dev/null +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java @@ -0,0 +1,67 @@ +// 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.doris.nereids.util; + +import org.apache.doris.common.util.ListComparator; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.PriorityQueue; + +/** + * Record Picker Util. + */ +public class RecordPickerUtils { + /** + * Qualifies the record(s) that are available to be picked in the Query / Command's result. + */ + public static List> getQualifiedRecords(List> comparables, ListComparator> comparator, Optional k) { + + int limit = k.orElse( comparables.size()); + if (comparables.isEmpty() || limit <= 0) { + return new ArrayList<>(); + } + if (limit >= comparables.size()) { + // no pruning benefit — just sort everything + List> all = new ArrayList<>(comparables); + all.sort(comparator); + return all; + } + + + PriorityQueue> heap = new PriorityQueue<>(limit, comparator.reversed()); + + for (List row : comparables) { + if (heap.size() < limit) { + heap.offer(row); + } else if (comparator.compare(row, heap.peek()) < 0) { + heap.poll(); + heap.offer(row); + } + } + + List> result = new ArrayList<>(heap); + result.sort(comparator); // heap order isn't sorted order — final sort needed, ascending per original comparator + return result; + } + + +} + + From 0d8be17c60ea1ad83f4cf347487569d6995fe9c2 Mon Sep 17 00:00:00 2001 From: Sudharsan_K Date: Fri, 24 Jul 2026 18:07:07 +0530 Subject: [PATCH 2/4] [fix](fe) Apply all record sort keys before limiting ### What problem does this PR solve? Issue Number: None Related PR: None Problem Summary: RecordPickerUtils used a top-K heap before returning sorted records. Replace the heap selection with a stable full lexicographic sort before truncation so mixed-direction keys such as LocalDataSize DESC and TabletId ASC are applied in sequence. Negative no-limit values continue to sort the complete result. ### Release note Fix multi-column ordering for SHOW TABLETS results. ### Check List (For Author) - Test: Manual test - Verified LocalDataSize DESC, TabletId ASC with equal-size groups and a limit - Behavior changed: Yes, all ORDER BY keys are applied before limiting results - Does this need documentation: No Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../doris/nereids/util/RecordPickerUtils.java | 37 +++--------- .../nereids/util/RecordPickerUtilsTest.java | 59 +++++++++++++++++++ 2 files changed, 67 insertions(+), 29 deletions(-) create mode 100644 fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java index 9e0f9a3edfcdaf..103b81fb173cbf 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java @@ -22,7 +22,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Optional; -import java.util.PriorityQueue; /** * Record Picker Util. @@ -30,38 +29,18 @@ public class RecordPickerUtils { /** * Qualifies the record(s) that are available to be picked in the Query / Command's result. + * Negative sizeLimit (k) is disregarded as it is the default from the caller. */ - public static List> getQualifiedRecords(List> comparables, ListComparator> comparator, Optional k) { - - int limit = k.orElse( comparables.size()); - if (comparables.isEmpty() || limit <= 0) { + public static List> getQualifiedRecords( + List> comparables, ListComparator> comparator, Optional k) { + int limit = k.filter(v -> v >= 0).orElse(comparables.size()); + if (comparables.isEmpty() || limit == 0) { return new ArrayList<>(); } - if (limit >= comparables.size()) { - // no pruning benefit — just sort everything - List> all = new ArrayList<>(comparables); - all.sort(comparator); - return all; - } - - PriorityQueue> heap = new PriorityQueue<>(limit, comparator.reversed()); - - for (List row : comparables) { - if (heap.size() < limit) { - heap.offer(row); - } else if (comparator.compare(row, heap.peek()) < 0) { - heap.poll(); - heap.offer(row); - } - } - - List> result = new ArrayList<>(heap); - result.sort(comparator); // heap order isn't sorted order — final sort needed, ascending per original comparator - return result; + List> sortedRecords = new ArrayList<>(comparables); + sortedRecords.sort(comparator); + return new ArrayList<>(sortedRecords.subList(0, Math.min(limit, sortedRecords.size()))); } - } - - diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java new file mode 100644 index 00000000000000..cdcf1ceed9d941 --- /dev/null +++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java @@ -0,0 +1,59 @@ +// 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.doris.nereids.util; + +import org.apache.doris.common.util.ListComparator; +import org.apache.doris.common.util.OrderByPair; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +class RecordPickerUtilsTest { + + @Test + void testMultipleOrderByColumnsWithDifferentDirections() { + List> records = Arrays.asList( + createTabletRecord(3L, 200L), + createTabletRecord(2L, 100L), + createTabletRecord(1L, 200L), + createTabletRecord(3L, 100L), + createTabletRecord(2L, 200L), + createTabletRecord(1L, 100L)); + ListComparator> comparator = new ListComparator<>( + new OrderByPair(8, true), + new OrderByPair(0, false)); + + List> actual = RecordPickerUtils.getQualifiedRecords( + records, comparator, Optional.of(5)); + + Assertions.assertEquals(Arrays.asList( + createTabletRecord(1L, 200L), + createTabletRecord(2L, 200L), + createTabletRecord(3L, 200L), + createTabletRecord(1L, 100L), + createTabletRecord(2L, 100L)), actual); + } + + private List createTabletRecord(long tabletId, long localDataSize) { + return Arrays.asList(tabletId, 0L, 0L, 0L, 0L, 0L, 0L, 0L, localDataSize); + } +} From f0440e43ebdc722d409b21593976bb47c4bc40e7 Mon Sep 17 00:00:00 2001 From: Sudharsan_K Date: Fri, 24 Jul 2026 18:19:20 +0530 Subject: [PATCH 3/4] [fix](fe) Distinguish zero and absent SHOW TABLETS limits ### What problem does this PR solve? Issue Number: close #65871 Related PR: None Problem Summary: SHOW TABLETS represented both an absent LIMIT and LIMIT 0 as zero. The command consequently converted explicit LIMIT 0 to an unlimited request, returning all records. Preserve absent LIMIT as -1, pass it to RecordPickerUtils as Optional.empty(), retain explicit zero as Optional.of(0), and apply offset after the complete multi-column ordering. ### Release note SHOW TABLETS now honors LIMIT 0 and applies LIMIT/OFFSET after multi-column ordering. ### Check List (For Author) - Test: Manual test - Verified LIMIT 0 returns no records and unlimited LocalDataSize DESC, TabletId ASC ordering - Behavior changed: Yes, explicit LIMIT 0 no longer behaves as unlimited - Does this need documentation: No Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../nereids/parser/LogicalPlanBuilder.java | 2 +- .../commands/ShowTabletsFromTableCommand.java | 52 +++++++------------ .../doris/nereids/util/RecordPickerUtils.java | 3 +- .../ShowTabletsFromTableCommandTest.java | 14 +++++ .../nereids/util/RecordPickerUtilsTest.java | 15 ++++++ 5 files changed, 51 insertions(+), 35 deletions(-) diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java index c470bc789d9e78..15ce9c9f6d2cb7 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java @@ -7763,7 +7763,7 @@ public LogicalPlan visitShowTabletsFromTable(DorisParser.ShowTabletsFromTableCon if (ctx.sortClause() != null) { orderKeys = visit(ctx.sortClause().sortItem(), OrderKey.class); } - long limit = 0; + long limit = -1; long offset = 0; if (ctx.limitClause() != null) { limit = ctx.limitClause().limit != null diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java index e5b7f6b8619ede..cb10b5949be126 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java @@ -60,7 +60,6 @@ import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.List; import java.util.Locale; import java.util.Optional; @@ -74,7 +73,7 @@ public class ShowTabletsFromTableCommand extends ShowCommand { private PartitionNamesInfo partitionNames; private Expression whereClause; private List orderKeys; - private long limit = 0; + private long limit = -1; private long offset = 0; private long version; @@ -206,13 +205,9 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc OlapTable olapTable = db.getOlapTableOrAnalysisException(dbTableName.getTbl()); olapTable.readLock(); try { - long sizeLimit = -1; - if (offset > 0 && limit > 0) { - sizeLimit = offset + limit; - } else if (limit > 0) { - sizeLimit = limit; - } - boolean stop = false; + Optional sizeLimit = limit >= 0 + ? Optional.of((int) Math.min(Math.addExact(offset, limit), Integer.MAX_VALUE)) + : Optional.empty(); Collection partitions = new ArrayList(); if (partitionNames != null) { List paNames = partitionNames.getPartitionNames(); @@ -230,37 +225,31 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc } List> tabletInfos = new ArrayList<>(); for (Partition partition : partitions) { - if (stop) { - break; - } for (MaterializedIndex index : partition.getMaterializedIndices(IndexExtState.ALL)) { TabletsProcDir procDir = new TabletsProcDir(olapTable, index); tabletInfos.addAll(procDir.fetchComparableResult( version, backendId, replicaState)); } } - if (offset >= tabletInfos.size()) {// - tabletInfos.clear(); + // order by + ListComparator> comparator; + if (orderByPairs != null) { + OrderByPair[] orderByPairArr = new OrderByPair[orderByPairs.size()]; + comparator = new ListComparator<>(orderByPairs.toArray(orderByPairArr)); } else { - // order by - ListComparator> comparator = null; - if (orderByPairs != null) { - OrderByPair[] orderByPairArr = new OrderByPair[orderByPairs.size()]; - comparator = new ListComparator<>(orderByPairs.toArray(orderByPairArr)); - } else { - // order by tabletId, replicaId - comparator = new ListComparator<>(0, 1); - } - - List> orderedTableInfos = RecordPickerUtils.getQualifiedRecords(tabletInfos, comparator, Optional.of((int) sizeLimit)); + // order by tabletId, replicaId + comparator = new ListComparator<>(0, 1); + } - for (List tabletInfo : orderedTableInfos) { - List oneTablet = new ArrayList(tabletInfo.size()); - for (Comparable column : tabletInfo) { - oneTablet.add(column.toString()); - } - rows.add(oneTablet); + List> orderedTableInfos = + RecordPickerUtils.getQualifiedRecords(tabletInfos, comparator, sizeLimit); + int resultOffset = (int) Math.min(offset, orderedTableInfos.size()); + for (List tabletInfo : orderedTableInfos.subList(resultOffset, orderedTableInfos.size())) { + List oneTablet = new ArrayList(tabletInfo.size()); + for (Comparable column : tabletInfo) { + oneTablet.add(column.toString()); } + rows.add(oneTablet); } } finally { olapTable.readUnlock(); @@ -294,4 +283,3 @@ public RedirectStatus toRedirectStatus() { } } } - diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java index 103b81fb173cbf..74f2c4c8b21b57 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java @@ -29,11 +29,10 @@ public class RecordPickerUtils { /** * Qualifies the record(s) that are available to be picked in the Query / Command's result. - * Negative sizeLimit (k) is disregarded as it is the default from the caller. */ public static List> getQualifiedRecords( List> comparables, ListComparator> comparator, Optional k) { - int limit = k.filter(v -> v >= 0).orElse(comparables.size()); + int limit = k.orElse(comparables.size()); if (comparables.isEmpty() || limit == 0) { return new ArrayList<>(); } diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommandTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommandTest.java index 17613cd057ce02..5d1cf9960a45af 100644 --- a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommandTest.java +++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommandTest.java @@ -27,6 +27,7 @@ import org.apache.doris.mysql.privilege.AccessControllerManager; import org.apache.doris.mysql.privilege.PrivPredicate; import org.apache.doris.nereids.analyzer.UnboundSlot; +import org.apache.doris.nereids.parser.NereidsParser; import org.apache.doris.nereids.properties.OrderKey; import org.apache.doris.nereids.trees.expressions.EqualTo; import org.apache.doris.nereids.trees.expressions.Expression; @@ -50,6 +51,19 @@ public class ShowTabletsFromTableCommandTest extends TestWithFeService { private Env env; private AccessControllerManager accessControllerManager; + @Test + void testLimitClauseParsing() { + ShowTabletsFromTableCommand withoutLimit = (ShowTabletsFromTableCommand) new NereidsParser() + .parseSingle("SHOW TABLETS FROM test_table ORDER BY LocalDataSize DESC, TabletId ASC"); + ShowTabletsFromTableCommand withZeroLimit = (ShowTabletsFromTableCommand) new NereidsParser() + .parseSingle("SHOW TABLETS FROM test_table ORDER BY LocalDataSize DESC, TabletId ASC LIMIT 0"); + long withoutLimitValue = Deencapsulation.getField(withoutLimit, "limit"); + long zeroLimitValue = Deencapsulation.getField(withZeroLimit, "limit"); + + Assertions.assertEquals(-1L, withoutLimitValue); + Assertions.assertEquals(0L, zeroLimitValue); + } + private void runBefore() throws IOException { connectContext = createDefaultCtx(); env = Env.getCurrentEnv(); diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java index cdcf1ceed9d941..47306c7b34cc5d 100644 --- a/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java +++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/util/RecordPickerUtilsTest.java @@ -29,6 +29,21 @@ class RecordPickerUtilsTest { + @Test + void testZeroLimitReturnsNoRecords() { + List> records = Arrays.asList( + createTabletRecord(2L, 100L), + createTabletRecord(1L, 100L)); + ListComparator> comparator = new ListComparator<>( + new OrderByPair(8, true), + new OrderByPair(0, false)); + + List> actual = RecordPickerUtils.getQualifiedRecords( + records, comparator, Optional.of(0)); + + Assertions.assertTrue(actual.isEmpty()); + } + @Test void testMultipleOrderByColumnsWithDifferentDirections() { List> records = Arrays.asList( From b3b289f41a0733a7dbf31e9c7719cfc785a3db7d Mon Sep 17 00:00:00 2001 From: Sudharsan_K Date: Mon, 27 Jul 2026 15:28:06 +0530 Subject: [PATCH 4/4] [fix](show) apply ORDER BY to SHOW TABLETS result set --- .../plans/commands/ShowTabletsFromTableCommand.java | 13 ++++++------- .../doris/nereids/util/RecordPickerUtils.java | 8 ++++---- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java index cb10b5949be126..71f01a1f5ab3a0 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/ShowTabletsFromTableCommand.java @@ -55,8 +55,6 @@ import org.apache.doris.qe.StmtExecutor; import com.google.common.collect.Lists; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; import java.util.ArrayList; import java.util.Collection; @@ -68,7 +66,6 @@ * ShowTabletsFromTableCommand */ public class ShowTabletsFromTableCommand extends ShowCommand { - private static final Logger LOG = LogManager.getLogger(ShowTabletsFromTableCommand.class); private TableNameInfo dbTableName; private PartitionNamesInfo partitionNames; private Expression whereClause; @@ -205,9 +202,12 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc OlapTable olapTable = db.getOlapTableOrAnalysisException(dbTableName.getTbl()); olapTable.readLock(); try { - Optional sizeLimit = limit >= 0 - ? Optional.of((int) Math.min(Math.addExact(offset, limit), Integer.MAX_VALUE)) - : Optional.empty(); + Optional sizeLimit = Optional.empty(); + if (offset > 0 && limit > 0) { + sizeLimit = Optional.of((int) (offset + limit)); + } else if (limit > 0) { + sizeLimit = Optional.of((int) limit); + } Collection partitions = new ArrayList(); if (partitionNames != null) { List paNames = partitionNames.getPartitionNames(); @@ -240,7 +240,6 @@ public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exc // order by tabletId, replicaId comparator = new ListComparator<>(0, 1); } - List> orderedTableInfos = RecordPickerUtils.getQualifiedRecords(tabletInfos, comparator, sizeLimit); int resultOffset = (int) Math.min(offset, orderedTableInfos.size()); diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java index 74f2c4c8b21b57..e5f102dc4a3c09 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java +++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/util/RecordPickerUtils.java @@ -33,13 +33,13 @@ public class RecordPickerUtils { public static List> getQualifiedRecords( List> comparables, ListComparator> comparator, Optional k) { int limit = k.orElse(comparables.size()); - if (comparables.isEmpty() || limit == 0) { + if (comparables.isEmpty()) { return new ArrayList<>(); } - List> sortedRecords = new ArrayList<>(comparables); - sortedRecords.sort(comparator); - return new ArrayList<>(sortedRecords.subList(0, Math.min(limit, sortedRecords.size()))); + //Collections.sort(comparables, comparator); + comparables.sort(comparator); + return new ArrayList<>(comparables.subList(0, Math.min(limit, comparables.size()))); } }