protected override ISqlFragment buildWhereFragment(IMartenSession session)
{
if (WhereClauses.Count == 0)
{
return(_storage.DefaultWhereFragment());
}
var parser = new WhereClauseParser(session, this);
ISqlFragment where = null;
switch (WhereClauses.Count)
{
case 0:
where = _storage.DefaultWhereFragment();
break;
case 1:
where = parser.Build(WhereClauses.Single());
break;
default:
var wheres = WhereClauses.Select(x => parser.Build(x)).ToArray();
where = new CompoundWhereFragment("and", wheres);
break;
}
return(_storage.FilterDocuments(null, where));
}
protected override void configure(CommandBuilder builder)
{
_storage.WriteSelectClause(builder);
var wheres = filters().ToArray();
switch (wheres.Length)
{
case 0:
break;
case 1:
builder.Append(" WHERE ");
wheres[0].Apply(builder);
break;
default:
var where = CompoundWhereFragment.And(wheres);
builder.Append(" WHERE ");
where.Apply(builder);
break;
}
builder.Append(" ORDER BY d.seq_id");
if (Limit > 0)
{
builder.Append(" LIMIT ");
builder.AppendParameter(Limit);
}
}
public EventDocumentStorage(StoreOptions options)
{
Events = options.EventGraph;
_mapping = new EventQueryMapping(options);
FromObject = _mapping.TableName.QualifiedName;
Fields = _mapping;
_serializer = options.Serializer();
IdType = Events.StreamIdentity == StreamIdentity.AsGuid ? typeof(Guid) : typeof(string);
TenancyStyle = options.Events.TenancyStyle;
// The json data column has to go first
var table = new EventsTable(Events);
var columns = table.SelectColumns();
_fields = columns.Select(x => x.Name).ToArray();
_selectClause = $"select {_fields.Join(", ")} from {Events.DatabaseSchemaName}.mt_events as d";
_defaultWhere = Events.TenancyStyle == TenancyStyle.Conjoined
? CompoundWhereFragment.And(IsNotArchivedFilter.Instance, CurrentTenantFilter.Instance)
: IsNotArchivedFilter.Instance;
}
public void query_using_where_fragment()
{
var user1 = new User {
UserName = "******"
};
var user2 = new User {
UserName = "******"
};
var user3 = new User {
UserName = "******"
};
var user4 = new User {
UserName = "******"
};
using var session = theStore.OpenSession();
session.Store(user1, user2, user3, user4);
session.SaveChanges();
var whereFragment = CompoundWhereFragment.And();
whereFragment.Add(new WhereFragment("d.data ->> 'UserName' != ?", "baz"));
whereFragment.Add(new WhereFragment("d.data ->> 'UserName' != ?", "jack"));
// no where clause
session.Query <User>().Where(x => x.MatchesSql(whereFragment)).OrderBy(x => x.UserName).Select(x => x.UserName)
.ToList().ShouldHaveTheSameElementsAs("bar", "foo");
// with a where clause
session.Query <User>().Where(x => x.UserName != "bar" && x.MatchesSql(whereFragment))
.OrderBy(x => x.UserName)
.ToList()
.Select(x => x.UserName)
.Single().ShouldBe("foo");
}
public ISqlFragment FilterDocuments(QueryModel model, ISqlFragment query)
{
var extras = extraFilters(query).ToArray();
var extraCompound = new CompoundWhereFragment("and", extras);
return new CompoundWhereFragment("and", query, extraCompound);
}
public ISqlFragment determineWhereFragment()
{
var defaults = defaultFilters().ToArray();
return(defaults.Length switch
{
0 => null,
1 => defaults[0],
_ => CompoundWhereFragment.And(defaults)
});
private void determineDefaultWhereFragment()
{
var defaults = defaultFilters().ToArray();
_defaultWhere = defaults.Length switch
{
0 => null,
1 => defaults[0],
_ => CompoundWhereFragment.And(defaults)
};
}
public ISqlFragment FilterDocuments(QueryModel?model, ISqlFragment query)
{
var extras = extraFilters(query).ToList();
if (extras.Count > 0)
{
extras.Add(query);
return(CompoundWhereFragment.And(extras));
}
return(query);
}
public static ISqlFragment CombineFragments(this IList <ISqlFragment> fragments)
{
switch (fragments.Count)
{
case 0:
return(null);
case 1:
return(fragments.Single());
default:
return(CompoundWhereFragment.And(fragments));
}
}
public IDeletion DeleteForId(TId id, string tenant)
{
if (TenancyStyle == TenancyStyle.Conjoined)
{
return(new Deletion(this, DeleteFragment)
{
Where = CompoundWhereFragment.And(new SpecificTenantFilter(tenant), ByIdFilter(id)),
Id = id
});
}
return(new Deletion(this, DeleteFragment)
{
Where = ByIdFilter(id),
Id = id
});
}
private void buildCompoundWhereFragment(BinaryExpression node, string separator)
{
var original = _holder;
var compound = CompoundWhereFragment.For(separator);
_holder.Register(compound);
_holder = compound;
Visit(node.Left);
_holder = compound;
Visit(node.Right);
_holder = original;
}
public void DeleteWhere <T>(Expression <Func <T, bool> > expression)
{
assertNotDisposed();
var parser = new MartenExpressionParser(Options.Serializer(), Options);
var model = MartenQueryParser.Flyweight.GetParsedQuery(Query <T>().Where(expression).As <MartenLinqQueryable <T> >().Expression);
var storage = StorageFor <T>();
var whereClauses = model.BodyClauses.OfType <WhereClause>().ToArray();
// This is duplicated logic
IWhereFragment where = null;
switch (whereClauses.Length)
{
case 0:
where = storage.DefaultWhereFragment();
break;
case 1:
where = parser.ParseWhereFragment(storage.Fields, whereClauses.Single().Predicate);
break;
default:
where = new CompoundWhereFragment(parser, storage.Fields, "and", whereClauses);
break;
}
where = storage.FilterDocuments(null, where);
var deletion = storage.DeleteForWhere(@where);
_unitOfWork.Add(deletion);
}
