Mapper: use Cql AutoPage property CSHARP-269

datastax · Mar 26, 2015 · 93a1304 · 93a1304
1 parent a299263
commit 93a1304
Show file tree

Hide file tree

Showing 6 changed files with 91 additions and 10 deletions.
diff --git a/src/Cassandra.Tests/Mapping/FetchTests.cs b/src/Cassandra.Tests/Mapping/FetchTests.cs
@@ -188,6 +188,33 @@ public void Fetch_Lazily_Pages()
             Assert.AreEqual(pageSize * totalPages, allSongs.Count);
         }
 
+        [Test]
+        public void FetchPageAsync_Pocos_Uses_Defaults()
+        {
+            var rs = TestDataHelper.GetUsersRowSet(TestDataHelper.GetUserList());
+            rs.AutoPage = false;
+            rs.PagingState = new byte[] { 1, 2, 3 };
+            BoundStatement stmt = null;
+            var sessionMock = new Mock<ISession>(MockBehavior.Strict);
+            sessionMock
+                .Setup(s => s.ExecuteAsync(It.IsAny<BoundStatement>()))
+                .Callback<IStatement>(s => stmt = (BoundStatement)s)
+                .Returns(() => TestHelper.DelayedTask(rs))
+                .Verifiable();
+            sessionMock
+                .Setup(s => s.PrepareAsync(It.IsAny<string>()))
+                .Returns(TaskHelper.ToTask(GetPrepared()))
+                .Verifiable();
+            var mappingClient = GetMappingClient(sessionMock);
+            IPage<PlainUser> page = mappingClient.FetchPageAsync<PlainUser>(Cql.New("SELECT * FROM users")).Result;
+            Assert.Null(page.CurrentPagingState);
+            Assert.NotNull(page.PagingState);
+            Assert.AreEqual(rs.PagingState, page.PagingState);
+            sessionMock.Verify();
+            Assert.False(stmt.AutoPage);
+            Assert.AreEqual(0, stmt.PageSize);
+        }
+
         [Test]
         public void FetchPageAsync_Pocos_WithCqlAndOptions()
         {
@@ -196,10 +223,11 @@ public void FetchPageAsync_Pocos_WithCqlAndOptions()
             var rs = TestDataHelper.GetUsersRowSet(usersExpected);
             rs.AutoPage = false;
             rs.PagingState = new byte[] {1, 2, 3};
-
+            BoundStatement stmt = null;
             var sessionMock = new Mock<ISession>(MockBehavior.Strict);
             sessionMock
-                .Setup(s => s.ExecuteAsync(It.Is<BoundStatement>(stmt => !stmt.AutoPage && stmt.PageSize == pageSize)))
+                .Setup(s => s.ExecuteAsync(It.IsAny<BoundStatement>()))
+                .Callback<IStatement>(s => stmt = (BoundStatement)s)
                 .Returns(() => TestHelper.DelayedTask(rs, 50))
                 .Verifiable();
             sessionMock
@@ -213,6 +241,8 @@ public void FetchPageAsync_Pocos_WithCqlAndOptions()
             Assert.AreEqual(rs.PagingState, page.PagingState);
             CollectionAssert.AreEqual(page, usersExpected, new TestHelper.PropertyComparer());
             sessionMock.Verify();
+            Assert.False(stmt.AutoPage);
+            Assert.AreEqual(pageSize, stmt.PageSize);
         }
 
         [Test]

diff --git a/src/Cassandra.Tests/Mapping/Linq/LinqMappingUnitTests.cs b/src/Cassandra.Tests/Mapping/Linq/LinqMappingUnitTests.cs
@@ -106,5 +106,39 @@ public void Linq_CqlQuery_ExecutePaged_Maps_SingleValues()
             CollectionAssert.AreEqual(rs.PagingState, page.PagingState);
             CollectionAssert.AreEqual(new [] { 100, 200, 300}, page.ToArray(), new TestHelper.PropertyComparer());
         }
+
+        [Test]
+        public void Linq_CqlQuery_Automatically_Pages()
+        {
+            const int pageLength = 100;
+            var rs = TestDataHelper.GetSingleColumnRowSet("int_val", Enumerable.Repeat(1, pageLength).ToArray());
+            BoundStatement stmt = null;
+            var sessionMock = new Mock<ISession>(MockBehavior.Strict);
+            sessionMock
+                .Setup(s => s.ExecuteAsync(It.IsAny<BoundStatement>()))
+                .Returns(TestHelper.DelayedTask(rs))
+                .Callback<IStatement>(s => stmt = (BoundStatement)s)
+                .Verifiable();
+            sessionMock.Setup(s => s.PrepareAsync(It.IsAny<string>())).Returns(TaskHelper.ToTask(GetPrepared("Mock query")));
+            sessionMock.Setup(s => s.BinaryProtocolVersion).Returns(2);
+            rs.AutoPage = true;
+            rs.PagingState = new byte[] { 0, 0, 0 };
+            var counter = 0;
+            rs.FetchNextPage = state =>
+            {
+                var rs2 = TestDataHelper.GetSingleColumnRowSet("int_val", Enumerable.Repeat(1, pageLength).ToArray());
+                if (++counter < 2)
+                {
+                    rs2.PagingState = new byte[] {0, 0, (byte) counter};
+                }
+                return rs2;
+            };
+            var table = new Table<int>(sessionMock.Object);
+            IEnumerable<int> results = table.Execute();
+            Assert.True(stmt.AutoPage);
+            Assert.AreEqual(0, counter);
+            Assert.AreEqual(pageLength * 3, results.Count());
+            Assert.AreEqual(2, counter);
+        }
     }
 }
