T IQueryExecutor.ExecuteScalar <T>(QueryModel queryModel)
{
var mapping = _schema.MappingFor(queryModel.SelectClause.Selector.Type);
var documentQuery = new DocumentQuery(mapping, queryModel);
_schema.EnsureStorageExists(mapping.DocumentType);
if (queryModel.ResultOperators.OfType <AnyResultOperator>().Any())
{
var anyCommand = documentQuery.ToAnyCommand();
return(_runner.Execute(conn =>
{
anyCommand.Connection = conn;
return (T)anyCommand.ExecuteScalar();
}));
}
if (queryModel.ResultOperators.OfType <CountResultOperator>().Any())
{
var countCommand = documentQuery.ToCountCommand();
return(_runner.Execute(conn =>
{
countCommand.Connection = conn;
var returnValue = countCommand.ExecuteScalar();
return Convert.ToInt32(returnValue).As <T>();
}));
}
throw new NotSupportedException();
}
public void DeleteDocumentsFor(Type documentType)
{
var tableName = _schema.MappingFor(documentType).TableName;
var sql = "truncate {0} cascade".ToFormat(tableName);
_factory.RunSql(sql);
}
T IQueryExecutor.ExecuteScalar <T>(QueryModel queryModel)
{
var mapping = _schema.MappingFor(queryModel.SelectClause.Selector.Type);
var documentQuery = new DocumentQuery(mapping, queryModel, _serializer);
_schema.EnsureStorageExists(mapping.DocumentType);
if (queryModel.ResultOperators.OfType <AnyResultOperator>().Any())
{
var anyCommand = new NpgsqlCommand();
documentQuery.ConfigureForAny(anyCommand);
return(_runner.Execute(anyCommand, c => (T)c.ExecuteScalar()));
}
if (queryModel.ResultOperators.OfType <CountResultOperator>().Any())
{
var countCommand = new NpgsqlCommand();
documentQuery.ConfigureForCount(countCommand);
return(_runner.Execute(countCommand, c =>
{
var returnValue = c.ExecuteScalar();
return Convert.ToInt32(returnValue).As <T>();
}));
}
throw new NotSupportedException();
}
private DocumentChange[] determineChanges(UpdateBatch batch)
{
int index = 0;
var order = _inserts.Keys.Union(_updates.Keys)
.TopologicalSort(GetTypeDependencies)
.ToDictionary(x => x, x => index++);
_inserts.Keys.OrderBy(type => order[type]).Each(type =>
{
var upsert = _schema.UpsertFor(type);
_inserts[type].Each(o => upsert.RegisterUpdate(batch, o));
});
_updates.Keys.OrderBy(type => order[type]).Each(type =>
{
var upsert = _schema.UpsertFor(type);
_updates[type].Each(o => upsert.RegisterUpdate(batch, o));
});
_deletes.Keys.Each(type =>
{
var storage = _schema.StorageFor(type);
var mapping = _schema.MappingFor(type).ToQueryableDocument();
_deletes[type].Each(id => id.Configure(_schema.Parser, storage, mapping, batch));
});
writeEvents(batch);
foreach (var patch in _patches)
{
patch.RegisterUpdate(batch);
}
var changes = detectTrackerChanges();
changes.GroupBy(x => x.DocumentType).Each(group =>
{
var upsert = _schema.UpsertFor(group.Key);
group.Each(c =>
{
upsert.RegisterUpdate(batch, c.Document, c.Json);
});
});
return(changes);
}
/// <summary>
/// Fetch the entity version and last modified time from the database
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public DocumentMetadata MetadataFor <T>(T entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var handler = new EntityMetadataQueryHandler(entity, _schema.StorageFor(typeof(T)),
_schema.MappingFor(typeof(T)));
using (var connection = OpenConnection())
{
return(connection.Fetch(handler, null, null));
}
}
public LinqQuery(IDocumentSchema schema, QueryModel model, IIncludeJoin[] joins, QueryStatistics stats)
{
Model = model;
_schema = schema;
_joins = joins;
_mapping = schema.MappingFor(model.SourceType()).ToQueryableDocument();
for (var i = 0; i < model.BodyClauses.Count; i++)
{
var clause = model.BodyClauses[i];
if (clause is AdditionalFromClause)
{
// TODO -- to be able to go recursive, have _subQuery start to read the BodyClauses
_subQuery = new SelectManyQuery(schema, _mapping, model, i + 1);
break;
}
}
Selector = BuildSelector(joins, stats, _subQuery, joins);
SourceType = Model.SourceType();
Where = buildWhereFragment();
}
private DocumentChange[] GetChanges(UpdateBatch batch)
{
_updates.Keys.Each(type =>
{
var storage = _schema.StorageFor(type);
_updates[type].Each(o => storage.RegisterUpdate(batch, o));
});
_deletes.Keys.Each(type =>
{
var storage = _schema.StorageFor(type);
var mapping = _schema.MappingFor(type);
_deletes[type].Each(id => batch.Delete(mapping.TableName, id.Id, storage.IdType));
});
var changes = detectTrackerChanges();
changes.GroupBy(x => x.DocumentType).Each(group =>
{
var storage = _schema.StorageFor(group.Key);
group.Each(c =>
{
storage.RegisterUpdate(batch, c.Document, c.Json);
});
});
return(changes);
}
public void ConfigureCommand(NpgsqlCommand command)
{
var sql = _sql;
if (!sql.Contains("select", StringComparison.OrdinalIgnoreCase))
{
var mapping = _schema.MappingFor(typeof(T)).ToQueryableDocument();
var tableName = mapping.Table.QualifiedName;
sql = "select data from {0} {1}".ToFormat(tableName, sql);
}
var firstParameter = _parameters.FirstOrDefault();
if (_parameters.Length == 1 && firstParameter != null && firstParameter.IsAnonymousType())
{
command.AddParameters(firstParameter);
}
else
{
_parameters.Each(x =>
{
var param = command.AddParameter(x);
sql = sql.UseParameter(param);
});
}
command.AppendQuery(sql);
}
public LinqQueryHandler(IDocumentSchema schema, QueryModel query, IIncludeJoin[] joins, QueryStatistics stats)
: base(BuildSelector(schema, query, joins, stats))
{
_mapping = schema.MappingFor(query).ToQueryableDocument();
_schema = schema;
_query = query;
}
private void apply()
{
var transform = _schema.TransformFor(StoreOptions.PatchDoc);
var document = _schema.MappingFor(typeof(T)).ToQueryableDocument();
var operation = new PatchOperation(transform, document, _fragment, Patch);
_unitOfWork.Patch(operation);
}
public void ConfigureCommand(NpgsqlCommand command)
{
var mapping = _schema.MappingFor(_query).ToQueryableDocument();
var sql = "select (count(*) > 0) as result from " + mapping.Table.QualifiedName + " as d";
var where = _schema.BuildWhereFragment(mapping, _query);
sql = sql.AppendWhere(@where, command);
command.AppendQuery(sql);
}
public JsonQueryHandler(IDocumentSchema schema, QueryModel query)
{
_mapping = schema.MappingFor(query).ToQueryableDocument();
_schema = schema;
_query = query;
var selector = _schema.BuildSelector <string>(_mapping, _query);
_selector = selector;
}
public string DocumentStorageCodeFor <T>()
{
var documentMapping = _schema.MappingFor(typeof(T));
if (documentMapping is DocumentMapping)
{
return(DocumentStorageBuilder.GenerateDocumentStorageCode(new[] { documentMapping.As <DocumentMapping>() }));
}
return($"Docuemnt Storage for {typeof (T).FullName} is not generated");
}
public when_deriving_the_table_definition_from_the_database_schema_Tests()
{
_schema = theStore.Schema;
theMapping = _schema.MappingFor(typeof(User)).As<DocumentMapping>();
theMapping.DuplicateField("UserName");
_storage = _schema.StorageFor(typeof(User));
theDerivedTable = _schema.DbObjects.TableSchema(theMapping);
}
private IEnumerable <Type> GetTypeDependencies(Type type)
{
var documentMapping = _schema.MappingFor(type) as DocumentMapping;
if (documentMapping == null)
{
return(Enumerable.Empty <Type>());
}
return(documentMapping.ForeignKeys.Select(keyDefinition => keyDefinition.ReferenceDocumentType));
}
private Task <T> load <T>(object id) where T : class
{
if (_identityMap.Has <T>(id))
{
return(Task.FromResult(_identityMap.Retrieve <T>(id)));
}
var mapping = _schema.MappingFor(typeof(T)).ToQueryableDocument();
return(AddItem(new LoadByIdHandler <T>(_schema.ResolverFor <T>(), mapping, id)));
}
public when_deriving_the_table_definition_from_the_database_schema_Tests()
{
_schema = theStore.Schema;
theMapping = _schema.MappingFor(typeof(User)).As <DocumentMapping>();
theMapping.DuplicateField("UserName");
_storage = _schema.StorageFor(typeof(User));
theDerivedTable = _schema.DbObjects.TableSchema(theMapping);
}
private Task <T> load <T>(object id) where T : class
{
if (_identityMap.Has <T>(id))
{
return(Task.FromResult(_identityMap.Retrieve <T>(id)));
}
var source = new TaskCompletionSource <T>();
var mapping = _schema.MappingFor(typeof(T));
var parameter = _command.AddParameter(id);
_command.AppendQuery(
$"select {mapping.SelectFields("d")} from {mapping.TableName} as d where id = :{parameter.ParameterName}");
var handler = new SingleResultReader <T>(source, _schema.StorageFor(typeof(T)), _identityMap);
addHandler(handler);
return(source.Task);
}
private CachedQuery buildCachedQuery <TDoc, TOut>(Type queryType, ICompiledQuery <TDoc, TOut> query)
{
Expression expression = query.QueryIs();
var invocation = Expression.Invoke(expression, Expression.Parameter(typeof(IMartenQueryable <TDoc>)));
var queryableDocument = _schema.MappingFor(typeof(TDoc)).ToQueryableDocument();
var setters = findSetters(queryableDocument, queryType, expression, _serializer);
var model = MartenQueryParser.TransformQueryFlyweight.GetParsedQuery(invocation);
validateCompiledQuery(model);
_schema.EnsureStorageExists(typeof(TDoc));
var includeJoins = new IIncludeJoin[0];
if (model.HasOperator <IncludeResultOperator>())
{
var builder = new CompiledIncludeJoinBuilder <TDoc, TOut>(_schema);
includeJoins = builder.BuildIncludeJoins(model, query);
}
// Hokey. Need a non-null stats to trigger LinqQuery into "knowing" that it needs
// to create a StatsSelector decorator
var stats = model.HasOperator <StatsResultOperator>() ? new QueryStatistics() : null;
var handler = _schema.HandlerFactory.BuildHandler <TOut>(model, includeJoins, stats);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
var cachedQuery = new CachedQuery
{
Command = cmd,
ParameterSetters = setters,
Handler = handler,
};
if (model.HasOperator <StatsResultOperator>())
{
var prop = queryType.GetProperties().FirstOrDefault(x => x.PropertyType == typeof(QueryStatistics));
if (prop != null)
{
cachedQuery.StatisticsFinder =
typeof(QueryStatisticsFinder <>).CloseAndBuildAs <IQueryStatisticsFinder>(prop, queryType);
}
}
return(cachedQuery);
}
private void apply()
{
var transform = _schema.TransformFor(StoreOptions.PatchDoc);
var document = _schema.MappingFor(typeof(T)).ToQueryableDocument();
var operation = new PatchOperation(transform, document, _fragment, Patch);
_unitOfWork.Patch(operation);
if (document.DuplicatedFields.Any())
{
_unitOfWork.Add(operation.UpdateDuplicateFieldOperation());
}
}
private IIncludeJoin doGetJoin <TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, IIncludeCallbackResolver <TInclude> callbackResolver) where TInclude : class
{
var idSource = includeOperator.IdSource as Expression <Func <TDoc, object> >;
var joinType = (JoinType)includeOperator.JoinType.Value;
var visitor = new FindMembers();
visitor.Visit(idSource);
var members = visitor.Members.ToArray();
var mapping = _schema.MappingFor(typeof(TDoc)).ToQueryableDocument();
var typeContainer = new IncludeTypeContainer {
IncludeType = includeOperator.Callback.Body.Type
};
var property = typeof(IncludeResultOperator).GetProperty("Callback");
var callback = callbackResolver.Resolve(property, typeContainer);
var included = _schema.MappingFor(typeContainer.IncludeType).ToQueryableDocument();
return(mapping.JoinToInclude(joinType, included, members, callback));
}
public void ConfigureCommand(NpgsqlCommand command)
{
var mapping = _schema.MappingFor(_query.SourceType()).ToQueryableDocument();
var locator = mapping.JsonLocator(_query.SelectClause.Selector);
var field = _operator.ToFormat(locator);
var sql = $"select {field} from {mapping.Table.QualifiedName} as d";
var @where = _schema.BuildWhereFragment(mapping, _query);
sql = sql.AppendWhere(@where, command);
command.AppendQuery(sql);
}
public PatchExpressionTests()
{
var queryable = Substitute.For <IQueryableDocument>();
queryable.DocumentType.Returns(typeof(Target));
var mapping = Substitute.For <IDocumentMapping>();
mapping.ToQueryableDocument().Returns(queryable);
_schema.MappingFor(typeof(Target)).Returns(mapping);
_expression = new PatchExpression <Target>(null, _schema, new UnitOfWork(_schema));
}
private void assertCorrectIdType <T>(object id)
{
var mapping = _schema.MappingFor(typeof(T));
if (id.GetType() != mapping.IdType)
{
if (id.GetType() == typeof(int) && mapping.IdType == typeof(long))
{
return;
}
throw new InvalidOperationException(
$"The id type for {typeof(T).FullName} is {mapping.IdType.Name}, but got {id.GetType().Name}");
}
}
public static IWhereFragment BuildWhereFragment(this IDocumentSchema schema, QueryModel query)
{
var mapping = schema.MappingFor(query.SourceType()).ToQueryableDocument();
var wheres = query.AllBodyClauses().OfType <WhereClause>().ToArray();
if (wheres.Length == 0)
{
return(mapping.DefaultWhereFragment());
}
var @where = wheres.Length == 1
? schema.Parser.ParseWhereFragment(mapping, wheres.Single().Predicate)
: new CompoundWhereFragment(schema.Parser, mapping, "and", wheres);
return(mapping.FilterDocuments(query, @where));
}
public void ConfigureCommand <T>(NpgsqlCommand cmd, string sql, object[] parameters)
{
var mapping = _schema.MappingFor(typeof(T));
if (!sql.Contains("select", StringComparison.OrdinalIgnoreCase))
{
var tableName = mapping.TableName;
sql = "select data from {0} {1}".ToFormat(tableName, sql);
}
parameters.Each(x =>
{
var param = cmd.AddParameter(x);
sql = sql.UseParameter(param);
});
cmd.AppendQuery(sql);
}
public OneResultHandler(int rowLimit, IDocumentSchema schema, QueryModel query, IIncludeJoin[] joins, bool canBeNull = true, bool canBeMultiples = true)
{
_rowLimit = rowLimit;
_mapping = schema.MappingFor(query).ToQueryableDocument();
_schema = schema;
_query = query;
_canBeNull = canBeNull;
_canBeMultiples = canBeMultiples;
var selector = _schema.BuildSelector <T>(_mapping, _query);
if (joins.Any())
{
selector = new IncludeSelector <T>(schema, selector, joins);
}
_selector = selector;
}
public static ISelector <T> BuildSelector(IDocumentSchema schema, QueryModel query,
IIncludeJoin[] joins, QueryStatistics stats)
{
var mapping = schema.MappingFor(query).ToQueryableDocument();
var selector = schema.BuildSelector <T>(mapping, query);
if (stats != null)
{
selector = new StatsSelector <T>(stats, selector);
}
if (joins.Any())
{
selector = new IncludeSelector <T>(schema, selector, joins);
}
return(selector);
}
public void ConfigureCommand(NpgsqlCommand command)
{
var sql = _sql;
if (!sql.Contains("select", StringComparison.OrdinalIgnoreCase))
{
var mapping = _schema.MappingFor(typeof(T)).ToQueryableDocument();
var tableName = mapping.Table.QualifiedName;
sql = "select data from {0} {1}".ToFormat(tableName, sql);
}
_parameters.Each(x =>
{
var param = command.AddParameter(x);
sql = sql.UseParameter(param);
});
command.AppendQuery(sql);
}
private NpgsqlCommand BuildCommand <T>(string sql, params object[] parameters)
{
var cmd = new NpgsqlCommand();
var mapping = _schema.MappingFor(typeof(T));
if (!sql.Contains("select", StringComparison.OrdinalIgnoreCase))
{
var tableName = mapping.TableName;
sql = "select data from {0} {1}".ToFormat(tableName, sql);
}
parameters.Each(x =>
{
var param = cmd.AddParameter(x);
sql = sql.UseParameter(param);
});
cmd.CommandText = sql;
return(cmd);
}
private CachedQuery buildCachedQuery <TDoc, TOut>(Type queryType, ICompiledQuery <TDoc, TOut> query)
{
Expression expression = query.QueryIs();
var invocation = Expression.Invoke(expression, Expression.Parameter(typeof(IMartenQueryable <TDoc>)));
var setters = findSetters(_schema.MappingFor(typeof(TDoc)).ToQueryableDocument(), queryType, expression, _serializer.EnumStorage);
var model = MartenQueryParser.TransformQueryFlyweight.GetParsedQuery(invocation);
_schema.EnsureStorageExists(typeof(TDoc));
var includeJoins = new IIncludeJoin[0];
if (model.HasOperator <IncludeResultOperator>())
{
var builder = new CompiledIncludeJoinBuilder <TDoc, TOut>(_schema);
includeJoins = builder.BuildIncludeJoins(model, query);
}
if (model.HasOperator <StatsResultOperator>())
{
SetStats(query, model);
}
var handler = _schema.HandlerFactory.BuildHandler <TOut>(model, includeJoins, Stats);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
return(new CachedQuery
{
Command = cmd,
ParameterSetters = setters,
Handler = handler
});
}
