public static async Task <T> FetchAsync <T>(this IManagedConnection runner, IQueryHandler <T> handler, IIdentityMap map, QueryStatistics stats, ITenant tenant, CancellationToken token) { var command = CommandBuilder.ToCommand(tenant, handler); return(await runner.ExecuteAsync(command, async (c, tkn) => { using (var reader = await command.ExecuteReaderAsync(tkn).ConfigureAwait(false)) { return await handler.HandleAsync(reader, map, stats, tkn).ConfigureAwait(false); } }, token).ConfigureAwait(false)); }
private IQueryHandler <T> tryFindSingleQuery <T>(QueryModel model, IIncludeJoin[] joins, QueryStatistics stats) { var choice = model.FindOperators <ChoiceResultOperatorBase>().FirstOrDefault(); if (choice == null) { return(null); } var query = new LinqQuery <T>(_schema, model, joins, stats); if (choice is FirstResultOperator) { return(choice.ReturnDefaultWhenEmpty ? OneResultHandler <T> .FirstOrDefault(query) : OneResultHandler <T> .First(query)); } if (choice is SingleResultOperator) { return(choice.ReturnDefaultWhenEmpty ? OneResultHandler <T> .SingleOrDefault(query) : OneResultHandler <T> .Single(query)); } if (choice is MinResultOperator) { return(AggregateQueryHandler <T> .Min(query)); } if (choice is MaxResultOperator) { return(AggregateQueryHandler <T> .Max(query)); } if (model.HasOperator <LastResultOperator>()) { throw new InvalidOperationException( "Marten does not support Last()/LastOrDefault(). Use reverse ordering and First()/FirstOrDefault() instead"); } return(null); }
public IQueryHandler <TOut> HandlerFor <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, out QueryStatistics stats) { var queryType = query.GetType(); CachedQuery cachedQuery; if (!_cache.Has(queryType)) { cachedQuery = buildCachedQuery(queryType, query); _cache[queryType] = cachedQuery; } else { cachedQuery = _cache[queryType]; } return(cachedQuery.CreateHandler <TOut>(query, out stats)); }
public void SimpleProjections() { var transformer = new CustomTrasformer(); sessions.EvictQueries(); sessions.Statistics.Clear(); const string queryString = "select i.Name, i.Description from AnotherItem i where i.Name='widget'"; object savedId; using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).List(); var i = new AnotherItem { Name = "widget" }; savedId = s.Save(i); tx.Commit(); } QueryStatistics qs = sessions.Statistics.GetQueryStatistics(queryString); EntityStatistics es = sessions.Statistics.GetEntityStatistics(typeof(AnotherItem).FullName); Thread.Sleep(200); IList result; using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).List(); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(0)); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).List(); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(1)); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).SetResultTransformer(transformer).List(); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(1), "hit count should not go up since we are adding a resulttransformer"); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).SetResultTransformer(transformer).List(); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(2), "hit count should go up since we are using the same resulttransformer"); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { result = s.CreateQuery(queryString).SetCacheable(true).List(); Assert.That(result.Count, Is.EqualTo(1)); var i = s.Get <AnotherItem>(savedId); i.Name = "Widget"; tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(3)); Assert.That(qs.CacheMissCount, Is.EqualTo(3)); Thread.Sleep(200); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).List(); var i = s.Get <AnotherItem>(savedId); Assert.That(i.Name, Is.EqualTo("Widget")); s.Delete(i); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(3)); Assert.That(qs.CacheMissCount, Is.EqualTo(4)); Assert.That(qs.CachePutCount, Is.EqualTo(4)); Assert.That(qs.ExecutionCount, Is.EqualTo(4)); Assert.That(es.FetchCount, Is.EqualTo(0)); //check that it was being cached }
public void CanPerformDynamicQueryUsingClientLinqQueryWithNestedCollection() { var blogOne = new Blog { Title = "one", Category = "Ravens", Tags = new[] { new BlogTag() { Name = "Birds" } } }; var blogTwo = new Blog { Title = "two", Category = "Rhinos", Tags = new[] { new BlogTag() { Name = "Mammals" } } }; var blogThree = new Blog { Title = "three", Category = "Rhinos", Tags = new[] { new BlogTag() { Name = "Mammals" } } }; using (var store = GetDocumentStore()) { using (var s = store.OpenSession()) { s.Store(blogOne); s.Store(blogTwo); s.Store(blogThree); s.SaveChanges(); } using (var s = store.OpenSession()) { var stats = new QueryStatistics(); var results = s.Query <Blog>() .Statistics(out stats) .Customize(x => x.WaitForNonStaleResults(TimeSpan.FromSeconds(5))) .Where(x => x.Tags.Any(y => y.Name == "Birds")) .ToArray(); Assert.Equal(1, results.Length); Assert.Equal("one", results[0].Title); Assert.Equal("Ravens", results[0].Category); } } }
public ISelectClause UseStatistics(QueryStatistics statistics) { return(new StatsSelectClause <T>(this, statistics)); }
public async Task <IEvent> ResolveAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { var id = await reader.GetFieldValueAsync <Guid>(0, token).ConfigureAwait(false); var eventTypeName = await reader.GetFieldValueAsync <string>(1, token).ConfigureAwait(false); var version = await reader.GetFieldValueAsync <int>(2, token).ConfigureAwait(false); var dataJson = await reader.As <NpgsqlDataReader>().GetTextReaderAsync(3).ConfigureAwait(false); var mapping = Events.EventMappingFor(eventTypeName); if (mapping == null) { var dotnetTypeName = await reader.GetFieldValueAsync <string>(8, token).ConfigureAwait(false); if (dotnetTypeName.IsEmpty()) { throw new UnknownEventTypeException(eventTypeName); } Type type; try { type = Events.TypeForDotNetName(dotnetTypeName); } catch (ArgumentNullException) { throw new UnknownEventTypeException(dotnetTypeName); } mapping = Events.EventMappingFor(type); } var data = _serializer.FromJson(mapping.DocumentType, dataJson).As <object>(); var sequence = await reader.GetFieldValueAsync <long>(4, token).ConfigureAwait(false); var stream = await reader.GetFieldValueAsync <Guid>(5, token).ConfigureAwait(false); var timestamp = await reader.GetFieldValueAsync <DateTimeOffset>(6, token).ConfigureAwait(false); var tenantId = await reader.GetFieldValueAsync <string>(7, token).ConfigureAwait(false); var @event = EventStream.ToEvent(data); @event.Version = version; @event.Id = id; @event.Sequence = sequence; @event.StreamId = stream; @event.Timestamp = timestamp; @event.TenantId = tenantId; return(@event); }
public IQueryHandler CloneForSession(IMartenSession session, QueryStatistics statistics) { var selector = (ISelector <T>)session.StorageFor <T>().BuildSelector(session); return(new ListWithStatsQueryHandler <T>(_countIndex, null, selector, statistics)); }
public ListWithStatsQueryHandler(int countIndex, Statement statement, ISelector <T> selector, QueryStatistics statistics) { _countIndex = countIndex; _statement = statement; _selector = selector; _statistics = statistics; }
public async Task <T> HandleAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { return(await reader.ReadAsync(token).ConfigureAwait(false) ? await storage.ResolveAsync(0, reader, map, token).ConfigureAwait(false) : default(T)); }
public void QueryStatGathering() { IStatistics stats = sessions.Statistics; stats.Clear(); ISession s = OpenSession(); ITransaction tx = s.BeginTransaction(); FillDb(s); tx.Commit(); s.Close(); s = OpenSession(); tx = s.BeginTransaction(); string continents = "from Continent"; int results = s.CreateQuery(continents).List().Count; QueryStatistics continentStats = stats.GetQueryStatistics(continents); Assert.IsNotNull(continentStats, "stats were null"); Assert.AreEqual(1, continentStats.ExecutionCount, "unexpected execution count"); Assert.AreEqual(results, continentStats.ExecutionRowCount, "unexpected row count"); var maxTime = continentStats.ExecutionMaxTime; Assert.AreEqual(maxTime, stats.QueryExecutionMaxTime); Assert.AreEqual(continents, stats.QueryExecutionMaxTimeQueryString); IEnumerable itr = s.CreateQuery(continents).Enumerable(); // Enumerable() should increment the execution count Assert.AreEqual(2, continentStats.ExecutionCount, "unexpected execution count"); // but should not effect the cumulative row count Assert.AreEqual(results, continentStats.ExecutionRowCount, "unexpected row count"); NHibernateUtil.Close(itr); tx.Commit(); s.Close(); // explicitly check that statistics for "split queries" get collected // under the original query stats.Clear(); s = OpenSession(); tx = s.BeginTransaction(); string localities = "from Locality"; results = s.CreateQuery(localities).List().Count; QueryStatistics localityStats = stats.GetQueryStatistics(localities); Assert.IsNotNull(localityStats, "stats were null"); // ...one for each split query Assert.AreEqual(2, localityStats.ExecutionCount, "unexpected execution count"); Assert.AreEqual(results, localityStats.ExecutionRowCount, "unexpected row count"); maxTime = localityStats.ExecutionMaxTime; Assert.AreEqual(maxTime, stats.QueryExecutionMaxTime); Assert.AreEqual(localities, stats.QueryExecutionMaxTimeQueryString); tx.Commit(); s.Close(); Assert.IsFalse(s.IsOpen); // native sql queries stats.Clear(); s = OpenSession(); tx = s.BeginTransaction(); string sql = "select Id, Name from Country"; results = s.CreateSQLQuery(sql).AddEntity(typeof(Country)).List().Count; QueryStatistics sqlStats = stats.GetQueryStatistics(sql); Assert.IsNotNull(sqlStats, "sql stats were null"); Assert.AreEqual(1, sqlStats.ExecutionCount, "unexpected execution count"); Assert.AreEqual(results, sqlStats.ExecutionRowCount, "unexpected row count"); maxTime = sqlStats.ExecutionMaxTime; Assert.AreEqual(maxTime, stats.QueryExecutionMaxTime); Assert.AreEqual(sql, stats.QueryExecutionMaxTimeQueryString); tx.Commit(); s.Close(); s = OpenSession(); tx = s.BeginTransaction(); CleanDb(s); tx.Commit(); s.Close(); }
public T Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats) { return(reader.Read() ? storage.Resolve(0, reader, map) : default(T)); }
public static Task <IList <T> > ResolveAsync <T>(this IManagedConnection runner, NpgsqlCommand cmd, ISelector <T> selector, IIdentityMap map, QueryStatistics stats, CancellationToken token) { var selectMap = map.ForQuery(); return(runner.ExecuteAsync(cmd, async(c, tkn) => { var list = new List <T>(); using (var reader = await cmd.ExecuteReaderAsync(tkn).ConfigureAwait(false)) { while (await reader.ReadAsync(tkn).ConfigureAwait(false)) { list.Add(selector.Resolve(reader, selectMap, stats)); } } return list.As <IList <T> >(); }, token)); }
public static IList <T> Resolve <T>(this IManagedConnection runner, NpgsqlCommand cmd, ISelector <T> selector, IIdentityMap map, QueryStatistics stats) { var selectMap = map.ForQuery(); return(runner.Execute(cmd, c => { var list = new List <T>(); using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { list.Add(selector.Resolve(reader, selectMap, stats)); } } return list; })); }
public IReadOnlyList <IEvent> Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats) { return(_selector.Read(reader, map, stats)); }
public StreamState Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats) { return(reader.Read() ? Resolve(reader, map, stats) : null); }
public Task <IReadOnlyList <IEvent> > HandleAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { return(_selector.ReadAsync(reader, map, stats, token)); }
public async Task <StreamState> HandleAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { return(await reader.ReadAsync(token).ConfigureAwait(false) ? await ResolveAsync(reader, map, stats, token).ConfigureAwait(false) : null); }
public async Task <IList <T> > HandleAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { var list = new List <T>(); while (await reader.ReadAsync(token).ConfigureAwait(false)) { list.Add(await storage.ResolveAsync(0, reader, map, token).ConfigureAwait(false)); } return(list); }
public async Task <StreamState> ResolveAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { var id = await reader.GetFieldValueAsync <T>(0, token).ConfigureAwait(false); var version = await reader.GetFieldValueAsync <int>(1, token).ConfigureAwait(false); var typeName = await reader.IsDBNullAsync(2, token).ConfigureAwait(false) ? null : await reader.GetFieldValueAsync <string>(2, token).ConfigureAwait(false); var timestamp = await reader.GetFieldValueAsync <object>(3, token).ConfigureAwait(false); var created = await reader.GetFieldValueAsync <object>(4, token).ConfigureAwait(false); Type aggregateType = null; if (typeName.IsNotEmpty()) { aggregateType = _events.AggregateTypeFor(typeName); } return(StreamState.Create(id, version, aggregateType, timestamp.MapToDateTime().ToUniversalTime(), created.MapToDateTime())); }
public void QueryCacheInvalidation() { sessions.EvictQueries(); sessions.Statistics.Clear(); const string queryString = "from Item i where i.Name='widget'"; object savedId = CreateItem(queryString); QueryStatistics qs = sessions.Statistics.GetQueryStatistics(queryString); EntityStatistics es = sessions.Statistics.GetEntityStatistics(typeof(Item).FullName); Thread.Sleep(200); IList result; using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { result = s.CreateQuery(queryString).SetCacheable(true).List(); Assert.That(result.Count, Is.EqualTo(1)); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(0)); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { result = s.CreateQuery(queryString).SetCacheable(true).List(); Assert.That(result.Count, Is.EqualTo(1)); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(1)); Assert.That(es.FetchCount, Is.EqualTo(0)); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { result = s.CreateQuery(queryString).SetCacheable(true).List(); Assert.That(result.Count, Is.EqualTo(1)); Assert.That(NHibernateUtil.IsInitialized(result[0])); var i = (Item)result[0]; i.Name = "Widget"; tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(2)); Assert.That(qs.CacheMissCount, Is.EqualTo(2)); Assert.That(es.FetchCount, Is.EqualTo(0)); Thread.Sleep(200); using (ISession s = OpenSession()) using (ITransaction tx = s.BeginTransaction()) { s.CreateQuery(queryString).SetCacheable(true).List(); var i = s.Get <Item>(savedId); Assert.That(i.Name, Is.EqualTo("Widget")); s.Delete(i); tx.Commit(); } Assert.That(qs.CacheHitCount, Is.EqualTo(2)); Assert.That(qs.CacheMissCount, Is.EqualTo(3)); Assert.That(qs.CachePutCount, Is.EqualTo(3)); Assert.That(qs.ExecutionCount, Is.EqualTo(3)); Assert.That(es.FetchCount, Is.EqualTo(0)); //check that it was being cached }
public T Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats) { var hasNext = reader.Read(); return(hasNext ? reader.GetFieldValue <T>(0) : default(T)); }
public ISelectClause UseStatistics(QueryStatistics statistics) { throw new NotSupportedException(); }
public async Task <T> HandleAsync(DbDataReader reader, IIdentityMap map, QueryStatistics stats, CancellationToken token) { var hasNext = await reader.ReadAsync(token).ConfigureAwait(false); return(hasNext ? await reader.GetFieldValueAsync <T>(0, token).ConfigureAwait(false) : default(T)); }
private IQueryHandler <T> tryFindScalarQuery <T>(QueryModel model, IIncludeJoin[] joins, QueryStatistics stats) { if (model.HasOperator <CountResultOperator>() || model.HasOperator <LongCountResultOperator>()) { return(new LinqQuery <T>(_schema, model, joins, stats).ToCount <T>()); } if (model.HasOperator <SumResultOperator>()) { return(AggregateQueryHandler <T> .Sum(new LinqQuery <T>(_schema, model, joins, stats))); } if (model.HasOperator <AverageResultOperator>()) { return(AggregateQueryHandler <T> .Average(new LinqQuery <T>(_schema, model, joins, stats))); } if (model.HasOperator <AnyResultOperator>()) { return(new LinqQuery <T>(_schema, model, joins, stats).ToAny().As <IQueryHandler <T> >()); } return(null); }
public StatsSelectClause(ISelectClause inner, QueryStatistics statistics) { Inner = inner; _statistics = statistics; }
public IQueryHandler <T> BuildHandler <T>(QueryModel model, IIncludeJoin[] joins, QueryStatistics stats) { return(tryFindScalarQuery <T>(model, joins, stats) ?? tryFindSingleQuery <T>(model, joins, stats) ?? listHandlerFor <T>(model, joins, stats)); }
public ISelectClause UseStatistics(QueryStatistics statistics) { _statistics = statistics; return(this); }
private IQueryHandler <T> listHandlerFor <T>(QueryModel model, IIncludeJoin[] joins, QueryStatistics stats) { if (model.HasOperator <ToJsonArrayResultOperator>()) { var query = new LinqQuery <T>(_schema, model, joins, stats); return(new JsonQueryHandler(query.As <LinqQuery <string> >()).As <IQueryHandler <T> >()); } if (!typeof(T).IsGenericEnumerable()) { return(null); } var elementType = typeof(T).GetGenericArguments().First(); var handlerType = typeof(LinqQuery <>); if (typeof(T).GetGenericTypeDefinition() == typeof(IEnumerable <>)) { handlerType = typeof(EnumerableQueryHandler <>); } // TODO -- WTH? return (Activator.CreateInstance(handlerType.MakeGenericType(elementType), _schema, model, joins, stats) .As <IQueryHandler <T> >()); }
public static T Fetch <T>(this IManagedConnection runner, IQueryHandler <T> handler, IIdentityMap map, QueryStatistics stats, ITenant tenant) { var command = CommandBuilder.ToCommand(tenant, handler); return(runner.Execute(command, c => { using (var reader = command.ExecuteReader()) { return handler.Handle(reader, map, stats); } })); }