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);
}
}));
}
