Refactor to avoid computing configuration in each call.

ananth7592 · ananth7592 · commit f79ca780d7e5 · 2025-11-10T11:38:59.000-08:00
diff --git a/Microsoft.Azure.Cosmos/src/Query/Core/Pipeline/CrossPartition/HierarchicalPartitionUtils.cs b/Microsoft.Azure.Cosmos/src/Query/Core/Pipeline/CrossPartition/HierarchicalPartitionUtils.cs
@@ -7,9 +7,11 @@ namespace Microsoft.Azure.Cosmos.Query.Core.Pipeline.CrossPartition
     using System;
     using System.Collections.Generic;
     using Microsoft.Azure.Cosmos.Query.Core.QueryClient;
+    using Microsoft.Azure.Documents.Routing;
 
     internal static class HierarchicalPartitionUtils
     {
+        private static readonly bool IsLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
         /// <summary>
         /// Updates the FeedRange to limit the scope of incoming feedRange to logical partition within a single physical partition.
         /// Generally speaking, a subpartitioned container can experience split partition at any level of hierarchical partition key.
@@ -51,9 +53,7 @@ public static FeedRangeInternal LimitFeedRangeToSinglePartition(PartitionKey? pa
                                 String overlappingMax;
                                 bool maxInclusive;
 
-                                bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
-
-                                IComparer<Documents.Routing.Range<string>> minComparer = GetComparer(isMinComparer: true, useLengthAwareComparison: isLengthAwareComparisonEnabled);
+                                (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) = GetComparers(IsLengthAwareComparisonEnabled);
 
                                 if (minComparer.Compare(
                                         epkForPartitionKey,
@@ -68,8 +68,6 @@ public static FeedRangeInternal LimitFeedRangeToSinglePartition(PartitionKey? pa
                                     minInclusive = epkForPartitionKey.IsMinInclusive;
                                 }
 
-                                IComparer<Documents.Routing.Range<string>> maxComparer = GetComparer(isMinComparer: false, useLengthAwareComparison: isLengthAwareComparisonEnabled);
-
                                 if (maxComparer.Compare(
                                         epkForPartitionKey,
                                         feedRangeEpk.Range) > 0)
@@ -104,11 +102,11 @@ public static FeedRangeInternal LimitFeedRangeToSinglePartition(PartitionKey? pa
             return feedRange;
         }
 
-        private static IComparer<Documents.Routing.Range<string>> GetComparer(bool isMinComparer, bool useLengthAwareComparison)
+        private static (IComparer<Documents.Routing.Range<string>> MinComparer, IComparer<Documents.Routing.Range<string>> MaxComparer) GetComparers(bool useLengthAwareComparison)
         {
-            return isMinComparer
-                ? (useLengthAwareComparison ? Documents.Routing.Range<string>.LengthAwareMinComparer.Instance : Documents.Routing.Range<string>.MinComparer.Instance)
-                : (useLengthAwareComparison ? Documents.Routing.Range<string>.LengthAwareMaxComparer.Instance : Documents.Routing.Range<string>.MaxComparer.Instance);
+            return useLengthAwareComparison
+                ? (Documents.Routing.Range<string>.LengthAwareMinComparer.Instance, Documents.Routing.Range<string>.LengthAwareMaxComparer.Instance)
+                : (Documents.Routing.Range<string>.MinComparer.Instance, Documents.Routing.Range<string>.MaxComparer.Instance);
         }
     }
 }
diff --git a/Microsoft.Azure.Cosmos/src/Routing/CollectionRoutingMap.cs b/Microsoft.Azure.Cosmos/src/Routing/CollectionRoutingMap.cs
@@ -33,6 +33,8 @@ internal sealed class CollectionRoutingMap
 
         internal int HighestNonOfflinePkRangeId { get; private set; }
 
+        private bool isLengthAwareComparisonEnabled = false;
+
         private CollectionRoutingMap(
             Dictionary<string, Tuple<PartitionKeyRange, ServiceIdentity>> rangeById,
             List<PartitionKeyRange> orderedPartitionKeyRanges,
@@ -72,6 +74,8 @@ private CollectionRoutingMap(
                     return range.Status == PartitionKeyRangeStatus.Offline ? CollectionRoutingMap.InvalidPkRangeId : pkId;
                 });
             this.partitionKeyDefinition = partitionKeyDefinition;
+
+            this.isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
         }
 
         public static CollectionRoutingMap TryCreateCompleteRoutingMap(
@@ -129,11 +133,9 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range
 
             SortedList<string, PartitionKeyRange> partitionRanges = new SortedList<string, PartitionKeyRange>();
 
-            bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
-
             bool useLengthAwareComparison = false;
             // Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).
-            if (isLengthAwareComparisonEnabled && this.partitionKeyDefinition != null && this.partitionKeyDefinition.Kind == PartitionKind.MultiHash && this.partitionKeyDefinition.Paths.Count > 1)
+            if (this.isLengthAwareComparisonEnabled && this.partitionKeyDefinition != null && this.partitionKeyDefinition.Kind == PartitionKind.MultiHash && this.partitionKeyDefinition.Paths.Count > 1)
             {
                 useLengthAwareComparison = true;
             }
@@ -142,15 +144,13 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range
             // Then within that two positions, check for overlapping partition key ranges
             foreach (Range<string> providedRange in providedPartitionKeyRanges)
             {
-                IComparer<Range<string>> minComparer = this.GetComparer(isMinComparer: true, useLengthAwareComparison: useLengthAwareComparison);
+                (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) = this.GetComparers(useLengthAwareComparison);
                 int minIndex = this.orderedRanges.BinarySearch(providedRange, minComparer);
                 if (minIndex < 0)
                 {
                     minIndex = Math.Max(0, (~minIndex) - 1);
                 }
 
-                IComparer<Range<string>> maxComparer = this.GetComparer(isMinComparer: false, useLengthAwareComparison: useLengthAwareComparison);
-
                 int maxIndex = this.orderedRanges.BinarySearch(providedRange, maxComparer);
                 if (maxIndex < 0)
                 {
@@ -169,11 +169,11 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range
             return new ReadOnlyCollection<PartitionKeyRange>(partitionRanges.Values);
         }
 
-        private IComparer<Range<string>> GetComparer(bool isMinComparer, bool useLengthAwareComparison)
+        private (IComparer<Range<string>> MinComparer, IComparer<Range<string>> MaxComparer) GetComparers(bool useLengthAwareComparison)
         {
-            return isMinComparer
-                ? (useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance)
-                : (useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance);
+            return useLengthAwareComparison
+                ? (Range<string>.LengthAwareMinComparer.Instance, Range<string>.LengthAwareMaxComparer.Instance)
+                : (Range<string>.MinComparer.Instance, Range<string>.MaxComparer.Instance);
         }
 
         public PartitionKeyRange GetRangeByEffectivePartitionKey(string effectivePartitionKeyValue)
diff --git a/Microsoft.Azure.Cosmos/src/Routing/PartitionRoutingHelper.cs b/Microsoft.Azure.Cosmos/src/Routing/PartitionRoutingHelper.cs
@@ -24,6 +24,7 @@ namespace Microsoft.Azure.Cosmos.Routing
 
     internal class PartitionRoutingHelper
     {
+        private static readonly bool IsLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
         public static IReadOnlyList<Range<string>> GetProvidedPartitionKeyRanges(
             string querySpecJsonString,
             bool enableCrossPartitionQuery,
@@ -233,15 +234,14 @@ await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(
                     return new ResolvedRangeInfo(lastPartitionKeyRange, suppliedTokens);
                 }
 
-                bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
                 bool useLengthAwareComparison = false;
                 // Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).
-                if (isLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)
+                if (IsLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)
                 {
                     useLengthAwareComparison = true;
                 }
 
-                IComparer<Range<string>> minComparer = this.GetComparer(isMinComparer: true, useLengthAwareComparison);
+                (IComparer<Range<string>> minComparer, _) = this.GetComparers(useLengthAwareComparison);
 
                 Range<string> minimumRange = PartitionRoutingHelper.Min(
                 providedPartitionKeyRanges,
@@ -362,13 +362,13 @@ public virtual async Task<bool> TryAddPartitionKeyRangeToContinuationTokenAsync(
                 // We only need to get the next range if we have to
                 if (string.IsNullOrEmpty(backendResponseHeaders[HttpConstants.HttpHeaders.Continuation]))
                 {
-                    bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();
                     bool useLengthAwareComparison = false;
                     // Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).
-                    if (isLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)
+                    if (IsLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)
                     {
                         useLengthAwareComparison = true;
                     }
+                    (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) = this.GetComparers(useLengthAwareComparison);
 
                     if (direction == RntdbEnumerationDirection.Reverse)
                     {
@@ -379,14 +379,14 @@ public virtual async Task<bool> TryAddPartitionKeyRangeToContinuationTokenAsync(
                                 trace, partitionKeyDefinition,
                                 false)).ToList(),
                             currentRange,
-                            this.GetComparer(isMinComparer: true, useLengthAwareComparison: useLengthAwareComparison));
+                            minComparer);
                     }
                     else
                     {
                         Range<string> nextProvidedRange = PartitionRoutingHelper.MinAfter(
                         providedPartitionKeyRanges,
                         currentRange.ToRange(),
-                        this.GetComparer(isMinComparer: false, useLengthAwareComparison: useLengthAwareComparison));
+                        maxComparer);
 
                         if (nextProvidedRange == null)
                         {
@@ -592,11 +592,12 @@ private static PartitionKeyRange MinBefore(IReadOnlyList<PartitionKeyRange> valu
             return min;
         }
 
-        private IComparer<Range<string>> GetComparer(bool isMinComparer, bool useLengthAwareComparison)
+        private (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) GetComparers(bool useLengthAwareComparison)
         {
-            return isMinComparer
-                ? (useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance)
-                : (useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance);
+            return (
+                useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance,
+                useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance
+            );
         }
 
         public readonly struct ResolvedRangeInfo

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,8 @@ internal sealed class CollectionRoutingMap`
`33`	`33`
`34`	`34`	`internal int HighestNonOfflinePkRangeId { get; private set; }`
`35`	`35`
	`36`	`+ private bool isLengthAwareComparisonEnabled = false;`
	`37`	`+`
`36`	`38`	`private CollectionRoutingMap(`
`37`	`39`	`Dictionary<string, Tuple<PartitionKeyRange, ServiceIdentity>> rangeById,`
`38`	`40`	`List<PartitionKeyRange> orderedPartitionKeyRanges,`
`@@ -72,6 +74,8 @@ private CollectionRoutingMap(`
`72`	`74`	`return range.Status == PartitionKeyRangeStatus.Offline ? CollectionRoutingMap.InvalidPkRangeId : pkId;`
`73`	`75`	`});`
`74`	`76`	`this.partitionKeyDefinition = partitionKeyDefinition;`
	`77`	`+`
	`78`	`+ this.isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();`
`75`	`79`	`}`
`76`	`80`
`77`	`81`	`public static CollectionRoutingMap TryCreateCompleteRoutingMap(`
`@@ -129,11 +133,9 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range`
`129`	`133`
`130`	`134`	`SortedList<string, PartitionKeyRange> partitionRanges = new SortedList<string, PartitionKeyRange>();`
`131`	`135`
`132`		`- bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();`
`133`		`-`
`134`	`136`	`bool useLengthAwareComparison = false;`
`135`	`137`	`// Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).`
`136`		`- if (isLengthAwareComparisonEnabled && this.partitionKeyDefinition != null && this.partitionKeyDefinition.Kind == PartitionKind.MultiHash && this.partitionKeyDefinition.Paths.Count > 1)`
	`138`	`+ if (this.isLengthAwareComparisonEnabled && this.partitionKeyDefinition != null && this.partitionKeyDefinition.Kind == PartitionKind.MultiHash && this.partitionKeyDefinition.Paths.Count > 1)`
`137`	`139`	`{`
`138`	`140`	`useLengthAwareComparison = true;`
`139`	`141`	`}`
`@@ -142,15 +144,13 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range`
`142`	`144`	`// Then within that two positions, check for overlapping partition key ranges`
`143`	`145`	`foreach (Range<string> providedRange in providedPartitionKeyRanges)`
`144`	`146`	`{`
`145`		`- IComparer<Range<string>> minComparer = this.GetComparer(isMinComparer: true, useLengthAwareComparison: useLengthAwareComparison);`
	`147`	`+ (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) = this.GetComparers(useLengthAwareComparison);`
`146`	`148`	`int minIndex = this.orderedRanges.BinarySearch(providedRange, minComparer);`
`147`	`149`	`if (minIndex < 0)`
`148`	`150`	`{`
`149`	`151`	`minIndex = Math.Max(0, (~minIndex) - 1);`
`150`	`152`	`}`
`151`	`153`
`152`		`- IComparer<Range<string>> maxComparer = this.GetComparer(isMinComparer: false, useLengthAwareComparison: useLengthAwareComparison);`
`153`		`-`
`154`	`154`	`int maxIndex = this.orderedRanges.BinarySearch(providedRange, maxComparer);`
`155`	`155`	`if (maxIndex < 0)`
`156`	`156`	`{`
`@@ -169,11 +169,11 @@ public IReadOnlyList<PartitionKeyRange> GetOverlappingRanges(IReadOnlyList<Range`
`169`	`169`	`return new ReadOnlyCollection<PartitionKeyRange>(partitionRanges.Values);`
`170`	`170`	`}`
`171`	`171`
`172`		`- private IComparer<Range<string>> GetComparer(bool isMinComparer, bool useLengthAwareComparison)`
	`172`	`+ private (IComparer<Range<string>> MinComparer, IComparer<Range<string>> MaxComparer) GetComparers(bool useLengthAwareComparison)`
`173`	`173`	`{`
`174`		`- return isMinComparer`
`175`		`- ? (useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance)`
`176`		`- : (useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance);`
	`174`	`+ return useLengthAwareComparison`
	`175`	`+ ? (Range<string>.LengthAwareMinComparer.Instance, Range<string>.LengthAwareMaxComparer.Instance)`
	`176`	`+ : (Range<string>.MinComparer.Instance, Range<string>.MaxComparer.Instance);`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`public PartitionKeyRange GetRangeByEffectivePartitionKey(string effectivePartitionKeyValue)`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ namespace Microsoft.Azure.Cosmos.Routing`
`24`	`24`
`25`	`25`	`internal class PartitionRoutingHelper`
`26`	`26`	`{`
	`27`	`+ private static readonly bool IsLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();`
`27`	`28`	`public static IReadOnlyList<Range<string>> GetProvidedPartitionKeyRanges(`
`28`	`29`	`string querySpecJsonString,`
`29`	`30`	`bool enableCrossPartitionQuery,`
`@@ -233,15 +234,14 @@ await routingMapProvider.TryGetRangeByEffectivePartitionKeyAsync(`
`233`	`234`	`return new ResolvedRangeInfo(lastPartitionKeyRange, suppliedTokens);`
`234`	`235`	`}`
`235`	`236`
`236`		`- bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();`
`237`	`237`	`bool useLengthAwareComparison = false;`
`238`	`238`	`// Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).`
`239`		`- if (isLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)`
	`239`	`+ if (IsLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)`
`240`	`240`	`{`
`241`	`241`	`useLengthAwareComparison = true;`
`242`	`242`	`}`
`243`	`243`
`244`		`- IComparer<Range<string>> minComparer = this.GetComparer(isMinComparer: true, useLengthAwareComparison);`
	`244`	`+ (IComparer<Range<string>> minComparer, _) = this.GetComparers(useLengthAwareComparison);`
`245`	`245`
`246`	`246`	`Range<string> minimumRange = PartitionRoutingHelper.Min(`
`247`	`247`	`providedPartitionKeyRanges,`
`@@ -362,13 +362,13 @@ public virtual async Task<bool> TryAddPartitionKeyRangeToContinuationTokenAsync(`
`362`	`362`	`// We only need to get the next range if we have to`
`363`	`363`	`if (string.IsNullOrEmpty(backendResponseHeaders[HttpConstants.HttpHeaders.Continuation]))`
`364`	`364`	`{`
`365`		`- bool isLengthAwareComparisonEnabled = ConfigurationManager.IsLengthAwareRangeComparatorEnabled();`
`366`	`365`	`bool useLengthAwareComparison = false;`
`367`	`366`	`// Enable length-aware comparison for provided partition EPK ranges only when the container uses a hierarchical partition key (MultiHash).`
`368`		`- if (isLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)`
	`367`	`+ if (IsLengthAwareComparisonEnabled && partitionKeyDefinition != null && partitionKeyDefinition.Kind == PartitionKind.MultiHash && partitionKeyDefinition.Paths.Count > 1)`
`369`	`368`	`{`
`370`	`369`	`useLengthAwareComparison = true;`
`371`	`370`	`}`
	`371`	`+ (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) = this.GetComparers(useLengthAwareComparison);`
`372`	`372`
`373`	`373`	`if (direction == RntdbEnumerationDirection.Reverse)`
`374`	`374`	`{`
`@@ -379,14 +379,14 @@ public virtual async Task<bool> TryAddPartitionKeyRangeToContinuationTokenAsync(`
`379`	`379`	`trace, partitionKeyDefinition,`
`380`	`380`	`false)).ToList(),`
`381`	`381`	`currentRange,`
`382`		`- this.GetComparer(isMinComparer: true, useLengthAwareComparison: useLengthAwareComparison));`
	`382`	`+ minComparer);`
`383`	`383`	`}`
`384`	`384`	`else`
`385`	`385`	`{`
`386`	`386`	`Range<string> nextProvidedRange = PartitionRoutingHelper.MinAfter(`
`387`	`387`	`providedPartitionKeyRanges,`
`388`	`388`	`currentRange.ToRange(),`
`389`		`- this.GetComparer(isMinComparer: false, useLengthAwareComparison: useLengthAwareComparison));`
	`389`	`+ maxComparer);`
`390`	`390`
`391`	`391`	`if (nextProvidedRange == null)`
`392`	`392`	`{`
`@@ -592,11 +592,12 @@ private static PartitionKeyRange MinBefore(IReadOnlyList<PartitionKeyRange> valu`
`592`	`592`	`return min;`
`593`	`593`	`}`
`594`	`594`
`595`		`- private IComparer<Range<string>> GetComparer(bool isMinComparer, bool useLengthAwareComparison)`
	`595`	`+ private (IComparer<Range<string>> minComparer, IComparer<Range<string>> maxComparer) GetComparers(bool useLengthAwareComparison)`
`596`	`596`	`{`
`597`		`- return isMinComparer`
`598`		`- ? (useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance)`
`599`		`- : (useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance);`
	`597`	`+ return (`
	`598`	`+ useLengthAwareComparison ? Range<string>.LengthAwareMinComparer.Instance : Range<string>.MinComparer.Instance,`
	`599`	`+ useLengthAwareComparison ? Range<string>.LengthAwareMaxComparer.Instance : Range<string>.MaxComparer.Instance`
	`600`	`+ );`
`600`	`601`	`}`
`601`	`602`
`602`	`603`	`public readonly struct ResolvedRangeInfo`