Query: Refactors Optimistic Direct Execution to be turned on by default on .NET SDK

Microsoft.Azure.Cosmos/src/Query/Core/Pipeline/CosmosQueryExecutionContextFactory.cs

@@ -782,7 +782,7 @@ private static Documents.PartitionKeyDefinition GetPartitionKeyDefinition(InputP
             Debug.Assert(containerQueryProperties.ResourceId != null, "CosmosQueryExecutionContextFactory Assert!", "Container ResourceId cannot be null!");
 
             List<Documents.PartitionKeyRange> targetRanges;
-            if (partitionedQueryExecutionInfo != null)
+            if (partitionedQueryExecutionInfo != null || inputParameters.InitialFeedRange != null)
             {
                 targetRanges = await CosmosQueryExecutionContextFactory.GetTargetPartitionKeyRangesAsync(
                     cosmosQueryContext.QueryClient,

Microsoft.Azure.Cosmos/src/RequestOptions/QueryRequestOptions.cs

@@ -50,15 +50,7 @@ public class QueryRequestOptions : RequestOptions
         /// <value>
         /// Direct (optimistic) execution offers improved performance for several kinds of queries such as a single partition streaming query.
         /// </value>
-#if PREVIEW
-        public
-#else
-        internal
-#endif
-        bool EnableOptimisticDirectExecution { get; set; }
-#if PREVIEW 
-        = true;
-#endif
+        public bool EnableOptimisticDirectExecution { get; set; } = true;
 
         /// <summary>
         /// Gets or sets the maximum number of items that can be buffered client side during 

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosBasicQueryTests.cs

@@ -240,9 +240,7 @@ public async Task QueryRequestRateTest(bool directMode)
                     {
                         MaxItemCount = 1,
                         MaxConcurrency = 1,
-#if PREVIEW
-                        EnableOptimisticDirectExecution = false
-#endif
+                        EnableOptimisticDirectExecution = true
                     }))
                 {
                     while (feedIterator.HasMoreResults)
@@ -271,9 +269,7 @@ public async Task QueryRequestRateTest(bool directMode)
                 {
                     MaxItemCount = 1,
                     MaxConcurrency = 1,
-#if PREVIEW
-                    EnableOptimisticDirectExecution = false
-#endif
+                    EnableOptimisticDirectExecution = true
                 });
 
             // First request should be a success
@@ -818,7 +814,7 @@ public async Task TesOdeTokenCompatibilityWithNonOdePipeline()
             QueryRequestOptions newQueryRequestOptions = new QueryRequestOptions
             {
                 MaxItemCount = 50,
-                EnableOptimisticDirectExecution = false
+                EnableOptimisticDirectExecution = true
             };
 
             // use Continuation Token to create new iterator and use same trace

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosGatewayTimeoutTests.cs

@@ -83,9 +83,7 @@ public async Task QueryPlanRetryTimeoutTestAsync()
 
                 QueryRequestOptions requestOptions = new QueryRequestOptions()
                 {
-#if PREVIEW
                     EnableOptimisticDirectExecution = false
-#endif
                 };
 
                 using FeedIterator<JObject> iterator = gatewayQueryPlanContainer.GetItemQueryIterator<JObject>("select * From T order by T.status", requestOptions: requestOptions);

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosJsonSerializerTests.cs

@@ -94,48 +94,64 @@ public async Task TestQueryWithCustomJsonSerializer()
                 Assert.AreEqual(1, toStreamCount, "parameter should use custom serializer");
                 Assert.AreEqual(0, fromStreamCount);
 
-                toStreamCount = 0;
-                fromStreamCount = 0;
-
-                FeedIterator<ToDoActivity> itemIterator = container.GetItemQueryIterator<ToDoActivity>(
-                    query
-#if PREVIEW
-                    , requestOptions: new QueryRequestOptions() { EnableOptimisticDirectExecution = false }
-#endif
-                    );
-                List<ToDoActivity> items = new List<ToDoActivity>();
-                while (itemIterator.HasMoreResults)
+                foreach (bool enableODE in new bool[] { false, true })
                 {
-                    items.AddRange(await itemIterator.ReadNextAsync());
-                }
-
-                Assert.AreEqual(2, toStreamCount);
-                Assert.AreEqual(1, fromStreamCount);
-
-                toStreamCount = 0;
-                fromStreamCount = 0;
+                    toStreamCount = 0;
+                    fromStreamCount = 0;
+
+                    FeedIterator<ToDoActivity> itemIterator = container.GetItemQueryIterator<ToDoActivity>(
+                        query,
+                        requestOptions: new QueryRequestOptions() { EnableOptimisticDirectExecution = enableODE }
+                        );
+                    List<ToDoActivity> items = new List<ToDoActivity>();
+                    while (itemIterator.HasMoreResults)
+                    {
+                        items.AddRange(await itemIterator.ReadNextAsync());
+                    }
 
-                // Verify that the custom serializer is actually being used via stream
-                FeedIterator itemStreamIterator = container.GetItemQueryStreamIterator(
-                    query
-#if PREVIEW
-                    , requestOptions: new QueryRequestOptions() { EnableOptimisticDirectExecution = false }
-#endif
-                    );
-                while (itemStreamIterator.HasMoreResults)
-                {
-                    ResponseMessage response = await itemStreamIterator.ReadNextAsync();
-                    using (StreamReader reader = new StreamReader(response.Content))
+                    // The toStreamCount variable will differ between ODE and non-ODE pipelines due to the non-ODE pipelines needing to get the query plan which makes an additional serialization call during its initialization.
+                    if (enableODE)
                     {
-                        string content = await reader.ReadToEndAsync();
-                        Assert.IsTrue(content.Contains("9001.42"));
-                        Assert.IsFalse(content.Contains("description"), "Description should be ignored and not in the JSON");
+                        Assert.AreEqual(1, toStreamCount);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(2, toStreamCount);
+                    }
+
+                    Assert.AreEqual(1, fromStreamCount);
+
+                    toStreamCount = 0;
+                    fromStreamCount = 0;
+
+                    // Verify that the custom serializer is actually being used via stream
+                    FeedIterator itemStreamIterator = container.GetItemQueryStreamIterator(
+                        query,
+                        requestOptions: new QueryRequestOptions() { EnableOptimisticDirectExecution = enableODE }
+                        );
+                    while (itemStreamIterator.HasMoreResults)
+                    {
+                        ResponseMessage response = await itemStreamIterator.ReadNextAsync();
+                        using (StreamReader reader = new StreamReader(response.Content))
+                        {
+                            string content = await reader.ReadToEndAsync();
+                            Assert.IsTrue(content.Contains("9001.42"));
+                            Assert.IsFalse(content.Contains("description"), "Description should be ignored and not in the JSON");
+                        }
                     }
-                }
 
-                Assert.AreEqual(2, toStreamCount);
-                Assert.AreEqual(0, fromStreamCount);
+                    // The toStreamCount variable will differ between ODE and non-ODE pipelines due to the non-ODE pipelines needing to get the query plan which makes an additional serialization call during its initialization.
+                    if (enableODE)
+                    {
+                        Assert.AreEqual(1, toStreamCount);
+                    }
+                    else
+                    {
+                        Assert.AreEqual(2, toStreamCount);
+                    }
 
+                    Assert.AreEqual(0, fromStreamCount);
+                }
             }
             finally
             {

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosMultiHashTest.cs

@@ -447,64 +447,68 @@ public async Task MultiHashQueryItemTest()
             doc.SetValue("Type", "Goverment");
             documents[2] = await this.container.CreateItemAsync<Document>(doc);
 
-            //Query
-            foreach (Document document in documents)
+            foreach (bool odeEnabled in new bool[] { false, true })
             {
-                pKey = new PartitionKeyBuilder()
-                    .Add(document.GetPropertyValue<string>("ZipCode"))
-                    .Add(document.GetPropertyValue<string>("City"))
-                .Build();
-
-                badPKey = new PartitionKeyBuilder()
-                            .Add(document.GetPropertyValue<string>("City"))
-                            .Build();
-
-                String query = $"SELECT * from c where c.id = \"{document.GetPropertyValue<string>("id")}\"";
-
-                using (FeedIterator<Document> feedIterator = this.container.GetItemQueryIterator<Document>(
-                    query,
-                    null,
-                    new QueryRequestOptions() { PartitionKey = pKey }))
+                //Query
+                foreach (Document document in documents)
                 {
-                    Assert.IsTrue(feedIterator.HasMoreResults);
+                    pKey = new PartitionKeyBuilder()
+                        .Add(document.GetPropertyValue<string>("ZipCode"))
+                        .Add(document.GetPropertyValue<string>("City"))
+                    .Build();
 
-                    FeedResponse<Document> queryDoc = await feedIterator.ReadNextAsync();
-                    queryDoc.First<Document>();
-                    Assert.IsTrue(queryDoc.Count == 1);
-                    feedIterator.Dispose();
-                }
+                    badPKey = new PartitionKeyBuilder()
+                                .Add(document.GetPropertyValue<string>("City"))
+                                .Build();
 
-                //Using an incomplete partition key with prefix of PK path definition
-                pKey = new PartitionKeyBuilder()
-                    .Add(document.GetPropertyValue<string>("ZipCode"))
-                .Build();
-                using (FeedIterator<Document> feedIterator = this.container.GetItemQueryIterator<Document>(
-                    query,
-                    null,
-                    new QueryRequestOptions() { PartitionKey = pKey }))
-                {
-                    Assert.IsTrue(feedIterator.HasMoreResults);
+                    String query = $"SELECT * from c where c.id = \"{document.GetPropertyValue<string>("id")}\"";
 
-                    FeedResponse<Document> queryDoc = await feedIterator.ReadNextAsync();
-                    queryDoc.First<Document>();
-                    Assert.IsTrue(queryDoc.Count == 1);
-                    feedIterator.Dispose();
-                }
+                    using (FeedIterator<Document> feedIterator = this.container.GetItemQueryIterator<Document>(
+                        query,
+                        null,
+                        new QueryRequestOptions() { EnableOptimisticDirectExecution = odeEnabled, PartitionKey = pKey }))
+                    {
+                        Assert.IsTrue(feedIterator.HasMoreResults);
 
-                //Negative test - using incomplete partition key
-                using (FeedIterator<Document> badFeedIterator = this.container.GetItemQueryIterator<Document>(
-                    query,
-                    null,
-                    new QueryRequestOptions() { PartitionKey = badPKey}))
-                {
-                    FeedResponse<Document> queryDocBad = await badFeedIterator.ReadNextAsync();
-                    Assert.ThrowsException<InvalidOperationException>(() =>
-                         queryDocBad.First<Document>()
-                    );
-                    badFeedIterator.Dispose();
+                        FeedResponse<Document> queryDoc = await feedIterator.ReadNextAsync();
+                        Document retrievedDocument = queryDoc.First<Document>();
+                        Assert.IsTrue(queryDoc.Count == 1);
+                        Assert.AreEqual(document.Id, retrievedDocument.Id);
+                        feedIterator.Dispose();
+                    }
+
+                    //Using an incomplete partition key with prefix of PK path definition
+                    pKey = new PartitionKeyBuilder()
+                        .Add(document.GetPropertyValue<string>("ZipCode"))
+                    .Build();
+                    using (FeedIterator<Document> feedIterator = this.container.GetItemQueryIterator<Document>(
+                        query,
+                        null,
+                        new QueryRequestOptions() { EnableOptimisticDirectExecution = odeEnabled, PartitionKey = pKey }))
+                    {
+                        Assert.IsTrue(feedIterator.HasMoreResults);
+
+                        FeedResponse<Document> queryDoc = await feedIterator.ReadNextAsync();
+                        Document retrievedDocument = queryDoc.First<Document>();
+                        Assert.IsTrue(queryDoc.Count == 1);
+                        Assert.AreEqual(document.Id, retrievedDocument.Id);
+                        feedIterator.Dispose();
+                    }
+
+                    //Negative test - using incomplete partition key
+                    using (FeedIterator<Document> badFeedIterator = this.container.GetItemQueryIterator<Document>(
+                        query,
+                        null,
+                        new QueryRequestOptions() { EnableOptimisticDirectExecution = odeEnabled, PartitionKey = badPKey }))
+                    {
+                        FeedResponse<Document> queryDocBad = await badFeedIterator.ReadNextAsync();
+                        Assert.ThrowsException<InvalidOperationException>(() =>
+                             queryDocBad.First<Document>()
+                        );
+                        badFeedIterator.Dispose();
+                    }
                 }
             }
         }
-
     }
 }