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 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 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 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_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() { 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>() 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)}; foreach (var brewery in breweries) { 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); }
public void Map2PocoTests_Simple_Projections_WhereDateTime() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from b in context.Query<Beer>() where (b.Type == "beer") && (b.Updated >= new DateTime(2010, 1, 1)) select new { name = b.Name, updated = b.Updated }; foreach (var b in beers.Take(20)) { Console.WriteLine("{0} last updated {1:g}", b.name, b.updated); } } } }
public void Map2PocoTests_Simple_Projections_TypeFilterRuntime() { DocumentFilterManager.SetFilter(new BreweryFilter()); using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var breweries = (from b in context.Query<Brewery>() select new {type = b.Type}) .AsEnumerable(); Assert.True(breweries.All(p => p.type == "brewery")); } } }
public void Map2PocoTests_Simple_Projections_TypeFilterAttribute() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = (from b in context.Query<BeerFiltered>() select new {type = b.Type}). AsEnumerable(); Assert.True(beers.All(p => p.type == "beer")); } } }
public async Task Query() { // Ensure that the database starts out empty. couchbase.Clear(); await Assert.ThrowsAsync <CouchbaseKeyValueResponseException>(async() => await bucket.GetSafeAsync <string>("jack")); await Assert.ThrowsAsync <CouchbaseKeyValueResponseException>(async() => await bucket.GetSafeAsync <string>("jill")); // Write a couple documents and then query for them. Note // that we're explicitly using [RequestPlus] consistency // and we're doing a synchronous query. await bucket.UpsertSafeAsync("jack", new TestDoc() { Name = "Jack", Age = 11 }); await bucket.UpsertSafeAsync("jill", new TestDoc() { Name = "Jill", Age = 12 }); var context = new BucketContext(bucket); // Note that we're explicitly using [RequestPlus] consistency // and we're doing a synchronous query. var query = from doc in context.Query <TestDoc>() .ScanConsistency(Couchbase.N1QL.ScanConsistency.RequestPlus) select doc; var results = query.ToList(); Assert.Equal(2, results.Count); Assert.Single(results.Where(doc => doc.Name == "Jack")); Assert.Single(results.Where(doc => doc.Name == "Jill")); // Use Couchbase [IQueryable<T>.ExecuteAsync()] to execute the query // and enable result streaming from the server. query = from doc in context.Query <TestDoc>() .ScanConsistency(Couchbase.N1QL.ScanConsistency.RequestPlus) .UseStreaming(true) select doc; await query.ExecuteAsync(); results = query.ToList(); Assert.Equal(2, results.Count); Assert.Single(results.Where(doc => doc.Name == "Jack")); Assert.Single(results.Where(doc => doc.Name == "Jill")); // Do a string based query using the [QueryAsync()] extension // method which throws an exception on errors. Note that this doesn't // appear to be compatible with streaming (Rows is NULL). var queryRequest = new QueryRequest($"select {bucket.Name}.* from {bucket.Name}") .ScanConsistency(ScanConsistency.RequestPlus); var queryResult = await bucket.QueryAsync <TestDoc>(queryRequest); var rows = queryResult.Rows; Assert.Equal(2, rows.Count); Assert.Single(rows.Where(doc => doc.Name == "Jack")); Assert.Single(rows.Where(doc => doc.Name == "Jill")); // Do a string based query using the [QuerySafeAsync()] extension // method which throws an exception on errors. Note that this doesn't // appear to be compatible with streaming (the result is NULL). queryRequest = new QueryRequest($"select {bucket.Name}.* from {bucket.Name}") .ScanConsistency(ScanConsistency.RequestPlus); results = await bucket.QuerySafeAsync <TestDoc>(queryRequest); Assert.Equal(2, results.Count); Assert.Single(results.Where(doc => doc.Name == "Jack")); Assert.Single(results.Where(doc => doc.Name == "Jill")); }
public void SingleOrDefault_HasResult() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from beer in context.Query<Beer>() where beer.Name == "21A IPA" select new { beer.Name }; var aBeer = beers.SingleOrDefault(); Assert.IsNotNull(aBeer); Console.WriteLine(aBeer.Name); } } }
public void NoProjection_Number() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = (from b in context.Query<Beer>() where b.Type == "beer" select b.Abv). Take(10); foreach (var b in beers) { Console.WriteLine(b); } } } }
public void Map2PocoTests() { using (var cluster = new Cluster( TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from b in context.Query<Beer>() select b; foreach (var beer in beers) { Console.WriteLine(beer.Name); } } } }
public void JoinTests_LeftJoin_SortAndFilter() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from beer in context.Query<Beer>() join breweryGroup in context.Query<Brewery>() on beer.BreweryId equals N1QlFunctions.Key(breweryGroup) into bg from brewery in bg.DefaultIfEmpty() where beer.Abv > 4 orderby brewery.Name, beer.Name select new {beer.Name, beer.Abv, BreweryName = brewery.Name}; foreach (var b in beers.Take(10)) { Console.WriteLine("Beer {0} with ABV {1} is from {2}", b.Name, b.Abv, b.BreweryName); } } } }
public void Execute(CancellationToken cancellationToken) { using (new CouchbaseDistributedLock(DISTRIBUTED_LOCK_KEY, defaultLockTimeout, storage)) { logger.Trace("Aggregating records in 'Counter' table."); using (IBucket bucket = storage.Client.OpenBucket(storage.Options.DefaultBucket)) { // context BucketContext context = new BucketContext(bucket); List <Counter> rawCounters = context.Query <Counter>() .Where(c => c.DocumentType == DocumentTypes.Counter && c.Type == CounterTypes.Raw) .ToList(); Dictionary <string, (int Value, int?ExpireOn, List <Counter> Counters)> counters = rawCounters.GroupBy(c => c.Key) .ToDictionary(k => k.Key, v => (Value: v.Sum(c => c.Value), ExpireOn: v.Max(c => c.ExpireOn), Counters: v.ToList())); foreach (string key in counters.Keys) { cancellationToken.ThrowIfCancellationRequested(); if (counters.TryGetValue(key, out var data)) { Counter aggregated; string id = $"{key}:{CounterTypes.Aggregate}".GenerateHash(); IOperationResult <Counter> operation = bucket.Get <Counter>(id, TimeSpan.FromMinutes(1)); if (operation.Success == false && operation.Value == null) { aggregated = new Counter { Id = id, Key = key, Type = CounterTypes.Aggregate, Value = data.Value, ExpireOn = data.ExpireOn }; } else if (operation.Success && operation.Value.Type == CounterTypes.Aggregate) { aggregated = operation.Value; aggregated.Value += data.Value; aggregated.ExpireOn = new[] { aggregated.ExpireOn, data.ExpireOn }.Max(); } else { logger.Warn($"Document with ID: {id} is a {operation.Value.Type.ToString()} type"); continue; } IOperationResult <Counter> result = bucket.Upsert(aggregated.Id, aggregated); if (result.Success) { IList <string> ids = data.Counters .Select(counter => counter.Id) .ToList(); bucket.Remove(ids, new ParallelOptions { CancellationToken = cancellationToken }, TimeSpan.FromMinutes(1)); logger.Trace($"Total {ids.Count} records from the 'Counter:{aggregated.Key}' were aggregated."); } } } } logger.Trace("Records from the 'Counter' table aggregated."); } cancellationToken.WaitHandle.WaitOne(storage.Options.CountersAggregateInterval); }
public void Map2PocoTests_Simple_Projections_WhereNot() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from b in context.Query<Beer>() where b.Type == "beer" && !(b.Abv < 4) select new {name = b.Name, abv = b.Abv}; foreach (var b in beers) { Console.WriteLine("{0} has {1} ABV", b.name, b.abv); } } } }
public void Map2PocoTests_Explain_QueryWithPropertyExtraction() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var explanation = (from b in context.Query<Beer>() where b.Type == "beer" select b.Abv). Explain(); Console.WriteLine(explanation); } } }
public void NestTests_Unnest_Sort() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var breweries = from brewery in context.Query<Brewery>() from address in brewery.Address orderby address select new {name = brewery.Name, address}; foreach (var b in breweries.Take(10)) { Console.WriteLine("Brewery {0} has address line {1}", b.name, b.address); } } } }
public void Map2PocoTests_NewObjectsInArray() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var query = from brewery in context.Query<Brewery>() where brewery.Type == "brewery" select new { name = brewery.Name, list = new[] {new {part = brewery.City}, new {part = brewery.State}, new {part = brewery.Code}} }; foreach (var brewery in query.Take(10)) { Console.WriteLine("Brewery {0} has address parts {1}", brewery.name, String.Join(", ", brewery.list.Select(p => p.part))); } } } }
public void SingleOrDefault_Empty() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from beer in context.Query<Beer>() where beer.Type == "abcdefg" select new { beer.Name }; var aBeer = beers.SingleOrDefault(); Assert.IsNull(aBeer); } } }
public void Map2PocoTests_Simple_Projections_MetaWhere() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = (from b in context.Query<Beer>() where b.Type == "beer" && N1QlFunctions.Meta(b).Type == "json" select new {name = b.Name}). Take(10); foreach (var b in beers) { Console.WriteLine("{0} is a JSON document", b.name); } } } }
public void Single_Empty() { using (var cluster = new Cluster(TestConfigurations.DefaultConfig())) { using (var bucket = cluster.OpenBucket("beer-sample")) { var context = new BucketContext(bucket); var beers = from beer in context.Query<Beer>() where beer.Type == "abcdefg" select new { beer.Name }; Assert.Throws<InvalidOperationException>(() => { // ReSharper disable once UnusedVariable var temp = beers.Single(); }); } } }
public async Task WriteReadList() { // Ensure that the database starts out empty. Assert.Empty(from doc in context.Query <object>() select doc); // Verify that the generated CreateKey() methods return the // correct values. Assert.Equal($"{Person.PersistedType}::0", Person.CreateKey("0")); Assert.Equal($"{City.PersistedType}::Woodinville", City.CreateKey("Woodinville")); // Verify that we can write generated entity models. var jack = new Person() { Id = 0, Name = "Jack", Age = 10, Gender = Gender.Male, Data = new byte[] { 0, 1, 2, 3, 4 } }; var jill = new Person() { Id = 1, Name = "Jill", Age = 11, Gender = Gender.Female, Data = new byte[] { 5, 6, 7, 8, 9 } }; Assert.Equal("Test.Neon.Models.Definitions.Person::0", jack.GetKey()); Assert.Equal("Test.Neon.Models.Definitions.Person::1", jill.GetKey()); await bucket.UpsertSafeAsync(jack, persistTo : PersistTo.One); await bucket.UpsertSafeAsync(jill, persistTo : PersistTo.One); // Verify that we can read them. var jackRead = await bucket.GetSafeAsync <Person>(Person.CreateKey(0)); var jillRead = await bucket.GetSafeAsync <Person>(Person.CreateKey(1)); Assert.Equal("Test.Neon.Models.Definitions.Person::0", jackRead.GetKey()); Assert.Equal("Test.Neon.Models.Definitions.Person::1", jillRead.GetKey()); Assert.True(jack == jackRead); Assert.True(jill == jillRead); //----------------------------------------------------------------- // Persist a [City] entity (which has a different entity type) and then // perform a N1QL query to list the Person entities and verify that we // get only Jack and Jill back. This verifies the the [TypeFilter] // attribute is generated and working correctly. var city = new City() { Name = "Woodinville", Population = 12345 }; var result = await bucket.UpsertAsync(city); await bucket.WaitForIndexerAsync(); //----------------------------------------------------------------- // Query for the people and verify var peopleQuery = (from doc in context.Query <Person>() select doc); var people = peopleQuery.ToList(); Assert.Equal(2, people.Count); Assert.Contains(people, p => p.Name == "Jack"); Assert.Contains(people, p => p.Name == "Jill"); //----------------------------------------------------------------- // Query for the city and verify. var cityQuery = from doc in context.Query <City>() select doc; var cities = cityQuery.ToList(); Assert.Single(cities); Assert.Contains(cities, p => p.Name == "Woodinville"); //----------------------------------------------------------------- // Query for documents that don't exist and verify. var rawResults = await bucket.QueryAsync <object>($"select * from `{bucket.Name}` where __T=\"Test.Neon.Models.Definitions.Country\";"); var countryQuery = from doc in context.Query <Country>() select doc; Assert.Empty(rawResults.ToList()); Assert.Empty(countryQuery.ToList()); // $todo(jefflill): https://github.com/nforgeio/neonKUBE/issues/475 //----------------------------------------------------------------- // Verify that plain old object serialization still works. var poo = new PlainOldObject() { Foo = "bar" }; await bucket.UpsertSafeAsync("poo", poo, persistTo : PersistTo.One); poo = await bucket.GetSafeAsync <PlainOldObject>("poo"); Assert.Equal("bar", poo.Foo); //----------------------------------------------------------------- // Extra credit #1: Verify that [DeepClone()] works. var clone = jack.DeepClone(); Assert.Equal(jack.Name, clone.Name); Assert.Equal(jack.Age, clone.Age); Assert.Equal(jack.Gender, clone.Gender); Assert.NotSame(jack.Data, clone.Data); //----------------------------------------------------------------- // Extra credit #2: Verify that [SameTypeAs()] works. Assert.True(Person.SameTypeAs(jack)); Assert.False(Person.SameTypeAs(city)); Assert.False(Person.SameTypeAs(null)); }