diff --git a/src/Cassandra.Tests/StatementTests.cs b/src/Cassandra.Tests/StatementTests.cs
@@ -88,11 +88,21 @@ public void Statement_SetPagingState_Disables_AutoPage()
         {
             var statement = new SimpleStatement();
             Assert.True(statement.AutoPage);
-            statement.SetPagingState(new byte[0]);
+            statement.SetPagingState(new byte[] { 1, 2, 3, 4, 5, 6 });
             Assert.False(statement.AutoPage);
             Assert.NotNull(statement.PagingState);
         }
 
+        [Test]
+        public void Statement_SetPagingState_Null_Does_Not_Disable_AutoPage()
+        {
+            var statement = new SimpleStatement();
+            Assert.True(statement.AutoPage);
+            statement.SetPagingState(null);
+            Assert.True(statement.AutoPage);
+            Assert.Null(statement.PagingState);
+        }
+
         [Test]
         public void PreparedStatement_Bind_SetsRoutingKey_Single()
         {

diff --git a/src/Cassandra/Data/Linq/CqlQueryExtensions.cs b/src/Cassandra/Data/Linq/CqlQueryExtensions.cs
@@ -27,7 +27,8 @@ internal static void CopyQueryPropertiesTo(this Statement src, Statement dst)
                .SetConsistencyLevel(src.ConsistencyLevel)
                .SetPageSize(src.PageSize)
                .SetPagingState(src.PagingState)
-               .SetRetryPolicy(src.RetryPolicy);
+               .SetRetryPolicy(src.RetryPolicy).
+                SetAutoPage(src.AutoPage);
             if (src.SerialConsistencyLevel != ConsistencyLevel.Any)
             {
                 dst.SetSerialConsistencyLevel(src.SerialConsistencyLevel);

diff --git a/src/Cassandra/Mapping/Mapper.cs b/src/Cassandra/Mapping/Mapper.cs
@@ -99,7 +99,7 @@ public Task<IPage<T>> FetchPageAsync<T>(Cql cql)
             {
                 throw new ArgumentNullException("cql");
             }
-            cql.AutoPage = true;
+            cql.AutoPage = false;
             _cqlGenerator.AddSelect<T>(cql);
             return ExecuteAsyncAndAdapt<IPage<T>>(cql, (stmt, rs) =>
             {

diff --git a/src/Cassandra/Mapping/Statements/StatementFactory.cs b/src/Cassandra/Mapping/Statements/StatementFactory.cs
@@ -25,11 +25,11 @@ public StatementFactory()
 
         public Task<Statement> GetStatementAsync(ISession session, Cql cql)
         {
-            // Use a SimpleStatement if we're not supposed to prepare
             if (cql.QueryOptions.NoPrepare)
             {
+                // Use a SimpleStatement if we're not supposed to prepare
                 Statement statement = new SimpleStatement(cql.Statement, cql.Arguments);
-                cql.QueryOptions.CopyOptionsToStatement(statement);
+                SetStatementProperties(statement, cql);
                 return TaskHelper.ToTask(statement);
             }
             return _statementCache
@@ -40,12 +40,18 @@ public Task<Statement> GetStatementAsync(ISession session, Cql cql)
                     {
                         Logger.Warning(String.Format("The prepared statement cache contains {0} queries. Use parameter markers for queries. You can configure this warning threshold using MappingConfiguration.SetMaxStatementPreparedThreshold() method.", _statementCache.Count));
                     }
-                    var boundStatement = t.Result.Bind(cql.Arguments);
-                    cql.QueryOptions.CopyOptionsToStatement(boundStatement);
-                    return (Statement)boundStatement;
+                    Statement boundStatement = t.Result.Bind(cql.Arguments);
+                    SetStatementProperties(boundStatement, cql);
+                    return boundStatement;
                 });
         }
 
+        private void SetStatementProperties(IStatement stmt, Cql cql)
+        {
+            cql.QueryOptions.CopyOptionsToStatement(stmt);
+            stmt.SetAutoPage(cql.AutoPage);
+        }
+
         public Statement GetStatement(ISession session, Cql cql)
         {
             // Just use async version's result