private async Task <TryCatch> TryInitializeAsync(
            SqlQuerySpec sqlQuerySpec,
            CosmosElement requestContinuation,
            string collectionRid,
            IReadOnlyList <PartitionKeyRange> partitionKeyRanges,
            int initialPageSize,
            IReadOnlyList <OrderByColumn> orderByColumns,
            CancellationToken cancellationToken)
        {
            if (sqlQuerySpec == null)
            {
                throw new ArgumentNullException(nameof(sqlQuerySpec));
            }

            if (collectionRid == null)
            {
                throw new ArgumentNullException(nameof(collectionRid));
            }

            if (partitionKeyRanges == null)
            {
                throw new ArgumentNullException(nameof(partitionKeyRanges));
            }

            if (orderByColumns == null)
            {
                throw new ArgumentNullException(nameof(orderByColumns));
            }

            cancellationToken.ThrowIfCancellationRequested();

            if (requestContinuation == null)
            {
                // Start off all the partition key ranges with null continuation
                SqlQuerySpec rewrittenQueryForOrderBy = new SqlQuerySpec(
                    sqlQuerySpec.QueryText.Replace(oldValue: FormatPlaceHolder, newValue: True),
                    sqlQuerySpec.Parameters);
                Dictionary <PartitionKeyRange, string> partitionKeyRangeToContinuationToken = new Dictionary <PartitionKeyRange, string>();
                foreach (PartitionKeyRange partitionKeyRange in partitionKeyRanges)
                {
                    partitionKeyRangeToContinuationToken.Add(key: partitionKeyRange, value: null);
                }

                return(await base.TryInitializeAsync(
                           collectionRid,
                           initialPageSize,
                           rewrittenQueryForOrderBy,
                           partitionKeyRangeToContinuationToken,
                           deferFirstPage : false,
                           filter : null,
                           tryFilterAsync : null,
                           cancellationToken));
            }

            TryCatch <PartitionMapping <OrderByContinuationToken> > tryGetOrderByContinuationTokenMapping = TryGetOrderByContinuationTokenMapping(
                partitionKeyRanges,
                requestContinuation,
                orderByColumns.Count);

            if (!tryGetOrderByContinuationTokenMapping.Succeeded)
            {
                return(TryCatch.FromException(tryGetOrderByContinuationTokenMapping.Exception));
            }

            IReadOnlyList <CosmosElement> orderByItems = tryGetOrderByContinuationTokenMapping
                                                         .Result
                                                         .TargetPartition
                                                         .Values
                                                         .First()
                                                         .OrderByItems
                                                         .Select(x => x.Item)
                                                         .ToList();

            if (orderByItems.Count != orderByColumns.Count)
            {
                return(TryCatch.FromException(
                           new MalformedContinuationTokenException($"Order By Items from continuation token did not match the query text. Order by item count: {orderByItems.Count()} did not match column count {orderByColumns.Count()}. Continuation token: {requestContinuation}")));
            }

            ReadOnlyMemory <(OrderByColumn, CosmosElement)> columnAndItems = orderByColumns.Zip(orderByItems, (column, item) => (column, item)).ToArray();

            // For ascending order-by, left of target partition has filter expression > value,
            // right of target partition has filter expression >= value,
            // and target partition takes the previous filter from continuation (or true if no continuation)
            (string leftFilter, string targetFilter, string rightFilter) = CosmosOrderByItemQueryExecutionContext.GetFormattedFilters(columnAndItems);
            List <(IReadOnlyDictionary <PartitionKeyRange, OrderByContinuationToken>, string)> tokenMappingAndFilters = new List <(IReadOnlyDictionary <PartitionKeyRange, OrderByContinuationToken>, string)>()
            {
                { (tryGetOrderByContinuationTokenMapping.Result.PartitionsLeftOfTarget, leftFilter) },
                { (tryGetOrderByContinuationTokenMapping.Result.TargetPartition, targetFilter) },