Analyse the tables involved in an IQueryable - entity-framework-core

Question

I have a requirement where I need to look at all of the tables involved in a query about to be run by EF Core via an IQueryable
Has anyone ever been able to do this?
Lets use an example
var cars = await (from car in DbContext.Cars
from salesperson in DbContext.SalesPersons.Where(x=>x.Id == car.SalesPersonId)
.Select(x=>x.Car));
Lets now say that there is a CountryId column in the salespersons table and the Cars table
I need to detect that the IQueryable above is using Cars and SalesPerson
Then I will add to the IQueryable so it becomes
var cars = await (from car in DbContext.Cars
from salesperson in DbContext.SalesPersons.Where(x=>x.Id == car.SalesPersonId).Select(x=>x.Car)
.Where(car.CountryId = 1).Where(salesPerson.CountryId = 1);
So we are basically adding a filter at runtime automatically
Cheers
Paul

Answer 1

It is not needed to analyze LINQ query for your task. For filtering by tenant there is Global Query Filters. After configuring EF Core should apply filter for every entity which has defined Query Filter.
public class TenantContext : DbContext
{
public int? TenantId { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
... // entities configuration
modelBuilder.Entity<Some>().HasQueryFilter(e => TenantId == null || TenantId == e.TenantId)
}
}
All that you need before querying data - set TenantId for context
context.TeantId = 2;
context.Some.ToList() // table will be filtered by TenantId == 2
I have prepared small sample how to apply tenant filter for all entities in one function call:
public class TenantContext : DbContext
{
public int? TenantId { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
... // entities configuration
ApplyTenantQueryFilters(modelBuilder, "TenantId", () => TenantId);
}
private void ApplyTenantQueryFilters<TProp>(ModelBuilder builder, string tenantPropName, Expression<Func<TProp>> tenantPropExpr)
{
foreach (var entityType in builder.Model.GetEntityTypes())
{
var tenantProp = entityType.GetProperties().FirstOrDefault(p => p.Name == tenantPropName);
if (tenantProp == null)
continue;
var entityParam = Expression.Parameter(entityType.ClrType, "e");
var contextTenantPropAccess = tenantPropExpr.Body;
var propertyExpression = GetPropertyExpression(entityParam, tenantProp);
if (propertyExpression.Type != contextTenantPropAccess.Type)
propertyExpression = Expression.Convert(propertyExpression, contextTenantPropAccess.Type);
// ctx.TenantId == null || ctx.TenantId == e.TenantId
var filterBody = (Expression)Expression.OrElse(
Expression.Equal(contextTenantPropAccess, Expression.Default(contextTenantPropAccess.Type)),
Expression.Equal(contextTenantPropAccess,
propertyExpression));
var filterLambda = entityType.GetQueryFilter();
// we have to combine filters
if (filterLambda != null)
{
filterBody = ReplacingExpressionVisitor.Replace(entityParam, filterLambda.Parameters[0], filterBody);
filterBody = Expression.AndAlso(filterLambda.Body, filterBody);
filterLambda = Expression.Lambda(filterBody, filterLambda.Parameters);
}
else
{
filterLambda = Expression.Lambda(filterBody, entityParam);
}
entityType.SetQueryFilter(filterLambda);
}
}
private static Expression GetPropertyExpression(Expression objExpression, IProperty property)
{
Expression propExpression;
if (property.PropertyInfo == null)
{
// 'property' is Shadow property, so call via EF.Property(e, "name")
propExpression = Expression.Call(typeof(EF), nameof(EF.Property), new[] { property.ClrType },
objExpression, Expression.Constant(property.Name));
}
else
{
propExpression = Expression.MakeMemberAccess(objExpression, property.PropertyInfo);
}
return propExpression;
}
}