Azure · jeet1995 · Jul 9, 2026 · Jan 20, 2026 · Jan 21, 2026 · Jan 23, 2026
diff --git a/sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/implementation/JsonSerializable.java b/sdk/cosmos/azure-cosmos/src/main/java/com/azure/cosmos/implementation/JsonSerializable.java
@@ -219,6 +219,27 @@ public <T> Map<String, T> getMap(String propertyKey) {
         return null;
     }
 
+    /**
+     * Gets a map value with empty string values converted to null.
+     * This is useful for handling JSON responses where empty strings are used instead of null.
+     *
+     * @param <T> the type of the map values.
+     * @param propertyKey the property to get.
+     * @return the map with empty string values converted to null.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> Map<String, T> getMapWithEmptyStringAsNull(String propertyKey) {
+        if (this.propertyBag.has(propertyKey)) {
+            Object value = this.get(propertyKey);
+            Map<String, T> map = (Map<String, T>) OBJECT_MAPPER.convertValue(value, HashMap.class);
+            if (map != null) {
+                map.replaceAll((k, v) -> (v instanceof String && ((String) v).isEmpty()) ? null : v);
+            }
+            return map;
+        }
+        return null;
+    }
+
     /**
      * Checks whether a property exists.
      *

@@ -4682,6 +4682,11 @@ public GlobalEndpointManager getGlobalEndpointManager() {
             public GlobalPartitionEndpointManagerForPerPartitionCircuitBreaker getGlobalPartitionEndpointManagerForCircuitBreaker() {
                 return RxDocumentClientImpl.this.globalPartitionEndpointManagerForPerPartitionCircuitBreaker;
             }
+
+            @Override
+            public boolean useThinClient(RxDocumentServiceRequest request) {
+                return RxDocumentClientImpl.this.useThinClientStoreModel(request);
+            }
         };
     }
 
@@ -6451,7 +6456,8 @@ private RxStoreModel getStoreProxy(RxDocumentServiceRequest request) {
             resourceType == ResourceType.ClientEncryptionKey ||
             resourceType.isScript() && operationType != OperationType.ExecuteJavaScript ||
             resourceType == ResourceType.PartitionKeyRange ||
-            resourceType == ResourceType.PartitionKey && operationType == OperationType.Delete) {
+            resourceType == ResourceType.PartitionKey && operationType == OperationType.Delete ||
+            operationType == OperationType.QueryPlan) {
             return this.gatewayProxy;
         }
 
@@ -6489,7 +6495,7 @@ private RxStoreModel getStoreProxy(RxDocumentServiceRequest request) {
             if ((operationType == OperationType.Query ||
                 operationType == OperationType.SqlQuery ||
                 operationType == OperationType.ReadFeed) &&
-                    Utils.isCollectionChild(request.getResourceType())) {
+                Utils.isCollectionChild(request.getResourceType())) {
                 // Go to gateway only when partition key range and partition key are not set. This should be very rare
                 if (request.getPartitionKeyRangeIdentity() == null &&
                         request.getHeaders().get(HttpConstants.HttpHeaders.PARTITION_KEY) == null) {
@@ -8009,7 +8015,7 @@ public boolean useThinClient() {
     private boolean useThinClientStoreModel(RxDocumentServiceRequest request) {
         if (!useThinClient
             || !this.globalEndpointManager.hasThinClientReadLocations()
-            || request.getResourceType() != ResourceType.Document) {
+            || request.getResourceType() != ResourceType.Document && !request.isExecuteStoredProcedureBasedRequest()) {
 
             return false;
         }
@@ -8019,7 +8025,9 @@ private boolean useThinClientStoreModel(RxDocumentServiceRequest request) {
         return operationType.isPointOperation()
                     || operationType == OperationType.Query
                     || operationType == OperationType.Batch
-                    || request.isChangeFeedRequest() && !request.isAllVersionsAndDeletesChangeFeedMode();
+                    || request.isChangeFeedRequest() && !request.isAllVersionsAndDeletesChangeFeedMode()
+                    || request.isExecuteStoredProcedureBasedRequest()
+                    || operationType == OperationType.QueryPlan;
     }
 
     private DocumentClientRetryPolicy getRetryPolicyForPointOperation(

@@ -955,6 +955,10 @@ public boolean isChangeFeedRequest() {
         return this.headers.containsKey(HttpConstants.HttpHeaders.A_IM);
     }
 
+    public boolean isExecuteStoredProcedureBasedRequest() {
+        return this.resourceType == ResourceType.StoredProcedure && this.operationType == OperationType.ExecuteJavaScript;
+    }
+
     public boolean isAllVersionsAndDeletesChangeFeedMode() {
         String aImHeader = this.headers.get(HttpConstants.HttpHeaders.A_IM);
         return this.headers.containsKey(HttpConstants.HttpHeaders.A_IM) && HttpConstants.A_IMHeaderValues.FULL_FIDELITY_FEED.equals(aImHeader);

@@ -201,10 +201,13 @@ public HttpRequest wrapInHttpRequest(RxDocumentServiceRequest request, URI reque
             byte[] epk = partitionKey.getEffectivePartitionKeyBytes(request.getPartitionKeyInternal(), request.getPartitionKeyDefinition());
             rntbdRequest.setHeaderValue(RntbdConstants.RntbdRequestHeader.EffectivePartitionKey, epk);
         } else if (request.requestContext.resolvedPartitionKeyRange == null) {
-            throw new IllegalStateException(
-                "Resolved partition key range should not be null at this point. ResourceType: "
-                + request.getResourceType() + ", OperationType: "
-                + request.getOperationType());
+
+            if (!(request.getOperationType() == OperationType.QueryPlan)) {
+                throw new IllegalStateException(
+                    "Resolved partition key range should not be null at this point. ResourceType: "
+                        + request.getResourceType() + ", OperationType: "
+                        + request.getOperationType());
+            }
         } else {
             PartitionKeyRange pkRange = request.requestContext.resolvedPartitionKeyRange;
             rntbdRequest.setHeaderValue(RntbdConstants.RntbdRequestHeader.StartEpkHash, HexConvert.hexToBytes(pkRange.getMinInclusive()));

@@ -265,7 +265,8 @@ public enum RntbdOperationType {
         PreReplaceValidation((short) 0x0020, OperationType.PreReplaceValidation),
         AddComputeGatewayRequestCharges((short) 0x0021, OperationType.AddComputeGatewayRequestCharges),
         MigratePartition((short) 0x0022, OperationType.MigratePartition),
-        Batch((short) 0x0025, OperationType.Batch);
+        Batch((short) 0x0025, OperationType.Batch),
+        QueryPlan((short) 0x0042, OperationType.QueryPlan);
 
         private final short id;
         private final OperationType type;

@@ -204,6 +204,8 @@ private static RntbdOperationType map(final OperationType operationType) {
                 return RntbdOperationType.AddComputeGatewayRequestCharges;
             case Batch:
                 return RntbdOperationType.Batch;
+            case QueryPlan:
+                return RntbdOperationType.QueryPlan;
             default:
                 final String reason = String.format("Unrecognized operation type: %s", operationType);
                 throw new UnsupportedOperationException(reason);

@@ -146,7 +146,8 @@ private static <T> Mono<PartitionKeyRangesAndQueryInfos> getPartitionKeyRangesAn
                 client,
                 query,
                 resourceLink,
-                cosmosQueryRequestOptions);
+                cosmosQueryRequestOptions,
+                collection);
 
         return queryExecutionInfoMono.flatMap(
             partitionedQueryExecutionInfo -> {

@@ -110,4 +110,6 @@ Mono<RxDocumentServiceRequest> addPartitionLevelUnavailableRegionsOnRequest(
     GlobalEndpointManager getGlobalEndpointManager();
 
     GlobalPartitionEndpointManagerForPerPartitionCircuitBreaker getGlobalPartitionEndpointManagerForCircuitBreaker();
+
+    boolean useThinClient(RxDocumentServiceRequest request);
 }
@@ -4,12 +4,19 @@
 package com.azure.cosmos.implementation.query;
 
 import com.azure.cosmos.implementation.RequestTimeline;
+import com.azure.cosmos.implementation.Utils;
 import com.azure.cosmos.implementation.query.hybridsearch.HybridSearchQueryInfo;
+import com.azure.cosmos.implementation.routing.PartitionKeyInternal;
+import com.azure.cosmos.implementation.routing.PartitionKeyInternalHelper;
 import com.azure.cosmos.implementation.routing.Range;
 import com.azure.cosmos.implementation.JsonSerializable;
 import com.azure.cosmos.implementation.Constants;
+import com.azure.cosmos.models.PartitionKeyDefinition;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -24,10 +31,14 @@ public final class PartitionedQueryExecutionInfo extends JsonSerializable {
     private List<Range<String>> queryRanges;
     private RequestTimeline queryPlanRequestTimeline;
     private HybridSearchQueryInfo hybridSearchQueryInfo;
+    private final boolean useThinClientMode;
+    private final PartitionKeyDefinition partitionKeyDefinition;
 
     PartitionedQueryExecutionInfo(QueryInfo queryInfo, List<Range<String>> queryRanges) {
         this.queryInfo = queryInfo;
         this.queryRanges = queryRanges;
+        this.useThinClientMode = false;
+        this.partitionKeyDefinition = null;
 
         this.set(
             PartitionedQueryExecutionInfoInternal.PARTITIONED_QUERY_EXECUTION_INFO_VERSION_PROPERTY,
@@ -38,10 +49,21 @@ public final class PartitionedQueryExecutionInfo extends JsonSerializable {
     public PartitionedQueryExecutionInfo(ObjectNode content, RequestTimeline queryPlanRequestTimeline) {
         super(content);
         this.queryPlanRequestTimeline = queryPlanRequestTimeline;
+        this.useThinClientMode = false;
+        this.partitionKeyDefinition = null;
+    }
+
+    public PartitionedQueryExecutionInfo(ObjectNode content, RequestTimeline queryPlanRequestTimeline, boolean useThinClientMode, PartitionKeyDefinition partitionKeyDefinition) {
+        super(content);
+        this.queryPlanRequestTimeline = queryPlanRequestTimeline;
+        this.useThinClientMode = useThinClientMode;
+        this.partitionKeyDefinition = partitionKeyDefinition;
     }
 
     public PartitionedQueryExecutionInfo(String jsonString) {
         super(jsonString);
+        this.useThinClientMode = false;
+        this.partitionKeyDefinition = null;
     }
 
     public int getVersion() {
@@ -55,9 +77,90 @@ public QueryInfo getQueryInfo() {
     }
 
     public List<Range<String>> getQueryRanges() {
-        return this.queryRanges != null ? this.queryRanges
-                : (this.queryRanges = super.getList(
-                        PartitionedQueryExecutionInfoInternal.QUERY_RANGES_PROPERTY, QUERY_RANGES_CLASS));
+        if (this.queryRanges != null) {
+            return this.queryRanges;
+        }
+
+        if (this.useThinClientMode) {
+            // In thin client mode, the proxy returns queryRanges in PartitionKeyInternal array format
+            // (e.g., {"min": [[""]], "max": [["Infinity"]]}) which needs to be converted to EPK hex strings.
+            // We need to manually parse this since the generic Range<T> deserialization doesn't handle
+            // PartitionKeyInternal properly (it keeps the raw ArrayNode).
+            this.queryRanges = parseQueryRangesForThinClient();
+        } else {
+            // In non-thin client mode, the Gateway returns queryRanges directly as EPK hex strings
+            this.queryRanges = super.getList(
+                PartitionedQueryExecutionInfoInternal.QUERY_RANGES_PROPERTY, QUERY_RANGES_CLASS);
+        }
+
+        return this.queryRanges;
+    }
+
+    /**
+     * Parses the queryRanges JSON array for thin client mode.
+     * The thin client proxy returns ranges in the format:
+     * [{"min": [[""]], "max": [["Infinity"]], "isMinInclusive": true, "isMaxInclusive": false}]
+     * where min/max are PartitionKeyInternal JSON representations that need to be converted to EPK strings.
+     *
+     * @return List of ranges with EPK hex string min/max values
+     */
+    private List<Range<String>> parseQueryRangesForThinClient() {
+        ObjectNode propertyBag = this.getPropertyBag();
+        JsonNode queryRangesNode = propertyBag.get(PartitionedQueryExecutionInfoInternal.QUERY_RANGES_PROPERTY);
+
+        if (queryRangesNode == null || !queryRangesNode.isArray()) {
+            return null;
+        }
+
+        ArrayNode rangesArray = (ArrayNode) queryRangesNode;
+        List<Range<String>> epkRanges = new ArrayList<>(rangesArray.size());
+
+        for (JsonNode rangeNode : rangesArray) {
+            if (!rangeNode.isObject()) {
+                continue;
+            }
+
+            ObjectNode rangeObject = (ObjectNode) rangeNode;
+
+            // Parse min and max as PartitionKeyInternal
+            JsonNode minNode = rangeObject.get("min");
+            JsonNode maxNode = rangeObject.get("max");
+
+            PartitionKeyInternal minPk = parsePartitionKeyInternal(minNode);
+            PartitionKeyInternal maxPk = parsePartitionKeyInternal(maxNode);
+
+            // Convert to EPK strings
+            String minEpk = PartitionKeyInternalHelper.getEffectivePartitionKeyString(minPk, this.partitionKeyDefinition);
+            String maxEpk = PartitionKeyInternalHelper.getEffectivePartitionKeyString(maxPk, this.partitionKeyDefinition);
+
+            // Parse isMinInclusive and isMaxInclusive (defaults: min=true, max=false)
+            boolean isMinInclusive = !rangeObject.has("isMinInclusive") || rangeObject.get("isMinInclusive").asBoolean(true);
+            boolean isMaxInclusive = rangeObject.has("isMaxInclusive") && rangeObject.get("isMaxInclusive").asBoolean(false);
+
+            epkRanges.add(new Range<>(minEpk, maxEpk, isMinInclusive, isMaxInclusive));
+        }
+
+        return epkRanges;
+    }
+
+    /**
+     * Parses a JSON node representing a PartitionKeyInternal.
+     * Handles formats like [[""]] (empty), [["Infinity"]] (infinity), or actual partition key values.
+     *
+     * @param node The JSON node to parse
+     * @return The parsed PartitionKeyInternal
+     */
+    private PartitionKeyInternal parsePartitionKeyInternal(JsonNode node) {
+        if (node == null || node.isNull()) {
+            return PartitionKeyInternal.EmptyPartitionKey;
+        }
+
+        try {
+            // Use Jackson to deserialize using PartitionKeyInternal's custom deserializer
+            return Utils.getSimpleObjectMapper().treeToValue(node, PartitionKeyInternal.class);
+        } catch (Exception e) {
+            throw new IllegalStateException("Failed to parse PartitionKeyInternal from JSON: " + node, e);
+        }
     }
 
     public RequestTimeline getQueryPlanRequestTimeline() {

@@ -168,7 +168,9 @@ public boolean hasNonStreamingOrderBy() {
 
     public Map<String, AggregateOperator> getGroupByAliasToAggregateType(){
             Map<String, AggregateOperator>  groupByAliasToAggregateMap;
-            groupByAliasToAggregateMap = super.getMap("groupByAliasToAggregateType");
+            // Use getMapWithEmptyStringAsNull to handle thin client responses where
+            // empty strings are returned instead of null values
+            groupByAliasToAggregateMap = super.getMapWithEmptyStringAsNull("groupByAliasToAggregateType");
             return groupByAliasToAggregateMap;
     }
 

@@ -8,13 +8,15 @@
 import com.azure.cosmos.CosmosException;
 import com.azure.cosmos.implementation.Configs;
 import com.azure.cosmos.implementation.DiagnosticsClientContext;
+import com.azure.cosmos.implementation.DocumentCollection;
 import com.azure.cosmos.implementation.ImplementationBridgeHelpers;
 import com.azure.cosmos.implementation.PathsHelper;
 import com.azure.cosmos.implementation.Utils;
 import com.azure.cosmos.implementation.routing.PartitionKeyInternal;
 import com.azure.cosmos.models.CosmosQueryRequestOptions;
 import com.azure.cosmos.models.ModelBridgeInternal;
 import com.azure.cosmos.models.PartitionKey;
+import com.azure.cosmos.models.PartitionKeyDefinition;
 import com.azure.cosmos.models.SqlQuerySpec;
 import com.azure.cosmos.implementation.BackoffRetryUtility;
 import com.azure.cosmos.implementation.DocumentClientRetryPolicy;
@@ -78,14 +80,17 @@ static Mono<PartitionedQueryExecutionInfo> getQueryPlanThroughGatewayAsync(Diagn
                                                                                IDocumentQueryClient queryClient,
                                                                                SqlQuerySpec sqlQuerySpec,
                                                                                String resourceLink,
-                                                                               CosmosQueryRequestOptions initialQueryRequestOptions) {
+                                                                               CosmosQueryRequestOptions initialQueryRequestOptions,
+                                                                               DocumentCollection collection) {
 
         CosmosQueryRequestOptions nonNullRequestOptions = initialQueryRequestOptions != null
             ? initialQueryRequestOptions
             : new CosmosQueryRequestOptions();
 
         PartitionKey partitionKey = nonNullRequestOptions.getPartitionKey();
 
+        PartitionKeyDefinition partitionKeyDefinition = collection != null ? collection.getPartitionKey() : null;
+
 
         final Map<String, String> requestHeaders = new HashMap<>();
         requestHeaders.put(HttpConstants.HttpHeaders.CONTENT_TYPE, RuntimeConstants.MediaTypes.JSON);
@@ -104,7 +109,9 @@ static Mono<PartitionedQueryExecutionInfo> getQueryPlanThroughGatewayAsync(Diagn
                                                                                  ResourceType.Document,
                                                                                  resourceLink,
                                                                                  requestHeaders);
-        queryPlanRequest.useGatewayMode = true;
+
+        // queryPlanRequest.useGatewayMode = true;
+
         queryPlanRequest.setByteBuffer(ModelBridgeInternal.serializeJsonToByteBuffer(sqlQuerySpec));
 
         CosmosEndToEndOperationLatencyPolicyConfig end2EndConfig = qryOptAccessor
@@ -133,7 +140,9 @@ static Mono<PartitionedQueryExecutionInfo> getQueryPlanThroughGatewayAsync(Diagn
                         PartitionedQueryExecutionInfo partitionedQueryExecutionInfo =
                             new PartitionedQueryExecutionInfo(
                                 (ObjectNode) rxDocumentServiceResponse.getResponseBody(),
-                                rxDocumentServiceResponse.getGatewayHttpRequestTimeline());
+                                rxDocumentServiceResponse.getGatewayHttpRequestTimeline(),
+                                queryClient.useThinClient(queryPlanRequest),
+                                partitionKeyDefinition);
                         return Mono.just(partitionedQueryExecutionInfo);
                     });
                 }, retryPolicyInstance);

diff --git a/...ure-cosmos/src/main/java/com/azure/cosmos/implementation/query/SingleGroupAggregator.java b/...ure-cosmos/src/main/java/com/azure/cosmos/implementation/query/SingleGroupAggregator.java
@@ -152,6 +152,7 @@ public static SingleGroupAggregator create(
             for (Map.Entry<String, AggregateOperator> aliasToAggregate : aggregateAliasToAggregateType.entrySet()) {
                 String alias = aliasToAggregate.getKey();
                 AggregateOperator aggregateOperator = null;
+                Object aliasAggregateOperator = aliasToAggregate.getValue();
                 if (aliasToAggregate.getValue() != null) {
                     aggregateOperator = AggregateOperator.valueOf(String.valueOf(aliasToAggregate.getValue()));
                 }