Omitted the useless distinct logic for device when determined predicate does not contain "OR"

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/SchemaPredicateUtil.java

@@ -44,6 +44,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 
 public class SchemaPredicateUtil {
@@ -114,15 +115,20 @@ private static void separateExpression(
   // e.g. (a OR b) AND (c OR d) -> (a AND c) OR (a AND d) OR (b AND c) OR (b AND d)
   // if input is empty, then return [[]]
   static List<Map<Integer, List<SchemaFilter>>> convertDeviceIdPredicateToOrConcatList(
-      final List<Expression> schemaFilterList, final TsTable table) {
+      final List<Expression> schemaFilterList,
+      final TsTable table,
+      final AtomicBoolean mayContainDuplicateDevice) {
     final ConvertSchemaPredicateToFilterVisitor visitor =
         new ConvertSchemaPredicateToFilterVisitor();
     final ConvertSchemaPredicateToFilterVisitor.Context context =
         new ConvertSchemaPredicateToFilterVisitor.Context(table);
 
     final List<List<Expression>> orConcatList =
         schemaFilterList.stream()
-            .map(IrUtils::extractOrPredicatesWithInExpanded)
+            .map(
+                expression ->
+                    IrUtils.extractOrPredicatesWithInExpanded(
+                        expression, mayContainDuplicateDevice))
             .collect(Collectors.toList());
     final int orSize = orConcatList.size();
     int remainingCaseNum = orConcatList.stream().map(List::size).reduce(1, (a, b) -> a * b);

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/TableDeviceSchemaFetcher.java

@@ -61,6 +61,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
@@ -172,6 +173,7 @@ public List<DeviceEntry> fetchDeviceSchemaForDataQuery(
     final List<DeviceEntry> deviceEntryList = new ArrayList<>();
     final ShowDevice statement = new ShowDevice(database, table);
     final TsTable tableInstance = DataNodeTableCache.getInstance().getTable(database, table);
+    final AtomicBoolean mayContainDuplicateDevice = new AtomicBoolean(false);
     if (tableInstance == null) {
       TableMetadataImpl.throwTableNotExistsException(database, table);
     }
@@ -184,6 +186,7 @@ public List<DeviceEntry> fetchDeviceSchemaForDataQuery(
         deviceEntryList,
         attributeColumns,
         queryContext,
+        mayContainDuplicateDevice,
         false)) {
       fetchMissingDeviceSchemaForQuery(
           database, tableInstance, attributeColumns, statement, deviceEntryList, queryContext);
@@ -192,8 +195,9 @@ public List<DeviceEntry> fetchDeviceSchemaForDataQuery(
     // TODO table metadata:  implement deduplicate during schemaRegion execution
     // TODO table metadata:  need further process on input predicates and transform them into
     // disjoint sets
-    final Set<DeviceEntry> set = new LinkedHashSet<>(deviceEntryList);
-    return new ArrayList<>(set);
+    return mayContainDuplicateDevice.get()
+        ? new ArrayList<>(new LinkedHashSet<>(deviceEntryList))
+        : deviceEntryList;
   }
 
   // Used by show/count device and update device.
@@ -206,6 +210,7 @@ public boolean parseFilter4TraverseDevice(
       final List<DeviceEntry> deviceEntryList,
       final List<String> attributeColumns,
       final MPPQueryContext queryContext,
+      final AtomicBoolean mayContainDuplicateDevice,
       final boolean isDirectDeviceQuery) {
     final Pair<List<Expression>, List<Expression>> separatedExpression =
         SchemaPredicateUtil.separateIdDeterminedPredicate(
@@ -220,7 +225,7 @@ public boolean parseFilter4TraverseDevice(
     // expressions inner each element are and-concat representing conditions of different column
     final List<Map<Integer, List<SchemaFilter>>> index2FilterMapList =
         SchemaPredicateUtil.convertDeviceIdPredicateToOrConcatList(
-            idDeterminedPredicateList, tableInstance);
+            idDeterminedPredicateList, tableInstance, mayContainDuplicateDevice);
     // If List<Expression> in idPredicateList contains all id columns comparison which can use
     // SchemaCache, we store its index.
     final List<Integer> idSingleMatchIndexList =

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/planner/ir/IrUtils.java

@@ -45,6 +45,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Predicate;
 
 import static java.util.Objects.requireNonNull;
@@ -69,18 +70,22 @@ public static List<Expression> extractPredicates(LogicalExpression expression) {
 
   // Use for table device fetching
   // Expand the inPredicates to better check the in list and hit device cache
-  public static List<Expression> extractOrPredicatesWithInExpanded(final Expression expression) {
+  public static List<Expression> extractOrPredicatesWithInExpanded(
+      final Expression expression, final AtomicBoolean mayContainDuplicateDevice) {
     ImmutableList.Builder<Expression> resultBuilder = ImmutableList.builder();
-    extractOrPredicatesWithInExpanded(expression, resultBuilder);
+    extractOrPredicatesWithInExpanded(expression, resultBuilder, mayContainDuplicateDevice);
     return resultBuilder.build();
   }
 
   private static void extractOrPredicatesWithInExpanded(
-      final Expression expression, final ImmutableList.Builder<Expression> resultBuilder) {
+      final Expression expression,
+      final ImmutableList.Builder<Expression> resultBuilder,
+      final AtomicBoolean mayContainDuplicateDevice) {
     if (expression instanceof LogicalExpression) {
       if (((LogicalExpression) expression).getOperator() == LogicalExpression.Operator.OR) {
+        mayContainDuplicateDevice.set(true);
         for (final Expression term : ((LogicalExpression) expression).getTerms()) {
-          extractOrPredicatesWithInExpanded(term, resultBuilder);
+          extractOrPredicatesWithInExpanded(term, resultBuilder, mayContainDuplicateDevice);
         }
       }
     } else if (expression instanceof InPredicate) {

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/AbstractTraverseDevice.java

@@ -37,6 +37,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import static org.apache.iotdb.db.queryengine.plan.relational.sql.ast.AbstractQueryDeviceWithCache.getDeviceColumnHeaderList;
 
@@ -145,6 +146,7 @@ public boolean parseRawExpression(
             entries,
             attributeColumns,
             context,
+            new AtomicBoolean(false),
             true);
   }