C# BucketContext.Query方法代码示例

        public void BeginChangeTracking_DoesNotClear_Modified_List()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));

            db.BeginChangeTracking();

            var query = from x in db.Query<Beer>()
                        where x.Type == "beer"
                        select x;

            db.BeginChangeTracking();

            var context = db as IChangeTrackableContext;

            Assert.AreEqual(0, context.ModifiedCount);

            var brewery = query.First();
            brewery.Abv = 10;

            Assert.AreEqual(1, context.ModifiedCount);

            db.BeginChangeTracking();

            Assert.AreEqual(1, context.ModifiedCount);
        }

        public void CreateQueryRequest_Any_ReturnsQueryWrappedInQueryRequest()
        {
            // Arrange

            var bucket = new Mock<IBucket>();
            bucket.Setup(m => m.Name).Returns("default");
            bucket.Setup(m => m.Configuration).Returns(new BucketConfiguration()
            {
                PoolConfiguration = new PoolConfiguration(new ClientConfiguration())
            });

            var context = new BucketContext(bucket.Object);
            var query = context.Query<Brewery>();

            // Act

            var result = LinqQueryRequest.CreateQueryRequest(query, p => p.Any(q => q.Name == "name"));

            // Assert

            const string queryStr = "SELECT true as result FROM `default` as `Extent1` WHERE (`Extent1`.`name` = 'name') LIMIT 1";

            Assert.NotNull(result);
            Assert.AreEqual(queryStr, result.GetOriginalStatement());
            Assert.True(result.ScalarResultBehavior.ResultExtractionRequired);
            Assert.AreEqual(false, result.ScalarResultBehavior.NoRowsResult);
        }

        public async Task ExecuteAsync_WithAvg_ReturnsAvg()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        select b;

            var result = await beers.ExecuteAsync(p => p.Average(q => q.Abv));
            Console.WriteLine(result);
        }

        public void Test_Basic_Query()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
            var query = from x in db.Query<Beer>()
                where x.Type == "beer"
                select x;

            foreach (var beer in query)
            {
                Console.WriteLine(beer.Name);
            }
        }

        public void AggregateTests_JoinBeforeGroupByAndMultipartKey()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var breweries =
                from beer in context.Query<Beer>()
                join brewery in context.Query<Brewery>() on beer.BreweryId equals N1QlFunctions.Key(brewery)
                where beer.Type == "beer"
                group beer by new {breweryid = beer.BreweryId, breweryName = brewery.Name}
                into g
                select new {g.Key.breweryName, count = g.Count(), avgAbv = g.Average(p => p.Abv)};

            var results = breweries.Take(1).ToList();
            Assert.AreEqual(1, results.Count);

            foreach (var brewery in results)
            {
                Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryName,
                    brewery.count, brewery.avgAbv);
            }
        }

        public async Task ExecuteAsync_Any_ReturnsTrue()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        where b.Type == "beer" && b.Name == "21A IPA"
                        select b;

            var result = await beers.ExecuteAsync(p => p.Any());

            Assert.True(result);
        }

        public async Task ExecuteAsync_FirstOrDefaultNoValues_ReturnsDefault()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        where b.Name == "abcdefg"
                        select b.Abv;

            var result = await beers.ExecuteAsync(p => p.FirstOrDefault());

            Assert.AreEqual(0M, result);
        }

        public async Task ExecuteAsync_First_ReturnsFirst()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                        select b;

            var result = await beers.ExecuteAsync(p => p.First());

            Assert.NotNull(result);
            Console.WriteLine(result.Name);
        }

        public void AggregateTests_JoinBeforeGroupByAndMultipartKey()
        {
            using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
            {
                using (var bucket = cluster.OpenBucket("beer-sample"))
                {
                    var context = new BucketContext(bucket);

                    var breweries =
                        from beer in context.Query<Beer>()
                        join brewery in context.Query<Brewery>() on beer.BreweryId equals N1QlFunctions.Key(brewery)
                        where beer.Type == "beer"
                        group beer by new { breweryid = beer.BreweryId, breweryName = brewery.Name }
                        into g
                        select new { g.Key.breweryName, count = g.Count(), avgAbv = g.Average(p => p.Abv) };

                    foreach (var brewery in breweries)
                    {
                        Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryName, brewery.count, brewery.avgAbv);
                    }
                }
            }
        }

        public async Task ExecuteAsync_NoParameters_ReturnsList()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var beers = from b in context.Query<Beer>()
                select b;

            var results = (await beers.Take(1).ExecuteAsync()).ToList();
            Assert.AreEqual(1, results.Count);

            foreach (var beer in results)
            {
                Console.WriteLine(beer.Name);
            }
        }

        public void Query_DisableProxyGeneration_ReturnsNoProxy()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));

            const string documentId = "21st_amendment_brewery_cafe-21a_ipa";

            var query = from x in db.Query<Beer>().UseKeys(new[] { documentId })
                        where x.Type == "beer"
                        select x;

            var beer = query.First();

            // ReSharper disable once SuspiciousTypeConversion.Global
            var status = beer as ITrackedDocumentNode;

            Assert.Null(status);
        }

        static void Main(string[] args)
        {
            var config = new ClientConfiguration
            {
                Servers = new List<Uri> { new Uri("http://localhost:8091") }
            };

            ClusterHelper.Initialize(config);
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
            var query = from b in db.Query<Beer>()
                        select b;

            foreach (var beer in query)
            {
                Console.WriteLine(beer.Type + ": " + beer.Name);
            }
            Console.Read();
            ClusterHelper.Close();
        }

        public void Query_EnableProxyGenerationAddAddress_FlagAsDirty()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"))
            {
                EnableChangeTracking = true
            };

            var query = from x in db.Query<Brewery>()
                        where x.Type == "brewery" && x.Address.Any()
                        select x;

            var brewery = query.First();
            var addresses = brewery.Address;

            addresses.Add("Test");

            // ReSharper disable once SuspiciousTypeConversion.Global
            var status = addresses as ITrackedDocumentNode;

            Assert.NotNull(status);
            Assert.IsTrue(status.IsDirty);
        }

        public void AggregateTests_GroupBy()
        {
            var bucket = ClusterHelper.GetBucket("beer-sample");
            var context = new BucketContext(bucket);

            var breweries =
                from beer in context.Query<Beer>()
                where beer.Type == "beer"
                group beer by beer.BreweryId
                into g
                orderby g.Key
                select new {breweryid = g.Key, count = g.Count(), avgAbv = g.Average(p => p.Abv)};

            var results = breweries.Take(1).ToList();
            Assert.AreEqual(1, results.Count);

            foreach (var brewery in results)
            {
                Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryid, brewery.count,
                    brewery.avgAbv);
            }
        }

        public void Query_EnableProxyGenerationChangesInSubDocuments_FlagAsDirty()
        {
            var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"))
            {
                EnableChangeTracking = true
            };

            var query = from x in db.Query<Brewery>()
                        where x.Type == "brewery" && N1QlFunctions.IsValued(x.Geo)
                        select x;

            var beer = query.First();

            // ReSharper disable once SuspiciousTypeConversion.Global
            var status = beer as ITrackedDocumentNode;

            Assert.NotNull(status);
            Assert.False(status.IsDirty);

            beer.Geo.Latitude = 90M;

            Assert.True(status.IsDirty);
        }