public string ToJsonBuildObjectPair(IQueryableDocument mapping)
{
var field = mapping.FieldFor(Field.ToArray());
var locator = field.SelectionLocator ?? field.SqlLocator;
return($"'{Name}', {locator}");
}
public ISelector <T> ToSelector <T>(IDocumentSchema schema, IQueryableDocument mapping)
{
if (_selectionType == SelectionType.AsJson && _target == null)
{
return(new JsonSelector().As <ISelector <T> >());
}
if (_selectionType == SelectionType.AsJson && _target != null)
{
return(_target.ToJsonSelector <T>(mapping));
}
if (_selectionType == SelectionType.TransformToJson)
{
var transform = schema.TransformFor(_transformName);
return(new TransformToJsonSelector(transform, mapping).As <ISelector <T> >());
}
if (_selectionType == SelectionType.TransformTo)
{
var transform = schema.TransformFor(_transformName);
return(new TransformToTypeSelector <T>(transform, mapping));
}
if (_target == null || _target.Type != typeof(T))
{
return(new SingleFieldSelector <T>(mapping, _currentField.Members.Reverse().ToArray()));
}
return(_target.ToSelector <T>(mapping));
}
private IWhereFragment buildSimpleWhereClause(IQueryableDocument mapping, BinaryExpression binary)
{
var isValueExpressionOnRight = binary.Right.IsValueExpression();
var isSubQuery = isValueExpressionOnRight
? binary.Left is SubQueryExpression
: binary.Right is SubQueryExpression;
if (isSubQuery)
{
var jsonLocatorExpression = isValueExpressionOnRight ? binary.Left : binary.Right;
var valueExpression = isValueExpressionOnRight ? binary.Right : binary.Left;
var op = _operators[binary.NodeType];
return(buildChildCollectionQuery(mapping, jsonLocatorExpression.As <SubQueryExpression>().QueryModel, valueExpression, op));
}
var parser = _supplementalParsers.OfType <IExpressionParser <BinaryExpression> >()?.FirstOrDefault(x => x.Matches(binary));
if (parser != null)
{
var where = parser.Parse(mapping, _serializer, binary);
return(where);
}
throw new NotSupportedException("Marten does not yet support this type of Linq query");
}
public static ISelector <T> BuildSelector <T>(this IDocumentSchema schema, IQueryableDocument mapping, QueryModel query)
{
var selectable = query.AllResultOperators().OfType <ISelectableOperator>().FirstOrDefault();
if (selectable != null)
{
return(selectable.BuildSelector <T>(schema, mapping));
}
if (query.SelectClause.Selector.Type == query.SourceType())
{
if (typeof(T) == typeof(string))
{
return((ISelector <T>) new JsonSelector());
}
// I'm so ashamed of this hack, but "simplest thing that works"
if (typeof(T) == typeof(IEvent))
{
return(mapping.As <EventQueryMapping>().Selector.As <ISelector <T> >());
}
var resolver = schema.ResolverFor <T>();
return(new WholeDocumentSelector <T>(mapping, resolver));
}
var visitor = new SelectorParser(query);
visitor.Visit(query.SelectClause.Selector);
return(visitor.ToSelector <T>(schema, mapping));
}
public SelectManyQuery(IDocumentSchema schema, IQueryableDocument mapping, QueryModel query, int index)
{
Index = index;
_schema = schema;
_query = query;
_from = query.BodyClauses[index - 1].As <AdditionalFromClause>();
var members = FindMembers.Determine(_from.FromExpression);
_field = mapping.FieldFor(members);
IsDistinct = query.HasOperator <DistinctResultOperator>();
var next = query.BodyClauses.Skip(index + 1).FirstOrDefault(x => x is AdditionalFromClause);
if (next != null)
{
throw new NotSupportedException("Not yet supporting SelectMany().SelectMany()");
}
else
{
_take = _query.BodyClauses.Count - index;
}
_tableAlias = "sub" + Index;
_documentType = _field.MemberType.DeriveElementType();
_document = _schema.StoreOptions.GetChildDocument(_tableAlias + ".x", _documentType);
}
public LinqQuery(DocumentStore store, QueryModel model, IIncludeJoin[] joins, QueryStatistics stats)
{
Model = model;
_store = store;
_joins = joins;
// TODO -- going to have to push in the ITenant eventually
_mapping = store.Tenancy.Default.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(store, _mapping, model, i + 1);
break;
}
}
Selector = BuildSelector(joins, stats, _subQuery, joins);
SourceType = Model.SourceType();
Where = buildWhereFragment();
}
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();
}
public static string[] ToSelectFields(string tableAlias, IQueryableDocument includedMapping, ISelector <TSearched> inner)
{
var innerFields = inner.SelectFields();
var outerFields = includedMapping.SelectFields().Select(x => $"{tableAlias}.{x}");
return(innerFields.Concat(outerFields).ToArray());
}
public ISelector <T> ToSelector <T>(string dataLocator, ITenant tenant, IQueryableDocument mapping)
{
if (_selectionType == SelectionType.AsJson && _target == null)
{
return(new JsonSelector().As <ISelector <T> >());
}
if (_selectionType == SelectionType.AsJson && _target != null)
{
return(_target.ToJsonSelector <T>(mapping));
}
if (_selectionType == SelectionType.TransformToJson)
{
var transform = tenant.TransformFor(_transformName);
return(new TransformToJsonSelector(dataLocator, transform, mapping).As <ISelector <T> >());
}
if (_selectionType == SelectionType.TransformTo)
{
var transform = tenant.TransformFor(_transformName);
return(new TransformToTypeSelector <T>(dataLocator, transform, mapping));
}
if (_target == null || _target.Type != typeof(T))
{
return(new SingleFieldSelector <T>(mapping, _currentField.ToArray(), _distinct));
}
return(_target.ToSelector <T>(mapping, _distinct));
}
public void AppendJoin(CommandBuilder sql, string rootTableAlias, IQueryableDocument document)
{
var locator = document == null
? _field.LocatorFor(rootTableAlias)
: document.FieldFor(_field.Members).LocatorFor(rootTableAlias);
var joinOperator = JoinType == JoinType.Inner ? InnerJoin : OuterJoin;
sql.Append(joinOperator);
sql.Append(" ");
if (IsSoftDeleted)
{
sql.Append("(select * from ");
sql.Append(_mapping.Table.QualifiedName);
sql.Append(" where ");
sql.Append(DocumentMapping.DeletedColumn);
sql.Append(" = False)");
}
else
{
sql.Append(_mapping.Table.QualifiedName);
}
sql.Append(" as ");
sql.Append(TableAlias);
sql.Append(" ON ");
sql.Append(locator);
sql.Append(" = ");
sql.Append(TableAlias);
sql.Append(".id");
}
public string ToJsonBuildObjectPair(IQueryableDocument mapping)
{
var locator = mapping.FieldFor(Field.Members).SelectionLocator;
return($"'{Setter.Name}', {locator}");
}
public PatchOperation(TransformFunction transform, IQueryableDocument document, IWhereFragment fragment,
IDictionary<string, object> patch)
{
_transform = transform;
_document = document;
_fragment = fragment;
_patch = patch;
}
// Polyfill for the Async Daemon where it doesn't do any harm
public static string ToSelectClause(this ISelector selector, IQueryableDocument mapping)
{
var builder = new CommandBuilder(new NpgsqlCommand());
selector.WriteSelectClause(builder, mapping);
return(builder.ToString());
}
public PatchOperation(TransformFunction transform, IQueryableDocument document, IWhereFragment fragment,
IDictionary <string, object> patch)
{
_transform = transform;
_document = document;
_fragment = fragment;
_patch = patch;
}
public ChildCollectionWhereVisitor(ISerializer serializer, SubQueryExpression expression, Action <IWhereFragment> registerFilter, IQueryableDocument mapping)
{
_serializer = serializer;
_expression = expression;
_query = expression.QueryModel;
_registerFilter = registerFilter;
_mapping = mapping;
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var members = FindMembers.Determine(expression);
var field = mapping.FieldFor(members);
return(new WhereFragment($"({field.SelectionLocator} is null or jsonb_array_length({field.SelectionLocator}) = 0)"));
}
public void WriteSelectClause(CommandBuilder sql, IQueryableDocument mapping)
{
sql.Append("select ");
sql.Append(_fieldName);
sql.Append(" from ");
sql.Append(_document.Table.QualifiedName);
sql.Append(" as d");
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var members = FindMembers.Determine(expression);
var field = mapping.FieldFor(members);
return new WhereFragment($"({field.SelectionLocator} is null or jsonb_array_length({field.SelectionLocator}) = 0)");
}
public static string ToOrderClause(this Ordering clause, IQueryableDocument mapping)
{
var locator = mapping.JsonLocator(clause.Expression);
return(clause.OrderingDirection == OrderingDirection.Asc
? locator
: locator + " desc");
}
public IncludeJoin(IQueryableDocument mapping, string joinText, string tableAlias, Action <T> callback)
{
JoinText = joinText;
_mapping = mapping;
_callback = callback;
TableAlias = tableAlias;
}
public PatchOperation(TransformFunction transform, IQueryableDocument document, ISqlFragment fragment,
IDictionary <string, object> patch, ISerializer serializer)
{
_transform = transform;
_document = document;
_fragment = fragment;
_patch = patch;
_serializer = serializer;
}
public IncludeSelector(string tableAlias, IQueryableDocument includedMapping, Action <TIncluded> callback, ISelector <TSearched> inner, IDocumentStorage <TIncluded> documentStorage)
: base(ToSelectFields(tableAlias, includedMapping, inner))
{
_callback = callback;
_inner = inner;
storage = documentStorage;
StartingIndex = _inner.SelectFields().Length;
}
public IncludeJoin(IQueryableDocument mapping, IField field, string tableAlias, Action <T> callback, JoinType joinType)
{
_mapping = mapping;
_field = field;
_callback = callback;
TableAlias = tableAlias;
JoinType = joinType;
}
private static IList <IDbParameterSetter> findSetters(IQueryableDocument mapping, Type queryType, Expression expression, EnumStorage enumStorage)
{
var visitor = new CompiledQueryMemberExpressionVisitor(mapping, queryType, enumStorage);
visitor.Visit(expression);
var parameterSetters = visitor.ParameterSetters;
return(parameterSetters);
}
public IncludeSelector(string tableAlias, IQueryableDocument includedMapping, Action <TIncluded> callback, ISelector <TSearched> inner, IResolver <TIncluded> resolver)
: base(ToSelectFields(tableAlias, includedMapping, inner))
{
_callback = callback;
_inner = inner;
_resolver = resolver;
StartingIndex = _inner.SelectFields().Length;
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, BinaryExpression expression)
{
var isValueExpressionOnRight = expression.Right.IsValueExpression();
var jsonLocatorExpression = isValueExpressionOnRight ? expression.Left : expression.Right;
var valueExpression = isValueExpressionOnRight ? expression.Right : expression.Left;
var members = FindMembers.Determine(jsonLocatorExpression);
var field = mapping.FieldFor(members);
var value = field.GetValue(valueExpression);
var jsonLocator = field.SqlLocator;
var useContainment = mapping.PropertySearching == PropertySearching.ContainmentOperator || field.ShouldUseContainmentOperator();
var isDuplicated = (mapping.FieldFor(members) is DuplicatedField);
if (useContainment &&
expression.NodeType == ExpressionType.Equal && value != null && !isDuplicated)
{
return(new ContainmentWhereFragment(serializer, expression, _wherePrefix));
}
if (value == null)
{
var sql = expression.NodeType == ExpressionType.NotEqual
? $"({jsonLocator}) is not null"
: $"({jsonLocator}) {_isOperator} null";
return(new WhereFragment(sql));
}
var op = _operators[expression.NodeType];
if (jsonLocatorExpression.NodeType == ExpressionType.Modulo)
{
var byValue = moduloByValue((isValueExpressionOnRight ? expression.Left : expression.Right) as BinaryExpression);
var moduloFormat = isValueExpressionOnRight ? "{0} % {1} {2} ?" : "? {2} {0} % {1}";
return(new WhereFragment(moduloFormat.ToFormat(jsonLocator, byValue, op), value));
}
// ! == -> <>
if (expression.Left.NodeType == ExpressionType.Not && expression.NodeType == ExpressionType.Equal)
{
op = _operators[ExpressionType.NotEqual];
}
var whereFormat = isValueExpressionOnRight ? "{0} {1} ?" : "? {1} {0}";
return(new WhereFragment($"{_wherePrefix}{whereFormat.ToFormat(jsonLocator, op)}", value));
return(value == null ? new WhereFragment($"({jsonLocator}) {_isOperator} null") : new WhereFragment($"{_wherePrefix}({jsonLocator}) {op} ?", value));
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var members = FindMembers.Determine(expression);
var locator = mapping.FieldFor(members).SqlLocator;
var value = expression.Arguments.Last().Value();
return(new WhereFragment($"{locator} ~~* ?", value.As <string>()));
}
public void WriteSelectClause(CommandBuilder sql, IQueryableDocument mapping)
{
_inner.WriteSelectClause(sql, mapping);
foreach (var @join in _joins)
{
sql.Append(" ");
@join.AppendJoin(sql, "d", mapping);
}
}
public static string JsonLocator(this IQueryableDocument mapping, Expression expression)
{
var visitor = new FindMembers();
visitor.Visit(expression);
var field = mapping.FieldFor(visitor.Members);
return(field.SqlLocator);
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var locator = GetLocator(mapping, expression);
var value = expression.Arguments.OfType<ConstantExpression>().FirstOrDefault();
if (value == null) throw new BadLinqExpressionException("Could not extract string value from {0}.".ToFormat(expression), null);
var stringOperator = GetOperator(expression);
return new WhereFragment("{0} {1} ?".ToFormat(locator, stringOperator), FormatValue(expression.Method, value.Value as string));
}
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 static string ToOrderClause(this QueryModel query, IQueryableDocument mapping)
{
var orders = query.BodyClauses.OfType <OrderByClause>().SelectMany(x => x.Orderings).ToArray();
if (!orders.Any())
{
return(string.Empty);
}
return(" order by " + orders.Select(c => ToOrderClause(c, mapping)).Join(", "));
}
// TODO -- pull this out somewhere else
private IWhereFragment buildSimpleWhereClause(IQueryableDocument mapping, BinaryExpression binary)
{
var isValueExpressionOnRight = binary.Right.IsValueExpression();
var jsonLocatorExpression = isValueExpressionOnRight ? binary.Left : binary.Right;
var valueExpression = isValueExpressionOnRight ? binary.Right : binary.Left;
var op = _operators[binary.NodeType];
var isSubQuery = isValueExpressionOnRight
? binary.Left is SubQueryExpression
: binary.Right is SubQueryExpression;
if (isSubQuery)
{
return buildChildCollectionQuery(mapping, jsonLocatorExpression.As<SubQueryExpression>().QueryModel, valueExpression, op);
}
var members = FindMembers.Determine(jsonLocatorExpression);
var field = mapping.FieldFor(members);
var value = field.GetValue(valueExpression);
var jsonLocator = field.SqlLocator;
var useContainment = mapping.PropertySearching == PropertySearching.ContainmentOperator || field.ShouldUseContainmentOperator();
var isDuplicated = (mapping.FieldFor(members) is DuplicatedField);
if (useContainment &&
binary.NodeType == ExpressionType.Equal && value != null && !isDuplicated)
{
return new ContainmentWhereFragment(_serializer, binary);
}
if (value == null)
{
var sql = binary.NodeType == ExpressionType.NotEqual
? $"({jsonLocator}) is not null"
: $"({jsonLocator}) is null";
return new WhereFragment(sql);
}
if (jsonLocatorExpression.NodeType == ExpressionType.Modulo)
{
var moduloByValue = MartenExpressionParser.moduloByValue(binary);
return new WhereFragment("{0} % {1} {2} ?".ToFormat(jsonLocator, moduloByValue, op), value);
}
return new WhereFragment("{0} {1} ?".ToFormat(jsonLocator, op), value);
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
MemberInfo[] members = FindMembers.Determine(expression);
string locator = mapping.FieldFor(members).SqlLocator;
object values = expression.Arguments.Last().Value();
string json = serializer.ToJson(values);
return(new CustomizableWhereFragment($"{locator} @> ?", "?", Tuple.Create <object, NpgsqlDbType?>(json, NpgsqlDbType.Jsonb)));
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var finder = new FindMembers();
finder.Visit(expression);
var members = finder.Members;
var locator = mapping.FieldFor(members).SqlLocator;
var values = expression.Object.Value();
return new WhereFragment($"{locator} = ANY(?)", values);
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var members = FindMembers.Determine(expression);
var locator = mapping.FieldFor(members).SqlLocator;
var values = expression.Arguments.Last().Value();
if (members.Last().GetMemberType().GetTypeInfo().IsEnum)
{
return new EnumIsOneOfWhereFragment(values, serializer.EnumStorage, locator);
}
return new WhereFragment($"{locator} = ANY(?)", values);
}
/// <summary>
/// Returns a locator for the member being queried upon
/// </summary>
/// <param name="mapping"></param>
/// <param name="expression"></param>
/// <returns></returns>
protected virtual string GetLocator(IQueryableDocument mapping, MethodCallExpression expression)
{
if (!expression.Method.IsStatic && expression.Object != null && expression.Object.NodeType != ExpressionType.Constant)
{
// x.member.Equals(...)
return mapping.JsonLocator(expression.Object);
}
if (expression.Arguments[0].NodeType == ExpressionType.Constant)
{
// string.Equals("value", x.member)
return mapping.JsonLocator(expression.Arguments[1]);
}
// string.Equals(x.member, "value")
return mapping.JsonLocator(expression.Arguments[0]);
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var finder = new FindMembers();
finder.Visit(expression);
var members = finder.Members;
var fieldlocator = mapping.FieldFor(members).SqlLocator;
if (IsCollectionContainsWithStringKey(expression.Method))
{
return QueryFromICollectionContains(expression, fieldlocator, serializer);
}
else if (IsDictionaryContainsKey(expression.Method))
{
return QueryFromDictionaryContainsKey(expression, fieldlocator);
}
else throw new NotImplementedException("Could not understand the format of the dictionary access");
}
public IWhereFragment ParseWhereFragment(IQueryableDocument mapping, Expression expression)
{
if (expression is LambdaExpression)
{
expression = expression.As<LambdaExpression>().Body;
}
var visitor = new WhereClauseVisitor(this, mapping);
visitor.Visit(expression);
var whereFragment = visitor.ToWhereFragment();
if (whereFragment == null)
{
throw new NotSupportedException("Marten does not (yet) support this Linq query type");
}
return whereFragment;
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var locator = mapping.FieldFor(new MemberInfo[] {_property}).SqlLocator;
return new WhereFragment($"{locator} = 'Blue'");
}
public CompoundWhereFragment(MartenExpressionParser parser, IQueryableDocument mapping, string separator, IEnumerable<WhereClause> wheres)
{
_separator = separator;
_children = wheres.Select(x => parser.ParseWhereFragment(mapping, x.Predicate)).ToArray();
}
public NotVisitor(MartenExpressionParser.WhereClauseVisitor parent, IQueryableDocument mapping, Action<IWhereFragment> callback)
{
_parent = parent;
_mapping = mapping;
_callback = callback;
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
return _whereFragment;
}
private IWhereFragment buildChildCollectionQuery(IQueryableDocument mapping, QueryModel query, Expression valueExpression, string op)
{
var members = FindMembers.Determine(query.MainFromClause.FromExpression);
var field = mapping.FieldFor(members);
if (query.HasOperator<CountResultOperator>())
{
var value = field.GetValue(valueExpression);
return new WhereFragment($"jsonb_array_length({field.SqlLocator}) {op} ?", value);
}
throw new NotSupportedException("Marten does not yet support this type of Linq query against child collections");
}
public WhereClauseVisitor(MartenExpressionParser parent, IQueryableDocument mapping)
{
_parent = parent;
_mapping = mapping;
_register.Push(x => _top = x);
}
public IWhereFragment Parse(IQueryableDocument mapping, ISerializer serializer, MethodCallExpression expression)
{
var value = expression.Arguments.Single().Value();
return ContainmentWhereFragment.SimpleArrayContains(FindMembers.Determine(expression.Object) ,serializer, expression.Object, value);
}