internal IQueryable <INullEntity> CreateDbContextEntitySet()
{
var prov = new EntityQueryProvider(this);
var entSet = new EntitySet <INullEntity>(prov);
return(entSet);
}
internal void InitRepository(EntityRepository repository)
{
_repository = repository;
_linqProvider = new EntityQueryProvider {
_repository = repository
};
}
public FakeSet()
{
var a = new Mock <IQueryCompiler>();
_pr = new EntityQueryProvider(a.Object);
_inner = new List <T>().AsQueryable();
}
public CompiledQuery(EntityQueryProvider provider, QueryCompiler queryCompiler,
object[] args, object compiledBackendMethod, SimpleType queryableType) : base(provider)
{
this.queryCompiler = queryCompiler;
this.compiledBackendMethod = compiledBackendMethod;
this.args = args;
this.queryableType = queryableType;
}
/// <summary>
/// 初始化 <see cref="DefaultRepositoryProvider"/> 类的新实例。
/// </summary>
/// <param name="context"></param>
public DefaultRepositoryProvider(InternalContext context)
{
this.context = context;
var entityQueryProvider = new EntityQueryProvider(context);
context.As <IEntityPersistentInstanceContainer>(s => entityQueryProvider.InitializeInstanceName(s.InstanceName));
QueryProvider = new QueryProvider(entityQueryProvider);
Queryable = new QuerySet <TEntity>(QueryProvider, null);
}
/// <summary>
/// 初始化 <see cref="DefaultRepositoryProvider"/> 类的新实例。
/// </summary>
/// <param name="service"></param>
public DefaultRepositoryProvider(IContextService service)
{
context = (DefaultContextService)service;
var entityQueryProvider = new EntityQueryProvider(this.context);
context.As((Action <IEntityPersistentInstanceContainer>)(s => entityQueryProvider.InitializeInstanceName(s.InstanceName)));
QueryProvider = new QueryProvider(entityQueryProvider);
Queryable = new QuerySet <TEntity>(QueryProvider);
}
public IncludableQueryProvider(EntityQueryProvider baseProvider)
// Passing null is fine here because we override all the execute methods to use our wrapped object,
// so the underlying class won't care if the _queryCompiler is missing.
// IMPORTANT: Don't override the CreateQuery methods to use the baseProvider - we want the provider used there to be ourself.
// Otherwise, the base provider would end up getting used for subsequent queries.
// The alternative to doing this is to get the IQueryCompiler from the baseProvider with reflection,
// which is a bit less nice, but would let us get rid of all the method overrides:
// base((IQueryCompiler)typeof(EntityQueryProvider).GetField("_queryCompiler", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(baseProvider))
: base(null)
{
_baseProvider = baseProvider;
}
public static DbContext GetDbContext <T>(IQueryable <T> queryable) where T : class
{
EntityQueryProvider queryProvider
= queryable.Provider as EntityQueryProvider
?? throw new ArgumentException(nameof(queryable), $"The \"{typeof(IQueryable<>).FullName}\" is not of type \"{typeof(EntityQueryProvider).FullName}\".");
return(queryProvider.GetQueryCompiler()
.GetDatabase()
.GetDependencies()
.QueryCompilationContextFactory
.GetDependencies()
.CurrentContext.Context);
}
private void AssertQuery <T>(Times times, Expression <Func <DbSet <T>, IQueryable> > expression) where T : class, new()
{
var query = expression.Compile()(new DbSet <T>(Mock.Of <DbContext>()));
var queryModel = new EntityQueryProvider(new EntityQueryExecutor(Mock.Of <DbContext>())).GenerateQueryModel(query.Expression);
_connection.Setup(s => s.ExecuteRequest(
It.IsAny <QueryTableRequest <T> >(),
It.IsAny <ILogger>()))
.Returns(NewTCallback <T>);
_dataStore.Query <T>(queryModel).ToList();
_connection.Verify(s => s.ExecuteRequest(
It.IsAny <QueryTableRequest <T> >(),
It.IsAny <ILogger>()),
times);
}
internal protected virtual IQueryable <TEntity> CreateEntitySet <TEntity>(LockType lockType) where TEntity : class
{
var entInfo = GetEntityInfo(typeof(TEntity));
var prov = new EntityQueryProvider(this);
var entSet = new EntitySet <TEntity>(prov, lockType);
//Check filters
var pred = Context.QueryFilter.GetPredicate <TEntity>();
if (pred != null)
{
return(entSet.Where(pred.Where));
}
else
{
return(entSet);
}
}
public EntityRepositoryQueryBase()
{
_linqProvider = new EntityQueryProvider(this);
}
public L2SQuery(EntityQueryProvider provider, Expression expression)
: base(provider, expression)
{
}
public L2SQuery(EntityQueryProvider provider)
: base(provider)
{
}
public static QueryCompiler GetQueryCompiler(this EntityQueryProvider entityQueryProvider)
{
Check.NotNull(entityQueryProvider, nameof(entityQueryProvider));
return((QueryCompiler)QueryCompiler_FieldInfo.GetValue(entityQueryProvider));
}
private int CountQuery(IQueryable query)
{
var queryModel = new EntityQueryProvider(new EntityQueryExecutor(Mock.Of <DbContext>())).GenerateQueryModel(query.Expression);
return(CountQueryModel(queryModel));
}