#pragma warning restore CS0612 // Type or member is obsolete
#pragma warning restore EF1001 // Internal EF Core API usage.
/// <summary>
/// Sets the LINQ query used as the default source for queries of this type.
/// </summary>
/// <param name="entityType">The entity type.</param>
/// <param name="inMemoryQuery">The LINQ query used as the default source.</param>
public static void SetInMemoryQuery(
this IMutableEntityType entityType,
LambdaExpression?inMemoryQuery)
=> entityType
#pragma warning disable EF1001 // Internal EF Core API usage.
#pragma warning disable CS0612 // Type or member is obsolete
.SetOrRemoveAnnotation(CoreAnnotationNames.DefiningQuery, inMemoryQuery);
public static Expression?BindMemberExpression(MemberExpression m, bool allowPolymorphics)
{
PropertyInfo?pi = m.Member as PropertyInfo;
if (pi == null)
{
return(null);
}
if (pi.HasAttributeInherit <PolymorphicExpansionAttribute>() && !allowPolymorphics)
{
return(null);
}
LambdaExpression?lambda = GetFieldExpansion(m.Expression?.Type, pi);
if (lambda == null)
{
return(null);
}
if (m.Expression == null)
{
return(lambda.Body);
}
else
{
return(Expression.Invoke(lambda, m.Expression));
}
}
internal static bool Equals(LambdaExpression?x, LambdaExpression?y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (x is null || y is null)
{
return(false);
}
var xMember = x.GetRootProperty();
var yMember = y.GetRootProperty();
while (xMember != null &&
yMember != null)
{
if (!MemberExpressionComparer.Equals(xMember, yMember))
{
return(false);
}
xMember = xMember.GetPreviousProperty();
yMember = yMember.GetPreviousProperty();
}
return(xMember is null && yMember is null &&
x.GetSourceType() == y.GetSourceType());
}
protected EntityShaperExpression(
[NotNull] IEntityType entityType,
[NotNull] Expression valueBufferExpression,
bool nullable,
[CanBeNull] LambdaExpression?materializationCondition)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(valueBufferExpression, nameof(valueBufferExpression));
if (materializationCondition == null)
{
materializationCondition = GenerateMaterializationCondition(entityType, nullable);
}
else if (materializationCondition.Parameters.Count != 1 ||
materializationCondition.Parameters[0].Type != typeof(ValueBuffer) ||
materializationCondition.ReturnType != typeof(IEntityType))
{
throw new InvalidOperationException(CoreStrings.QueryEntityMaterializationConditionWrongShape(entityType.DisplayName()));
}
EntityType = entityType;
ValueBufferExpression = valueBufferExpression;
IsNullable = nullable;
MaterializationCondition = materializationCondition;
}
public BinaryExpression(BinaryOperator binaryOperator, Expression leftOperand, Expression rightOperand, bool liftToNull, MethodInfo?method, LambdaExpression?conversion = null)
: this(binaryOperator, leftOperand, rightOperand)
{
IsLiftedToNull = liftToNull;
Method = method;
Conversion = conversion;
}
public static Expression?BindMethodExpression(MethodCallExpression m, bool allowPolymorphics)
{
if (m.Method.DeclaringType == typeof(ExpressionExtensions) && m.Method.Name == "Evaluate")
{
LambdaExpression lambda = (LambdaExpression)ExpressionEvaluator.Eval(m.Arguments[0]) !;
return(Expression.Invoke(lambda, m.Arguments.Skip(1).ToArray()));
}
if (m.Method.HasAttributeInherit <PolymorphicExpansionAttribute>() && !allowPolymorphics)
{
return(null);
}
MethodExpanderAttribute?attribute = m.Method.GetCustomAttribute <MethodExpanderAttribute>();
if (attribute != null)
{
if (attribute.ExpanderType.IsGenericTypeDefinition)
{
if (!typeof(GenericMethodExpander).IsAssignableFrom(attribute.ExpanderType))
{
throw new InvalidOperationException("Expansion failed, '{0}' does not implement IMethodExpander or GenericMethodExpander".FormatWith(attribute.ExpanderType.TypeName()));
}
Expression[] args = m.Object == null?m.Arguments.ToArray() : m.Arguments.PreAnd(m.Object).ToArray();
var type = attribute.ExpanderType.MakeGenericType(m.Method.GetGenericArguments());
GenericMethodExpander expander = (GenericMethodExpander)Activator.CreateInstance(type) !;
return(Expression.Invoke(expander.GenericLambdaExpression, args));
}
else
{
if (!typeof(IMethodExpander).IsAssignableFrom(attribute.ExpanderType))
{
throw new InvalidOperationException("Expansion failed, '{0}' does not implement IMethodExpander or GenericMethodExpander".FormatWith(attribute.ExpanderType.TypeName()));
}
IMethodExpander expander = (IMethodExpander)Activator.CreateInstance(attribute.ExpanderType) !;
Expression exp = expander.Expand(
m.Object,
m.Arguments.ToArray(),
m.Method);
return(exp);
}
}
LambdaExpression?lambdaExpression = GetFieldExpansion(m.Object?.Type, m.Method);
if (lambdaExpression != null)
{
Expression[] args = m.Object == null?m.Arguments.ToArray() : m.Arguments.PreAnd(m.Object).ToArray();
return(Expression.Invoke(lambdaExpression, args));
}
return(null);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var obj = base.Visit(node.Object);
var args = base.Visit(node.Arguments);
LambdaExpression?lambda = ExpressionCleaner.GetFieldExpansion(obj?.Type, node.Method);
if (lambda != null)
{
var replace = ExpressionReplacer.Replace(Expression.Invoke(lambda, obj == null ? args : args.PreAnd(obj)));
return(this.Visit(replace));
}
if (node.Method.Name == "ToString" && node.Arguments.IsEmpty() && obj is CachedEntityExpression ce)
{
var table = (Table)ce.Constructor.table;
if (table.ToStrColumn == null)
{
throw new InvalidOperationException("Impossible to get ToStrColumn from " + ce.ToString());
}
return(BindMember(ce, (FieldValue)table.ToStrColumn, null));
}
return(node.Update(obj, args));
}
public OeEntryFactory(
IEdmEntitySetBase entitySet,
OePropertyAccessor[] accessors,
OePropertyAccessor[]?skipTokenAccessors,
IReadOnlyList <OeNavigationEntryFactory>?navigationLinks,
LambdaExpression?linkAccessor)
: this(entitySet, accessors, skipTokenAccessors)
{
NavigationLinks = navigationLinks ?? Array.Empty <OeNavigationEntryFactory>();
if (linkAccessor != null)
{
IsTuple = GetIsTuple(linkAccessor);
LinkAccessor = (Func <Object, Object>)linkAccessor.Compile();
}
if (accessors.Length > 0)
{
if (IsExpandCount(accessors))
{
_equalityComparer = Infrastructure.OeEntryEqualityComparer.ExpandCountEqualityComparer;
}
else
{
_equalityComparer = new Infrastructure.OeEntryEqualityComparer(GetKeyExpressions(entitySet, accessors));
}
}
}
public static void SetInMemoryQuery(
[NotNull] this IMutableEntityType entityType,
[CanBeNull] LambdaExpression?inMemoryQuery)
=> Check.NotNull(entityType, nameof(entityType))
#pragma warning disable EF1001 // Internal EF Core API usage.
#pragma warning disable CS0612 // Type or member is obsolete
.SetOrRemoveAnnotation(CoreAnnotationNames.DefiningQuery, inMemoryQuery);
public static void SetDefiningQuery(
[NotNull] this IConventionEntityType entityType,
[CanBeNull] LambdaExpression?definingQuery,
bool fromDataAnnotation = false)
=> ((EntityType)entityType).SetDefiningQuery(
definingQuery,
fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
/// <summary>
/// Returns a value indicating whether the given in-memory query can be set from the current configuration source.
/// </summary>
/// <param name="entityTypeBuilder"> The builder for the entity type being configured. </param>
/// <param name="query"> The query that will provide the underlying data for the keyless entity type. </param>
/// <param name="fromDataAnnotation"> Indicates whether the configuration was specified using a data annotation. </param>
/// <returns> <see langword="true" /> if the given in-memory query can be set. </returns>
public static bool CanSetInMemoryQuery(
this IConventionEntityTypeBuilder entityTypeBuilder,
LambdaExpression?query,
bool fromDataAnnotation = false)
#pragma warning disable EF1001 // Internal EF Core API usage.
#pragma warning disable CS0612 // Type or member is obsolete
=> entityTypeBuilder.CanSetAnnotation(CoreAnnotationNames.DefiningQuery, query, fromDataAnnotation);
protected override Expression VisitConstant(ConstantExpression c)
{
if (disableQueryFilter)
{
return(base.VisitConstant(c));
}
if (typeof(IQueryable).IsAssignableFrom(c.Type))
{
IQueryable query = (IQueryable)c.Value;
if (query.IsBase())
{
Type queryType = c.Type.GetGenericArguments().SingleEx();
if (filter)
{
if (typeof(Entity).IsAssignableFrom(queryType))
{
LambdaExpression?rawFilter = giFilter.GetInvoker(queryType)(Schema.Current);
if (rawFilter != null)
{
Expression clean = ExpressionCleaner.Clean(rawFilter) !;
var cleanFilter = (LambdaExpression)OverloadingSimplifier.Simplify(clean) !;
return(Expression.Call(miWhere.MakeGenericMethod(queryType), query.Expression, cleanFilter));
}
}
else if (queryType.IsInstantiationOf(typeof(MListElement <,>)))
{
Type entityType = queryType.GetGenericArguments()[0];
LambdaExpression?rawFilter = giFilter.GetInvoker(entityType)(Schema.Current);
if (rawFilter != null)
{
var param = Expression.Parameter(queryType, "mle");
var lambda = Expression.Lambda(Expression.Invoke(rawFilter, Expression.Property(param, "Parent")), param);
Expression clean = ExpressionCleaner.Clean(lambda) !;
var cleanFilter = (LambdaExpression)OverloadingSimplifier.Simplify(clean) !;
return(Expression.Call(miWhere.MakeGenericMethod(queryType), query.Expression, cleanFilter));
}
}
}
return(c);
}
else
{
/// <summary>
/// Replaces every expression like ConstantExpression{ Type = IQueryable, Value = complexExpr } by complexExpr
/// </summary>
return(DbQueryProvider.Clean(query.Expression, filter, null) !);
}
}
return(base.VisitConstant(c));
}
/// <summary>
/// Initializes a new instance with the specified parameters.
/// </summary>
public ArgumentInformation(ParameterInfo parameterInfo, Type?sourceType, FieldType?fieldType, TypeInformation typeInformation, LambdaExpression?expression)
{
ParameterInfo = parameterInfo ?? throw new ArgumentNullException(nameof(parameterInfo));
FieldType = fieldType; // ?? throw new ArgumentNullException(nameof(fieldType));
SourceType = sourceType; // ?? throw new ArgumentNullException(nameof(sourceType));
TypeInformation = typeInformation ?? throw new ArgumentNullException(nameof(typeInformation));
Expression = expression;
}
public static LambdaExpression?SetQueryFilter(
[NotNull] this IConventionEntityType entityType,
[CanBeNull] LambdaExpression?queryFilter,
bool fromDataAnnotation = false)
=> Check.NotNull(entityType, nameof(entityType)).AsEntityType()
.SetQueryFilter(
queryFilter,
fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
/// <summary>
/// Creates a new instance of the <see cref="RelationalEntityShaperExpression" /> class.
/// </summary>
/// <param name="entityType">The entity type to shape.</param>
/// <param name="valueBufferExpression">An expression of ValueBuffer to get values for properties of the entity.</param>
/// <param name="nullable">Whether this entity instance can be null.</param>
/// <param name="materializationCondition">
/// An expression of <see cref="Func{T,TResult}" /> to determine which entity type to
/// materialize.
/// </param>
protected RelationalEntityShaperExpression(
IEntityType entityType,
Expression valueBufferExpression,
bool nullable,
LambdaExpression?materializationCondition)
: base(entityType, valueBufferExpression, nullable, materializationCondition)
{
}
protected QuerySplitBuilder(TBuilder?parent, LambdaExpression?idExpression, LambdaExpression?includeExpression, string?idPropertyName = null)
{
Parent = parent;
_idExpression = idExpression;
_includeExpression = includeExpression;
_idPropertyName = idPropertyName;
Children = new List <TBuilder>();
}
internal MultipleQuerySplitBuilder(
MultipleQuerySplitBuilder <T, TId>?parent,
Expression <Func <T, TId> >?idExpression = null,
LambdaExpression?derivedIdExpression = null,
LambdaExpression?includeExpression = null)
: base(parent, idExpression ?? derivedIdExpression, includeExpression)
{
_idExpression = idExpression;
}
internal LambdaExpression?GetConstructUsing()
{
if (!_fetchConstructUsing)
{
_constructUsing = Settings.ConstructUsingFactory?.Invoke(this);
_fetchConstructUsing = true;
}
return(_constructUsing);
}
private static bool GetIsTuple(LambdaExpression?linkAccessor)
{
if (linkAccessor != null && ((MemberExpression)linkAccessor.Body).Expression is UnaryExpression convertExpression)
{
return(OeExpressionHelper.IsTupleType(convertExpression.Type));
}
return(false);
}
/// <summary>
/// 用于：Sum
/// </summary>
/// <param name="source"></param>
/// <param name="lambda"></param>
/// <returns></returns>
public static object ExecuteSum(this IQueryable source, LambdaExpression?lambda = null)
{
var method = nameof(Queryable.Sum);
var expression = lambda is null
? Expression.Call(typeof(Queryable), method, null, source.Expression)
: Expression.Call(typeof(Queryable), method, new[] { source.ElementType }, source.Expression, lambda);
return(source.Provider.Execute(expression));
}
/// <summary>
/// Configures a query used to provide data for an entity type.
/// </summary>
/// <param name="entityTypeBuilder"> The builder for the entity type being configured. </param>
/// <param name="query"> The query that will provide the underlying data for the entity type. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static EntityTypeBuilder ToInMemoryQuery(
this EntityTypeBuilder entityTypeBuilder,
LambdaExpression?query)
{
Check.NotNull(query, nameof(query));
entityTypeBuilder.Metadata.SetInMemoryQuery(query);
return(entityTypeBuilder);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.DeclaringType == typeof(string) && node.Method.Name == nameof(string.Format) ||
node.Method.DeclaringType == typeof(StringExtensions) && node.Method.Name == nameof(StringExtensions.FormatWith))
{
var formatStr = Visit(node.Arguments[0]);
var remainging = node.Arguments.Skip(1).Select(a => Visit(ToString(a))).ToList();
return(node.Update(null, new Sequence <Expression> {
formatStr, remainging
}));
}
var obj = base.Visit(node.Object);
var args = base.Visit(node.Arguments);
if (node.Method.Name == "ToString" && node.Arguments.IsEmpty() && obj is CachedEntityExpression ce && ce.Type.IsEntity())
{
var table = (Table)ce.Constructor.table;
if (table.ToStrColumn != null)
{
return(BindMember(ce, (FieldValue)table.ToStrColumn, null));
}
else if (this.root != ce)
{
var cachedTableType = typeof(CachedTable <>).MakeGenericType(table.Type);
ConstantExpression tab = Expression.Constant(ce.Constructor.cachedTable, cachedTableType);
var mi = cachedTableType.GetMethod(nameof(CachedTable <Entity> .GetToString));
return(Expression.Call(tab, mi, ce.PrimaryKey.UnNullify()));
}
}
LambdaExpression?lambda = ExpressionCleaner.GetFieldExpansion(obj?.Type, node.Method);
if (lambda != null)
{
var replace = ExpressionReplacer.Replace(Expression.Invoke(lambda, obj == null ? args : args.PreAnd(obj)));
return(this.Visit(replace));
}
if (node.Method.Name == nameof(Entity.Mixin) && obj is CachedEntityExpression cee)
{
var mixin = ((Table)cee.Constructor.table).GetField(node.Method);
return(GetField(mixin, cee.Constructor, cee.PrimaryKey));
}
return(node.Update(obj, args));
}
public static Expression?Replace(LambdaExpression?expression, ParameterExpression parameter)
{
if (expression == null)
{
return(null);
}
var visitor = new Replacer(expression.Parameters[0], parameter);
return(visitor.Visit(expression.Body));
}
public static LambdaExpression?SetInMemoryQuery(
[NotNull] this IConventionEntityType entityType,
[CanBeNull] LambdaExpression?inMemoryQuery,
bool fromDataAnnotation = false)
=> (LambdaExpression?)Check.NotNull(entityType, nameof(entityType))
#pragma warning disable EF1001 // Internal EF Core API usage.
#pragma warning disable CS0612 // Type or member is obsolete
.SetOrRemoveAnnotation(CoreAnnotationNames.DefiningQuery, inMemoryQuery, fromDataAnnotation)
#pragma warning restore CS0612 // Type or member is obsolete
#pragma warning restore EF1001 // Internal EF Core API usage.
?.Value;
public LambdaInfo(
LambdaExpression checkNullLambda,
LambdaExpression?lambda,
Delegate? @delegate,
bool isSchemaSpecific)
{
CheckNullLambda = checkNullLambda;
Lambda = lambda ?? checkNullLambda;
Delegate = @delegate;
IsSchemaSpecific = isSchemaSpecific;
}
protected SequenceContextBase(IBuildContext?parent, IBuildContext[] sequences, LambdaExpression?lambda)
{
Parent = parent;
Sequences = sequences;
Builder = sequences[0].Builder;
Lambda = lambda;
SelectQuery = sequences[0].SelectQuery;
Sequence.Parent = this;
Builder.Contexts.Add(this);
}
/// <summary>
/// 用于：Max、Min
/// </summary>
/// <param name="source"></param>
/// <param name="method"></param>
/// <param name="lambda"></param>
/// <returns></returns>
public static object ExecuteMaxMin(this IQueryable source, MethodInfo method, LambdaExpression?lambda = null)
{
method = method.GetGenericArguments().Length == 2
? method.MakeGenericMethod(source.ElementType, lambda?.ReturnType)
: method.MakeGenericMethod(source.ElementType);
var expression = lambda is null
? Expression.Call(method, source.Expression)
: Expression.Call(method, source.Expression, lambda);
return(source.Provider.Execute(expression));
}
public static bool TryRewriteLamdaExpression(
LambdaExpression lambdaExpression,
Dictionary <ParameterExpression, GroupingDescriptor> lambdaParamsToRewrite,
[NotNullWhen(true)] out LambdaExpression?translatedArg)
{
_instance ??= new GroupingExpressionRewriter();
_instance._lambdaParamsToRewrite = lambdaParamsToRewrite;
_instance._success = true;
translatedArg = (LambdaExpression)_instance.Visit(lambdaExpression);
_instance._rewrittenLamdaParameters.Clear();
return(_instance._success);
}
/// <summary>
/// 用于：First、FirstOrDefault、Last、LastOrDefault、Single、SingleOrDefault
/// </summary>
/// <param name="source"></param>
/// <param name="method"></param>
/// <param name="lambda"></param>
/// <returns></returns>
public static object Execute(this IQueryable source, MethodInfo method, LambdaExpression?lambda = null)
{
if (method.IsGenericMethod)
{
method = method.MakeGenericMethod(source.ElementType);
}
var expression = lambda is null
? Expression.Call(method, source.Expression)
: Expression.Call(method, source.Expression, lambda);
return(source.Provider.Execute(expression));
}
// Returns
// (ParentType p) => dc.GetTable<ObjectType>().Where(...)
// (ParentType p) => dc.GetTable<ObjectType>().Where(...).DefaultIfEmpty
public static LambdaExpression CreateAssociationQueryLambda(ExpressionBuilder builder, AccessorMember onMember, AssociationDescriptor association,
Type parentOriginalType,
Type parentType,
Type objectType, bool inline, bool enforceDefault,
List <LoadWithInfo[]>?loadWith, out bool isLeft)
{
var dataContextConstant = Expression.Constant(builder.DataContext, builder.DataContext.GetType());
// We are trying to keep fast cache hit behaviour, so cache check should be added only if needed
//
bool shouldAddCacheCheck = false;
bool cacheCheckAdded = false;
LambdaExpression?definedQueryMethod = null;
if (association.HasQueryMethod())
{
// here we tell for Expression Comparer to compare optimized Association expressions
//
definedQueryMethod = (LambdaExpression)builder.AddQueryableMemberAccessors(onMember, builder.DataContext, (mi, dc) =>
{
var queryLambda = association.GetQueryMethod(parentType, objectType) ?? throw new InvalidOperationException();
var optimizationContext = new ExpressionTreeOptimizationContext(dc);
var optimizedExpr = optimizationContext.ExposeExpression(queryLambda);
optimizedExpr = optimizationContext.ExpandQueryableMethods(optimizedExpr);
return(optimizedExpr);
});
cacheCheckAdded = true;
var parameterMatch = new Dictionary <ParameterExpression, Expression>();
if (onMember.Arguments == null)
{
if (definedQueryMethod.Parameters.Count > 1 && typeof(IDataContext).IsSameOrParentOf(definedQueryMethod.Parameters[1].Type))
{
parameterMatch.Add(definedQueryMethod.Parameters[1], dataContextConstant);
}
}
else
{
var definedCount = definedQueryMethod.Parameters.Count;
var argumentsCount = onMember.Arguments.Count;
var diff = definedCount - argumentsCount;
for (int i = definedCount - 1; i >= diff; i--)
{
parameterMatch.Add(definedQueryMethod.Parameters[i], onMember.Arguments[i - diff]);
}
}
var body = definedQueryMethod.Body.Transform(parameterMatch, static (parameterMatch, e) =>
