/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual Expression CreateMaterializeExpression(
IEntityType entityType,
Expression valueBufferExpression,
int[] indexMap = null)
{
// ReSharper disable once SuspiciousTypeConversion.Global
var materializer = entityType as IEntityMaterializer;
if (materializer != null)
{
return(Expression.Call(
Expression.Constant(materializer),
((Func <ValueBuffer, object>)materializer.CreateEntity).GetMethodInfo(),
valueBufferExpression));
}
if (!entityType.HasClrType())
{
throw new InvalidOperationException(CoreStrings.NoClrType(entityType.Name));
}
if (entityType.IsAbstract())
{
throw new InvalidOperationException(CoreStrings.CannotMaterializeAbstractType(entityType));
}
var constructorInfo = entityType.ClrType.GetDeclaredConstructor(null);
if (constructorInfo == null)
{
throw new InvalidOperationException(CoreStrings.NoParameterlessConstructor(entityType.DisplayName()));
}
var instanceVariable = Expression.Variable(entityType.ClrType, "instance");
var blockExpressions
= new List <Expression>
{
Expression.Assign(
instanceVariable,
Expression.New(constructorInfo))
};
blockExpressions.AddRange(
from mapping in _memberMapper.MapPropertiesToMembers(entityType)
let propertyInfo = mapping.Item2 as PropertyInfo
let targetMember
= propertyInfo != null
? Expression.Property(instanceVariable, propertyInfo)
: Expression.Field(instanceVariable, (FieldInfo)mapping.Item2)
select
Expression.Assign(
targetMember,
CreateReadValueExpression(
valueBufferExpression,
targetMember.Type,
indexMap?[mapping.Item1.GetIndex()] ?? mapping.Item1.GetIndex())));
blockExpressions.Add(instanceVariable);
return(Expression.Block(new[] { instanceVariable }, blockExpressions));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override QueryRootExpression UpdateEntityType(IEntityType entityType)
=> entityType.ClrType != EntityType.ClrType ||
entityType.Name != EntityType.Name
? throw new InvalidOperationException(CoreStrings.QueryRootDifferentEntityType(entityType.DisplayName()))
: new TemporalContainedInQueryRootExpression(entityType, From, To);
/// <summary> /// Creates a copy of this mapping. /// </summary> /// <param name="parameters"> The parameters for this mapping. </param> /// <returns> The newly created mapping. </returns> protected virtual RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters) => throw new NotImplementedException(CoreStrings.ConverterCloneNotImplemented(GetType().ShortDisplayName()));
public void BatchingTopologicalSort_throws_with_formatted_message_with_no_tail_when_cycle_cannot_be_broken()
{
const string message = "Formatted cycle";
var vertexOne = new Vertex
{
Id = 1
};
var vertexTwo = new Vertex
{
Id = 2
};
var vertexThree = new Vertex
{
Id = 3
};
var vertexFour = new Vertex
{
Id = 4
};
var edgeOne = new Edge
{
Id = 1
};
var edgeTwo = new Edge
{
Id = 2
};
var edgeThree = new Edge
{
Id = 3
};
var edgeFour = new Edge
{
Id = 4
};
var graph = new Multigraph <Vertex, Edge>();
graph.AddVertices(new[] { vertexOne, vertexTwo, vertexThree, vertexFour });
// 2 -> {1}
graph.AddEdge(vertexTwo, vertexOne, edgeOne);
// 3 -> {2}
graph.AddEdge(vertexThree, vertexTwo, edgeTwo);
// 4 -> {3}
graph.AddEdge(vertexFour, vertexThree, edgeThree);
// 3 -> {4}
graph.AddEdge(vertexThree, vertexFour, edgeFour);
Dictionary <Vertex, Tuple <Vertex, Vertex, IEnumerable <Edge> > > cycleData = null;
string formatter(IEnumerable <Tuple <Vertex, Vertex, IEnumerable <Edge> > > data)
{
cycleData = data.ToDictionary(entry => entry.Item1);
return(message);
}
Assert.Equal(
CoreStrings.CircularDependency(message),
Assert.Throws <InvalidOperationException>(() => graph.BatchingTopologicalSort(formatter)).Message);
Assert.Equal(2, cycleData.Count);
Assert.Equal(vertexFour, cycleData[vertexThree].Item2);
Assert.Equal(new[] { edgeFour }, cycleData[vertexThree].Item3);
Assert.Equal(vertexThree, cycleData[vertexFour].Item2);
Assert.Equal(new[] { edgeThree }, cycleData[vertexFour].Item3);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual IComparer <IUpdateEntry> Create([NotNull] IPropertyBase propertyBase)
{
var modelType = propertyBase.ClrType;
var nonNullableModelType = modelType.UnwrapNullableType();
if (IsGenericComparable(modelType, nonNullableModelType))
{
return((IComparer <IUpdateEntry>)Activator.CreateInstance(
typeof(EntryCurrentValueComparer <>).MakeGenericType(modelType),
propertyBase));
}
if (typeof(IStructuralComparable).IsAssignableFrom(nonNullableModelType))
{
return(new StructuralEntryCurrentValueComparer(propertyBase));
}
if (typeof(IComparable).IsAssignableFrom(nonNullableModelType))
{
return(new EntryCurrentValueComparer(propertyBase));
}
if (propertyBase is IProperty property)
{
var converter = property.GetValueConverter()
?? property.GetTypeMapping().Converter;
if (converter != null)
{
var providerType = converter.ProviderClrType;
var nonNullableProviderType = providerType.UnwrapNullableType();
if (IsGenericComparable(providerType, nonNullableProviderType))
{
var comparerType = modelType.IsClass
? typeof(NullableClassCurrentProviderValueComparer <,>).MakeGenericType(modelType, converter.ProviderClrType)
: modelType == converter.ModelClrType
? typeof(CurrentProviderValueComparer <,>).MakeGenericType(modelType, converter.ProviderClrType)
: typeof(NullableStructCurrentProviderValueComparer <,>).MakeGenericType(
nonNullableModelType, converter.ProviderClrType);
return((IComparer <IUpdateEntry>)Activator.CreateInstance(comparerType, propertyBase, converter));
}
if (typeof(IStructuralComparable).IsAssignableFrom(nonNullableProviderType))
{
return(new StructuralEntryCurrentProviderValueComparer(propertyBase, converter));
}
if (typeof(IComparable).IsAssignableFrom(nonNullableProviderType))
{
return(new EntryCurrentProviderValueComparer(propertyBase, converter));
}
throw new InvalidOperationException(
CoreStrings.NonComparableKeyTypes(
propertyBase.DeclaringType.DisplayName(),
propertyBase.Name,
modelType.ShortDisplayName(),
providerType.ShortDisplayName()));
}
}
throw new InvalidOperationException(
CoreStrings.NonComparableKeyType(
propertyBase.DeclaringType.DisplayName(),
propertyBase.Name,
modelType.ShortDisplayName()));
bool IsGenericComparable(Type type, Type nonNullableType)
=> typeof(IComparable <>).MakeGenericType(type).IsAssignableFrom(type) ||
typeof(IComparable <>).MakeGenericType(nonNullableType).IsAssignableFrom(nonNullableType) ||
type.IsEnum ||
nonNullableType.IsEnum;
}
public void Can_find_targets_for_same_base_foreign_keys()
{
var fk = CreateOneToManySameBaseFK();
var model = fk.DeclaringEntityType.Model;
var derivedPrincipal = model.AddEntityType(typeof(DerivedOneToManyPrincipal));
derivedPrincipal.BaseType = fk.PrincipalEntityType;
var derivedDependent = model.AddEntityType(typeof(DerivedOneToManyDependent));
derivedDependent.BaseType = fk.DeclaringEntityType;
Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityType(fk.DeclaringEntityType));
Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityType(fk.PrincipalEntityType));
Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsFrom(fk.PrincipalEntityType).SingleOrDefault());
Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsFrom(fk.DeclaringEntityType).SingleOrDefault());
Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsTo(fk.PrincipalEntityType).SingleOrDefault());
Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsTo(fk.DeclaringEntityType).SingleOrDefault());
Assert.Same(fk.DeclaringEntityType, fk.ResolveEntityTypeInHierarchy(fk.DeclaringEntityType));
Assert.Same(fk.PrincipalEntityType, fk.ResolveEntityTypeInHierarchy(fk.PrincipalEntityType));
Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityTypeInHierarchy(fk.DeclaringEntityType));
Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityTypeInHierarchy(fk.PrincipalEntityType));
Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsFromInHierarchy(fk.PrincipalEntityType).SingleOrDefault());
Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsFromInHierarchy(fk.DeclaringEntityType).SingleOrDefault());
Assert.Same(fk.DependentToPrincipal, fk.FindNavigationsToInHierarchy(fk.PrincipalEntityType).SingleOrDefault());
Assert.Same(fk.PrincipalToDependent, fk.FindNavigationsToInHierarchy(fk.DeclaringEntityType).SingleOrDefault());
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedDependent.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityType(derivedDependent)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedPrincipal.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityType(derivedPrincipal)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedPrincipal.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFrom(derivedPrincipal)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedDependent.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFrom(derivedDependent)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedPrincipal.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsTo(derivedPrincipal)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
derivedDependent.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsTo(derivedDependent)).Message);
Assert.Same(fk.DeclaringEntityType, fk.ResolveEntityTypeInHierarchy(derivedDependent));
Assert.Same(fk.PrincipalEntityType, fk.ResolveEntityTypeInHierarchy(derivedPrincipal));
Assert.Same(fk.PrincipalEntityType, fk.ResolveOtherEntityTypeInHierarchy(derivedDependent));
Assert.Same(fk.DeclaringEntityType, fk.ResolveOtherEntityTypeInHierarchy(derivedPrincipal));
Assert.Equal(new[] { fk.PrincipalToDependent }.Where(n => n != null), fk.FindNavigationsFromInHierarchy(derivedPrincipal));
Assert.Equal(new[] { fk.DependentToPrincipal }.Where(n => n != null), fk.FindNavigationsFromInHierarchy(derivedDependent));
Assert.Equal(new[] { fk.DependentToPrincipal }.Where(n => n != null), fk.FindNavigationsToInHierarchy(derivedPrincipal));
Assert.Equal(new[] { fk.PrincipalToDependent }.Where(n => n != null), fk.FindNavigationsToInHierarchy(derivedDependent));
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
Check.NotNull(methodCallExpression, nameof(methodCallExpression));
ShapedQueryExpression CheckTranslated(ShapedQueryExpression translated)
{
return translated ?? throw new InvalidOperationException(CoreStrings.TranslationFailed(methodCallExpression.Print()));
}
var method = methodCallExpression.Method;
if (method.DeclaringType == typeof(Queryable)
|| method.DeclaringType == typeof(QueryableExtensions))
{
var source = Visit(methodCallExpression.Arguments[0]);
if (source is ShapedQueryExpression shapedQueryExpression)
{
var genericMethod = method.IsGenericMethod ? method.GetGenericMethodDefinition() : null;
switch (method.Name)
{
case nameof(Queryable.All)
when genericMethod == QueryableMethods.All:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateAll(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.Any)
when genericMethod == QueryableMethods.AnyWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateAny(shapedQueryExpression, null));
case nameof(Queryable.Any)
when genericMethod == QueryableMethods.AnyWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateAny(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.AsQueryable)
when genericMethod == QueryableMethods.AsQueryable:
return source;
case nameof(Queryable.Average)
when QueryableMethods.IsAverageWithoutSelector(method):
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateAverage(shapedQueryExpression, null, methodCallExpression.Type));
case nameof(Queryable.Average)
when QueryableMethods.IsAverageWithSelector(method):
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateAverage(shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type));
case nameof(Queryable.Cast)
when genericMethod == QueryableMethods.Cast:
return CheckTranslated(TranslateCast(shapedQueryExpression, method.GetGenericArguments()[0]));
case nameof(Queryable.Concat)
when genericMethod == QueryableMethods.Concat:
{
var source2 = Visit(methodCallExpression.Arguments[1]);
if (source2 is ShapedQueryExpression innerShapedQueryExpression)
{
return TranslateConcat(
shapedQueryExpression,
innerShapedQueryExpression);
}
break;
}
case nameof(Queryable.Contains)
when genericMethod == QueryableMethods.Contains:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateContains(shapedQueryExpression, methodCallExpression.Arguments[1]));
case nameof(Queryable.Count)
when genericMethod == QueryableMethods.CountWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateCount(shapedQueryExpression, null));
case nameof(Queryable.Count)
when genericMethod == QueryableMethods.CountWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateCount(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.DefaultIfEmpty)
when genericMethod == QueryableMethods.DefaultIfEmptyWithoutArgument:
return CheckTranslated(TranslateDefaultIfEmpty(shapedQueryExpression, null));
case nameof(Queryable.DefaultIfEmpty)
when genericMethod == QueryableMethods.DefaultIfEmptyWithArgument:
return CheckTranslated(TranslateDefaultIfEmpty(shapedQueryExpression, methodCallExpression.Arguments[1]));
case nameof(Queryable.Distinct)
when genericMethod == QueryableMethods.Distinct:
return CheckTranslated(TranslateDistinct(shapedQueryExpression));
case nameof(Queryable.ElementAt)
when genericMethod == QueryableMethods.ElementAt:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateElementAtOrDefault(shapedQueryExpression, methodCallExpression.Arguments[1], false));
case nameof(Queryable.ElementAtOrDefault)
when genericMethod == QueryableMethods.ElementAtOrDefault:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(
TranslateElementAtOrDefault(shapedQueryExpression, methodCallExpression.Arguments[1], true));
case nameof(Queryable.Except)
when genericMethod == QueryableMethods.Except:
{
var source2 = Visit(methodCallExpression.Arguments[1]);
if (source2 is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(
TranslateExcept(
shapedQueryExpression,
innerShapedQueryExpression));
}
break;
}
case nameof(Queryable.First)
when genericMethod == QueryableMethods.FirstWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateFirstOrDefault(shapedQueryExpression, null, methodCallExpression.Type, false));
case nameof(Queryable.First)
when genericMethod == QueryableMethods.FirstWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateFirstOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, false));
case nameof(Queryable.FirstOrDefault)
when genericMethod == QueryableMethods.FirstOrDefaultWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(TranslateFirstOrDefault(shapedQueryExpression, null, methodCallExpression.Type, true));
case nameof(Queryable.FirstOrDefault)
when genericMethod == QueryableMethods.FirstOrDefaultWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(
TranslateFirstOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, true));
case nameof(Queryable.GroupBy)
when genericMethod == QueryableMethods.GroupByWithKeySelector:
return CheckTranslated(TranslateGroupBy(shapedQueryExpression, GetLambdaExpressionFromArgument(1), null, null));
case nameof(Queryable.GroupBy)
when genericMethod == QueryableMethods.GroupByWithKeyElementSelector:
return CheckTranslated(
TranslateGroupBy(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), GetLambdaExpressionFromArgument(2), null));
case nameof(Queryable.GroupBy)
when genericMethod == QueryableMethods.GroupByWithKeyElementResultSelector:
return CheckTranslated(
TranslateGroupBy(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), GetLambdaExpressionFromArgument(2),
GetLambdaExpressionFromArgument(3)));
case nameof(Queryable.GroupBy)
when genericMethod == QueryableMethods.GroupByWithKeyResultSelector:
return CheckTranslated(
TranslateGroupBy(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), null, GetLambdaExpressionFromArgument(2)));
case nameof(Queryable.GroupJoin)
when genericMethod == QueryableMethods.GroupJoin:
{
if (Visit(methodCallExpression.Arguments[1]) is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(
TranslateGroupJoin(
shapedQueryExpression,
innerShapedQueryExpression,
GetLambdaExpressionFromArgument(2),
GetLambdaExpressionFromArgument(3),
GetLambdaExpressionFromArgument(4)));
}
break;
}
case nameof(Queryable.Intersect)
when genericMethod == QueryableMethods.Intersect:
{
if (Visit(methodCallExpression.Arguments[1]) is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(TranslateIntersect(shapedQueryExpression, innerShapedQueryExpression));
}
break;
}
case nameof(Queryable.Join)
when genericMethod == QueryableMethods.Join:
{
if (Visit(methodCallExpression.Arguments[1]) is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(
TranslateJoin(
shapedQueryExpression, innerShapedQueryExpression, GetLambdaExpressionFromArgument(2),
GetLambdaExpressionFromArgument(3), GetLambdaExpressionFromArgument(4)));
}
break;
}
case nameof(QueryableExtensions.LeftJoin)
when genericMethod == QueryableExtensions.LeftJoinMethodInfo:
{
if (Visit(methodCallExpression.Arguments[1]) is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(
TranslateLeftJoin(
shapedQueryExpression, innerShapedQueryExpression, GetLambdaExpressionFromArgument(2),
GetLambdaExpressionFromArgument(3), GetLambdaExpressionFromArgument(4)));
}
break;
}
case nameof(Queryable.Last)
when genericMethod == QueryableMethods.LastWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateLastOrDefault(shapedQueryExpression, null, methodCallExpression.Type, false));
case nameof(Queryable.Last)
when genericMethod == QueryableMethods.LastWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateLastOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, false));
case nameof(Queryable.LastOrDefault)
when genericMethod == QueryableMethods.LastOrDefaultWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(TranslateLastOrDefault(shapedQueryExpression, null, methodCallExpression.Type, true));
case nameof(Queryable.LastOrDefault)
when genericMethod == QueryableMethods.LastOrDefaultWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(
TranslateLastOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, true));
case nameof(Queryable.LongCount)
when genericMethod == QueryableMethods.LongCountWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateLongCount(shapedQueryExpression, null));
case nameof(Queryable.LongCount)
when genericMethod == QueryableMethods.LongCountWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateLongCount(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.Max)
when genericMethod == QueryableMethods.MaxWithoutSelector:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateMax(shapedQueryExpression, null, methodCallExpression.Type));
case nameof(Queryable.Max)
when genericMethod == QueryableMethods.MaxWithSelector:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateMax(shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type));
case nameof(Queryable.Min)
when genericMethod == QueryableMethods.MinWithoutSelector:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateMin(shapedQueryExpression, null, methodCallExpression.Type));
case nameof(Queryable.Min)
when genericMethod == QueryableMethods.MinWithSelector:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateMin(shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type));
case nameof(Queryable.OfType)
when genericMethod == QueryableMethods.OfType:
return CheckTranslated(TranslateOfType(shapedQueryExpression, method.GetGenericArguments()[0]));
case nameof(Queryable.OrderBy)
when genericMethod == QueryableMethods.OrderBy:
return CheckTranslated(TranslateOrderBy(shapedQueryExpression, GetLambdaExpressionFromArgument(1), true));
case nameof(Queryable.OrderByDescending)
when genericMethod == QueryableMethods.OrderByDescending:
return CheckTranslated(TranslateOrderBy(shapedQueryExpression, GetLambdaExpressionFromArgument(1), false));
case nameof(Queryable.Reverse)
when genericMethod == QueryableMethods.Reverse:
return CheckTranslated(TranslateReverse(shapedQueryExpression));
case nameof(Queryable.Select)
when genericMethod == QueryableMethods.Select:
return CheckTranslated(TranslateSelect(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.SelectMany)
when genericMethod == QueryableMethods.SelectManyWithoutCollectionSelector:
return CheckTranslated(TranslateSelectMany(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.SelectMany)
when genericMethod == QueryableMethods.SelectManyWithCollectionSelector:
return CheckTranslated(
TranslateSelectMany(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), GetLambdaExpressionFromArgument(2)));
case nameof(Queryable.Single)
when genericMethod == QueryableMethods.SingleWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateSingleOrDefault(shapedQueryExpression, null, methodCallExpression.Type, false));
case nameof(Queryable.Single)
when genericMethod == QueryableMethods.SingleWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateSingleOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, false));
case nameof(Queryable.SingleOrDefault)
when genericMethod == QueryableMethods.SingleOrDefaultWithoutPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(TranslateSingleOrDefault(shapedQueryExpression, null, methodCallExpression.Type, true));
case nameof(Queryable.SingleOrDefault)
when genericMethod == QueryableMethods.SingleOrDefaultWithPredicate:
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.SingleOrDefault);
return CheckTranslated(
TranslateSingleOrDefault(
shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type, true));
case nameof(Queryable.Skip)
when genericMethod == QueryableMethods.Skip:
return CheckTranslated(TranslateSkip(shapedQueryExpression, methodCallExpression.Arguments[1]));
case nameof(Queryable.SkipWhile)
when genericMethod == QueryableMethods.SkipWhile:
return CheckTranslated(TranslateSkipWhile(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.Sum)
when QueryableMethods.IsSumWithoutSelector(method):
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(TranslateSum(shapedQueryExpression, null, methodCallExpression.Type));
case nameof(Queryable.Sum)
when QueryableMethods.IsSumWithSelector(method):
shapedQueryExpression = shapedQueryExpression.UpdateResultCardinality(ResultCardinality.Single);
return CheckTranslated(
TranslateSum(shapedQueryExpression, GetLambdaExpressionFromArgument(1), methodCallExpression.Type));
case nameof(Queryable.Take)
when genericMethod == QueryableMethods.Take:
return CheckTranslated(TranslateTake(shapedQueryExpression, methodCallExpression.Arguments[1]));
case nameof(Queryable.TakeWhile)
when genericMethod == QueryableMethods.TakeWhile:
return CheckTranslated(TranslateTakeWhile(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
case nameof(Queryable.ThenBy)
when genericMethod == QueryableMethods.ThenBy:
return CheckTranslated(TranslateThenBy(shapedQueryExpression, GetLambdaExpressionFromArgument(1), true));
case nameof(Queryable.ThenByDescending)
when genericMethod == QueryableMethods.ThenByDescending:
return CheckTranslated(TranslateThenBy(shapedQueryExpression, GetLambdaExpressionFromArgument(1), false));
case nameof(Queryable.Union)
when genericMethod == QueryableMethods.Union:
{
if (Visit(methodCallExpression.Arguments[1]) is ShapedQueryExpression innerShapedQueryExpression)
{
return CheckTranslated(TranslateUnion(shapedQueryExpression, innerShapedQueryExpression));
}
break;
}
case nameof(Queryable.Where)
when genericMethod == QueryableMethods.Where:
return CheckTranslated(TranslateWhere(shapedQueryExpression, GetLambdaExpressionFromArgument(1)));
LambdaExpression GetLambdaExpressionFromArgument(int argumentIndex) =>
methodCallExpression.Arguments[argumentIndex].UnwrapLambdaFromQuote();
}
}
}
return _subquery
? (Expression)null
: throw new NotImplementedException(CoreStrings.UnhandledMethod(method.Name));
}
private bool TryValidatePseudoHeaders()
{
// The initial pseudo header validation takes place in Http2Connection.ValidateHeader and StartStream
// They make sure the right fields are at least present (except for Connect requests) exactly once.
_httpVersion = Http.HttpVersion.Http2;
// Method could already have been set from :method static table index
if (Method == HttpMethod.None && !TryValidateMethod())
{
return(false);
}
if (!TryValidateAuthorityAndHost(out var hostText))
{
return(false);
}
// CONNECT - :scheme and :path must be excluded
if (Method == HttpMethod.Connect)
{
if (!String.IsNullOrEmpty(HttpRequestHeaders.HeaderScheme) || !String.IsNullOrEmpty(HttpRequestHeaders.HeaderPath))
{
ResetAndAbort(new ConnectionAbortedException(CoreStrings.Http2ErrorConnectMustNotSendSchemeOrPath), Http2ErrorCode.PROTOCOL_ERROR);
return(false);
}
RawTarget = hostText;
return(true);
}
// :scheme https://tools.ietf.org/html/rfc7540#section-8.1.2.3
// ":scheme" is not restricted to "http" and "https" schemed URIs. A
// proxy or gateway can translate requests for non - HTTP schemes,
// enabling the use of HTTP to interact with non - HTTP services.
// A common example is TLS termination.
var headerScheme = HttpRequestHeaders.HeaderScheme.ToString();
HttpRequestHeaders.HeaderScheme = default; // Suppress pseduo headers from the public headers collection.
if (!ReferenceEquals(headerScheme, Scheme) &&
!string.Equals(headerScheme, Scheme, StringComparison.OrdinalIgnoreCase))
{
if (!ServerOptions.AllowAlternateSchemes || !Uri.CheckSchemeName(headerScheme))
{
ResetAndAbort(new ConnectionAbortedException(
CoreStrings.FormatHttp2StreamErrorSchemeMismatch(headerScheme, Scheme)), Http2ErrorCode.PROTOCOL_ERROR);
return(false);
}
Scheme = headerScheme;
}
// :path (and query) - Required
// Must start with / except may be * for OPTIONS
var path = HttpRequestHeaders.HeaderPath.ToString();
HttpRequestHeaders.HeaderPath = default; // Suppress pseduo headers from the public headers collection.
RawTarget = path;
// OPTIONS - https://tools.ietf.org/html/rfc7540#section-8.1.2.3
// This pseudo-header field MUST NOT be empty for "http" or "https"
// URIs; "http" or "https" URIs that do not contain a path component
// MUST include a value of '/'. The exception to this rule is an
// OPTIONS request for an "http" or "https" URI that does not include
// a path component; these MUST include a ":path" pseudo-header field
// with a value of '*'.
if (Method == HttpMethod.Options && path.Length == 1 && path[0] == '*')
{
// * is stored in RawTarget only since HttpRequest expects Path to be empty or start with a /.
Path = string.Empty;
QueryString = string.Empty;
return(true);
}
// Approximate MaxRequestLineSize by totaling the required pseudo header field lengths.
var requestLineLength = _methodText !.Length + Scheme !.Length + hostText.Length + path.Length;
if (requestLineLength > ServerOptions.Limits.MaxRequestLineSize)
{
ResetAndAbort(new ConnectionAbortedException(CoreStrings.BadRequest_RequestLineTooLong), Http2ErrorCode.PROTOCOL_ERROR);
return(false);
}
var queryIndex = path.IndexOf('?');
QueryString = queryIndex == -1 ? string.Empty : path.Substring(queryIndex);
var pathSegment = queryIndex == -1 ? path.AsSpan() : path.AsSpan(0, queryIndex);
return(TryValidatePath(pathSegment));
}
async public override Task <List <T1> > ExecuteDeletedAsync(CancellationToken cancellationToken = default)
{
var ret = new List <T1>();
DbParameter[] dbParms = null;
StringBuilder sbret = null;
await ToSqlFetchAsync(async sb =>
{
if (dbParms == null)
{
dbParms = _params.ToArray();
sbret = new StringBuilder();
sbret.Append(" OUTPUT ");
var colidx = 0;
foreach (var col in _table.Columns.Values)
{
if (colidx > 0)
{
sbret.Append(", ");
}
sbret.Append(_commonUtils.RereadColumn(col, $"DELETED.{_commonUtils.QuoteSqlName(col.Attribute.Name)}")).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
++colidx;
}
}
var sql = sb.ToString();
var validx = sql.IndexOf(" WHERE ");
if (validx == -1)
{
throw new ArgumentException(CoreStrings.S_NotFound_Name("WHERE"));
}
sql = sb.Clear().Append(sql.Substring(0, validx))
.Append(sbret)
.Append(sql.Substring(validx)).ToString();
var before = new Aop.CurdBeforeEventArgs(_table.Type, _table, Aop.CurdType.Delete, sql, dbParms);
_orm.Aop.CurdBeforeHandler?.Invoke(this, before);
Exception exception = null;
try
{
ret.AddRange(await _orm.Ado.QueryAsync <T1>(_table.TypeLazy ?? _table.Type, _connection, _transaction, CommandType.Text, sql, _commandTimeout, dbParms, cancellationToken));
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
var after = new Aop.CurdAfterEventArgs(before, exception, ret);
_orm.Aop.CurdAfterHandler?.Invoke(this, after);
}
});
if (dbParms != null)
{
this.ClearData();
sbret.Clear();
}
return(ret);
}
public static TProperty Collate <TProperty>(
[NotNull] this DbFunctions _,
[NotNull] TProperty operand,
[NotNull][NotParameterized] string collation)
=> throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Collate)));
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected virtual void ValidateData([NotNull] IModel model)
{
Check.NotNull(model, nameof(model));
var identityMaps = new Dictionary <IKey, IIdentityMap>();
var sensitiveDataLogged = Dependencies.Logger.ShouldLogSensitiveData();
foreach (var entityType in model.GetEntityTypes().Where(et => !et.IsQueryType))
{
var key = entityType.FindPrimaryKey();
IIdentityMap identityMap = null;
foreach (var seedDatum in entityType.GetData())
{
foreach (var property in entityType.GetProperties())
{
if (!seedDatum.TryGetValue(property.Name, out var value) ||
value == null)
{
if (!property.IsNullable &&
(!property.RequiresValueGenerator() ||
property.IsKey()))
{
throw new InvalidOperationException(CoreStrings.SeedDatumMissingValue(entityType.DisplayName(), property.Name));
}
}
else if (property.RequiresValueGenerator() &&
property.IsKey() &&
property.ClrType.IsDefaultValue(value))
{
if (property.ClrType.IsSignedInteger())
{
throw new InvalidOperationException(CoreStrings.SeedDatumSignedNumericValue(entityType.DisplayName(), property.Name));
}
throw new InvalidOperationException(CoreStrings.SeedDatumDefaultValue(entityType.DisplayName(), property.Name, property.ClrType.GetDefaultValue()));
}
else if (!property.ClrType.GetTypeInfo().IsAssignableFrom(value.GetType().GetTypeInfo()))
{
if (sensitiveDataLogged)
{
throw new InvalidOperationException(
CoreStrings.SeedDatumIncompatibleValueSensitive(
entityType.DisplayName(), value, property.Name, property.ClrType.DisplayName()));
}
throw new InvalidOperationException(
CoreStrings.SeedDatumIncompatibleValue(
entityType.DisplayName(), property.Name, property.ClrType.DisplayName()));
}
}
var keyValues = new object[key.Properties.Count];
for (var i = 0; i < key.Properties.Count; i++)
{
keyValues[i] = seedDatum[key.Properties[i].Name];
}
foreach (var navigation in entityType.GetNavigations())
{
if (seedDatum.TryGetValue(navigation.Name, out var value) &&
((navigation.IsCollection() && value is IEnumerable collection && collection.Any()) ||
(!navigation.IsCollection() && value != null)))
{
if (sensitiveDataLogged)
{
throw new InvalidOperationException(
CoreStrings.SeedDatumNavigationSensitive(
entityType.DisplayName(),
string.Join(", ", key.Properties.Select((p, i) => p.Name + ":" + keyValues[i])),
navigation.Name,
navigation.GetTargetType().DisplayName(),
Property.Format(navigation.ForeignKey.Properties)));
}
throw new InvalidOperationException(
CoreStrings.SeedDatumNavigation(
entityType.DisplayName(),
navigation.Name,
navigation.GetTargetType().DisplayName(),
Property.Format(navigation.ForeignKey.Properties)));
}
}
if (identityMap == null)
{
if (!identityMaps.TryGetValue(key, out identityMap))
{
identityMap = key.GetIdentityMapFactory()(sensitiveDataLogged);
identityMaps[key] = identityMap;
}
}
var entry = identityMap.TryGetEntry(keyValues);
if (entry != null)
{
if (sensitiveDataLogged)
{
throw new InvalidOperationException(
CoreStrings.SeedDatumDuplicateSensitive(
entityType.DisplayName(), string.Join(", ", key.Properties.Select((p, i) => p.Name + ":" + keyValues[i]))));
}
throw new InvalidOperationException(
CoreStrings.SeedDatumDuplicate(
entityType.DisplayName(), Property.Format(key.Properties)));
}
entry = new InternalShadowEntityEntry(null, entityType);
identityMap.Add(keyValues, entry);
}
}
}
public override string ToSql()
{
if (_source?.Any() != true)
{
return(null);
}
var sqls = new string[2];
var dbParams = new List <DbParameter>();
var ds = SplitSourceByIdentityValueIsNull(_source);
if (ds.Item1.Any())
{
sqls[0] = string.Join("\r\n\r\n;\r\n\r\n", ds.Item1.Select(a => getMergeSql(a)));
}
if (ds.Item2.Any())
{
sqls[1] = string.Join("\r\n\r\n;\r\n\r\n", ds.Item2.Select(a => getInsertSql(a)));
}
_params = dbParams.ToArray();
if (ds.Item2.Any() == false)
{
return(sqls[0]);
}
if (ds.Item1.Any() == false)
{
return(sqls[1]);
}
return(string.Join("\r\n\r\n;\r\n\r\n", sqls));
string getMergeSql(List <T1> data)
{
if (_table.Primarys.Any() == false)
{
throw new Exception(CoreStrings.InsertOrUpdate_Must_Primary_Key(_table.CsName));
}
var sb = new StringBuilder().Append("MERGE INTO ").Append(_commonUtils.QuoteSqlName(TableRuleInvoke())).Append(" t1 \r\nUSING (");
WriteSourceSelectUnionAll(data, sb, dbParams);
sb.Append(" ) t2 ON (").Append(string.Join(" AND ", _table.Primarys.Select(a => $"t1.{_commonUtils.QuoteSqlName(a.Attribute.Name)} = t2.{_commonUtils.QuoteSqlName(a.Attribute.Name)}"))).Append(") \r\n");
var cols = _table.Columns.Values.Where(a => a.Attribute.IsPrimary == false && a.Attribute.CanUpdate == true && _updateIgnore.ContainsKey(a.Attribute.Name) == false);
if (_doNothing == false && cols.Any())
{
sb.Append("WHEN MATCHED THEN \r\n")
.Append(" update set ").Append(string.Join(", ", cols.Select(a =>
a.Attribute.IsVersion && a.Attribute.MapType != typeof(byte[]) ?
$"{_commonUtils.QuoteSqlName(a.Attribute.Name)} = t1.{_commonUtils.QuoteSqlName(a.Attribute.Name)} + 1" :
$"{_commonUtils.QuoteSqlName(a.Attribute.Name)} = t2.{_commonUtils.QuoteSqlName(a.Attribute.Name)}"
))).Append(" \r\n");
}
cols = _table.Columns.Values.Where(a => a.Attribute.CanInsert == true);
if (cols.Any())
{
sb.Append("WHEN NOT MATCHED THEN \r\n")
.Append(" insert (").Append(string.Join(", ", cols.Select(a => _commonUtils.QuoteSqlName(a.Attribute.Name)))).Append(") \r\n")
.Append(" values (").Append(string.Join(", ", cols.Select(a => $"t2.{_commonUtils.QuoteSqlName(a.Attribute.Name)}"))).Append(")");
}
return(sb.ToString());
}
string getInsertSql(List <T1> data)
{
var insert = _orm.Insert <T1>()
.AsTable(_tableRule).AsType(_table.Type)
.WithConnection(_connection)
.WithTransaction(_transaction)
.NoneParameter(true) as Internal.CommonProvider.InsertProvider <T1>;
insert._source = data;
insert._table = _table;
var sql = insert.ToSql();
if (string.IsNullOrEmpty(sql))
{
return(null);
}
if (insert._params?.Any() == true)
{
dbParams.AddRange(insert._params);
}
return(sql);
}
}
private async Task ProcessHeadersFrameAsync <TContext>(IHttpApplication <TContext> application)
{
if (_currentHeadersStream != null)
{
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorHeadersInterleaved(_incomingFrame.Type, _incomingFrame.StreamId, _currentHeadersStream.StreamId), Http2ErrorCode.PROTOCOL_ERROR);
}
if (_incomingFrame.StreamId == 0)
{
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorStreamIdZero(_incomingFrame.Type), Http2ErrorCode.PROTOCOL_ERROR);
}
if (_incomingFrame.HeadersHasPadding && _incomingFrame.HeadersPadLength >= _incomingFrame.Length)
{
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorPaddingTooLong(_incomingFrame.Type), Http2ErrorCode.PROTOCOL_ERROR);
}
if (_incomingFrame.HeadersHasPriority && _incomingFrame.HeadersStreamDependency == _incomingFrame.StreamId)
{
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorStreamSelfDependency(_incomingFrame.Type, _incomingFrame.StreamId), Http2ErrorCode.PROTOCOL_ERROR);
}
if (_streams.TryGetValue(_incomingFrame.StreamId, out var stream))
{
// http://httpwg.org/specs/rfc7540.html#rfc.section.5.1
//
// ...an endpoint that receives any frames after receiving a frame with the
// END_STREAM flag set MUST treat that as a connection error (Section 5.4.1)
// of type STREAM_CLOSED, unless the frame is permitted as described below.
//
// (The allowed frame types after END_STREAM are WINDOW_UPDATE, RST_STREAM and PRIORITY)
if (stream.EndStreamReceived)
{
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorStreamHalfClosedRemote(_incomingFrame.Type, stream.StreamId), Http2ErrorCode.STREAM_CLOSED);
}
// This is the last chance for the client to send END_STREAM
if ((_incomingFrame.HeadersFlags & Http2HeadersFrameFlags.END_STREAM) == 0)
{
throw new Http2ConnectionErrorException(CoreStrings.Http2ErrorHeadersWithTrailersNoEndStream, Http2ErrorCode.PROTOCOL_ERROR);
}
// Since we found an active stream, this HEADERS frame contains trailers
_currentHeadersStream = stream;
_requestHeaderParsingState = RequestHeaderParsingState.Trailers;
var endHeaders = (_incomingFrame.HeadersFlags & Http2HeadersFrameFlags.END_HEADERS) == Http2HeadersFrameFlags.END_HEADERS;
await DecodeTrailersAsync(endHeaders, _incomingFrame.HeadersPayload);
}
else if (_incomingFrame.StreamId <= _highestOpenedStreamId)
{
// http://httpwg.org/specs/rfc7540.html#rfc.section.5.1.1
//
// The first use of a new stream identifier implicitly closes all streams in the "idle"
// state that might have been initiated by that peer with a lower-valued stream identifier.
//
// If we couldn't find the stream, it was previously closed (either implicitly or with
// END_STREAM or RST_STREAM).
throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorStreamClosed(_incomingFrame.Type, _incomingFrame.StreamId), Http2ErrorCode.STREAM_CLOSED);
}
else
{
// Start a new stream
_currentHeadersStream = new Http2Stream(new Http2StreamContext
{
ConnectionId = ConnectionId,
StreamId = _incomingFrame.StreamId,
ServiceContext = _context.ServiceContext,
ConnectionFeatures = _context.ConnectionFeatures,
MemoryPool = _context.MemoryPool,
LocalEndPoint = _context.LocalEndPoint,
RemoteEndPoint = _context.RemoteEndPoint,
StreamLifetimeHandler = this,
FrameWriter = _frameWriter
});
if ((_incomingFrame.HeadersFlags & Http2HeadersFrameFlags.END_STREAM) == Http2HeadersFrameFlags.END_STREAM)
{
await _currentHeadersStream.OnDataAsync(Constants.EmptyData, endStream : true);
}
_currentHeadersStream.Reset();
var endHeaders = (_incomingFrame.HeadersFlags & Http2HeadersFrameFlags.END_HEADERS) == Http2HeadersFrameFlags.END_HEADERS;
await DecodeHeadersAsync(application, endHeaders, _incomingFrame.HeadersPayload);
}
}
public override string ExpressionLambdaToSqlCallString(MethodCallExpression exp, ExpTSC tsc)
{
Func <Expression, string> getExp = exparg => ExpressionLambdaToSql(exparg, tsc);
if (exp.Object == null)
{
switch (exp.Method.Name)
{
case "IsNullOrEmpty":
var arg1 = getExp(exp.Arguments[0]);
return($"({arg1} is null or {arg1} = '')");
case "IsNullOrWhiteSpace":
var arg2 = getExp(exp.Arguments[0]);
return($"({arg2} is null or {arg2} = '' or ltrim({arg2}) = '')");
case "Concat":
return(_common.StringConcat(exp.Arguments.Select(a => getExp(a)).ToArray(), null));
case "Format":
if (exp.Arguments[0].NodeType != ExpressionType.Constant)
{
throw new Exception(CoreStrings.Not_Implemented_Expression_ParameterUseConstant(exp, exp.Arguments[0]));
}
var expArgsHack = exp.Arguments.Count == 2 && exp.Arguments[1].NodeType == ExpressionType.NewArrayInit ?
(exp.Arguments[1] as NewArrayExpression).Expressions : exp.Arguments.Where((a, z) => z > 0);
//3个 {} 时，Arguments 解析出来是分开的
//4个 {} 时，Arguments[1] 只能解析这个出来，然后里面是 NewArray []
var expArgs = expArgsHack.Select(a => $"'||{_common.IsNull(ExpressionLambdaToSql(a, tsc), "''")}||'").ToArray();
return(string.Format(ExpressionLambdaToSql(exp.Arguments[0], tsc), expArgs));
case "Join": //未通用测试 #405
if (exp.IsStringJoin(out var tolistObjectExp, out var toListMethod, out var toListArgs1))
{
var newToListArgs0 = Expression.Call(tolistObjectExp, toListMethod,
Expression.Lambda(
Expression.Call(
typeof(SqlExtExtensions).GetMethod("StringJoinOracleGroupConcat"),
Expression.Convert(toListArgs1.Body, typeof(object)),
Expression.Convert(exp.Arguments[0], typeof(object))),
toListArgs1.Parameters));
var newToListSql = getExp(newToListArgs0);
return(newToListSql);
}
break;
}
}
else
{
var left = getExp(exp.Object);
switch (exp.Method.Name)
{
case "StartsWith":
case "EndsWith":
case "Contains":
var args0Value = getExp(exp.Arguments[0]);
if (args0Value == "NULL")
{
return($"({left}) IS NULL");
}
var likeOpt = "LIKE";
if (exp.Arguments.Count > 1)
{
if (exp.Arguments[1].Type == typeof(bool) ||
exp.Arguments[1].Type == typeof(StringComparison))
{
likeOpt = "ILIKE";
}
}
if (exp.Method.Name == "StartsWith")
{
return($"({left}) {likeOpt} {(args0Value.EndsWith("'") ? args0Value.Insert(args0Value.Length - 1, "%") : $"(({args0Value})::text || '%')")}");
}
if (exp.Method.Name == "EndsWith")
{
return($"({left}) {likeOpt} {(args0Value.StartsWith("'") ? args0Value.Insert(1, "%") : $"('%' || ({args0Value})::text)")}");
}
if (args0Value.StartsWith("'") && args0Value.EndsWith("'"))
{
return($"({left}) {likeOpt} {args0Value.Insert(1, "%").Insert(args0Value.Length, "%")}");
}
return($"({left}) {likeOpt} ('%' || ({args0Value})::text || '%')");
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
var unmappedProperty = entityType.GetProperties().FirstOrDefault(
p => (!ConfigurationSource.Convention.Overrides(p.GetConfigurationSource()) || !p.IsShadowProperty) &&
!IsMappedPrimitiveProperty(p));
if (unmappedProperty != null)
{
throw new InvalidOperationException(
CoreStrings.PropertyNotMapped(
entityType.DisplayName(), unmappedProperty.Name, unmappedProperty.ClrType.ShortDisplayName()));
}
if (!entityType.HasClrType())
{
continue;
}
var clrProperties = new HashSet <string>();
clrProperties.UnionWith(
entityType.GetRuntimeProperties().Values
.Where(pi => pi.IsCandidateProperty())
.Select(pi => pi.GetSimpleMemberName()));
clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name));
clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name));
clrProperties.ExceptWith(entityType.GetServiceProperties().Select(p => p.Name));
clrProperties.RemoveWhere(p => entityType.Builder.IsIgnored(p, ConfigurationSource.Convention));
if (clrProperties.Count <= 0)
{
continue;
}
foreach (var clrProperty in clrProperties)
{
var actualProperty = entityType.GetRuntimeProperties()[clrProperty];
var propertyType = actualProperty.PropertyType;
var targetSequenceType = propertyType.TryGetSequenceType();
if (modelBuilder.IsIgnored(
modelBuilder.Metadata.GetDisplayName(propertyType),
ConfigurationSource.Convention) ||
(targetSequenceType != null &&
modelBuilder.IsIgnored(
modelBuilder.Metadata.GetDisplayName(targetSequenceType),
ConfigurationSource.Convention)))
{
continue;
}
var targetType = FindCandidateNavigationPropertyType(actualProperty);
var isTargetWeakOrOwned
= targetType != null &&
(modelBuilder.Metadata.HasEntityTypeWithDefiningNavigation(targetType) ||
modelBuilder.Metadata.ShouldBeOwnedType(targetType));
if (targetType?.IsValidEntityType() == true &&
(isTargetWeakOrOwned ||
modelBuilder.Metadata.FindEntityType(targetType) != null ||
targetType.GetRuntimeProperties().Any(p => p.IsCandidateProperty())))
{
// ReSharper disable CheckForReferenceEqualityInstead.1
// ReSharper disable CheckForReferenceEqualityInstead.3
if (entityType.GetDerivedTypes().All(
dt => dt.FindDeclaredNavigation(actualProperty.GetSimpleMemberName()) == null) &&
(!isTargetWeakOrOwned ||
(!targetType.Equals(entityType.ClrType) &&
(!entityType.IsInOwnershipPath(targetType) ||
(entityType.FindOwnership().PrincipalEntityType.ClrType.Equals(targetType) &&
targetSequenceType == null)) &&
(!entityType.IsInDefinitionPath(targetType) ||
(entityType.DefiningEntityType.ClrType.Equals(targetType) &&
targetSequenceType == null)))))
{
if (modelBuilder.Metadata.ShouldBeOwnedType(entityType.ClrType) &&
modelBuilder.Metadata.ShouldBeOwnedType(targetType))
{
throw new InvalidOperationException(
CoreStrings.AmbiguousOwnedNavigation(entityType.DisplayName(), targetType.ShortDisplayName()));
}
throw new InvalidOperationException(
CoreStrings.NavigationNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
// ReSharper restore CheckForReferenceEqualityInstead.3
// ReSharper restore CheckForReferenceEqualityInstead.1
}
else if (targetSequenceType == null && propertyType.GetTypeInfo().IsInterface ||
targetSequenceType?.GetTypeInfo().IsInterface == true)
{
throw new InvalidOperationException(
CoreStrings.InterfacePropertyNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
else
{
throw new InvalidOperationException(
CoreStrings.PropertyNotAdded(
entityType.DisplayName(), actualProperty.Name, propertyType.ShortDisplayName()));
}
}
}
return(modelBuilder);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public static bool TryGetMemberInfo(
[NotNull] this IPropertyBase propertyBase,
bool forConstruction,
bool forSet,
out MemberInfo memberInfo,
out string errorMessage)
{
memberInfo = null;
errorMessage = null;
var propertyInfo = propertyBase.PropertyInfo;
var fieldInfo = propertyBase.FieldInfo;
var setterProperty = propertyInfo?.FindSetterProperty();
var getterProperty = propertyInfo?.FindGetterProperty();
var isCollectionNav = (propertyBase as INavigation)?.IsCollection() == true;
var hasField = fieldInfo != null;
var hasSetter = setterProperty != null;
var hasGetter = getterProperty != null;
var mode = propertyBase.GetPropertyAccessMode();
if (forConstruction)
{
if (mode == PropertyAccessMode.Field ||
mode == PropertyAccessMode.FieldDuringConstruction)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
if (isCollectionNav)
{
return(true);
}
errorMessage = GetNoFieldErrorMessage(propertyBase);
return(false);
}
if (mode == PropertyAccessMode.Property)
{
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
if (isCollectionNav)
{
return(true);
}
errorMessage = hasGetter
? CoreStrings.NoSetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode))
: CoreStrings.NoProperty(fieldInfo?.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode));
return(false);
}
if (mode == PropertyAccessMode.PreferField ||
mode == PropertyAccessMode.PreferFieldDuringConstruction)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
}
if (mode == PropertyAccessMode.PreferProperty)
{
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
}
if (isCollectionNav)
{
return(true);
}
errorMessage = CoreStrings.NoFieldOrSetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName());
return(false);
}
if (forSet)
{
if (mode == PropertyAccessMode.Field)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
if (isCollectionNav)
{
return(true);
}
errorMessage = GetNoFieldErrorMessage(propertyBase);
return(false);
}
if (mode == PropertyAccessMode.Property)
{
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
if (isCollectionNav)
{
return(true);
}
errorMessage = hasGetter
? CoreStrings.NoSetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode))
: CoreStrings.NoProperty(fieldInfo?.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode));
return(false);
}
if (mode == PropertyAccessMode.PreferField)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
}
if (mode == PropertyAccessMode.PreferProperty ||
mode == PropertyAccessMode.FieldDuringConstruction ||
mode == PropertyAccessMode.PreferFieldDuringConstruction)
{
if (hasSetter)
{
memberInfo = setterProperty;
return(true);
}
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
}
if (isCollectionNav)
{
return(true);
}
errorMessage = CoreStrings.NoFieldOrSetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName());
return(false);
}
// forGet
if (mode == PropertyAccessMode.Field)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
errorMessage = GetNoFieldErrorMessage(propertyBase);
return(false);
}
if (mode == PropertyAccessMode.Property)
{
if (hasGetter)
{
memberInfo = getterProperty;
return(true);
}
errorMessage = hasSetter
? CoreStrings.NoGetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode))
: CoreStrings.NoProperty(fieldInfo?.Name, propertyBase.DeclaringType.DisplayName(), nameof(PropertyAccessMode));
return(false);
}
if (mode == PropertyAccessMode.PreferField)
{
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
if (hasGetter)
{
memberInfo = getterProperty;
return(true);
}
}
if (mode == PropertyAccessMode.PreferProperty ||
mode == PropertyAccessMode.FieldDuringConstruction ||
mode == PropertyAccessMode.PreferFieldDuringConstruction)
{
if (hasGetter)
{
memberInfo = getterProperty;
return(true);
}
if (hasField)
{
memberInfo = fieldInfo;
return(true);
}
}
errorMessage = CoreStrings.NoFieldOrGetter(propertyBase.Name, propertyBase.DeclaringType.DisplayName());
return(false);
}
public FopePolicyRuleHasProhibitedRegularExpressionsException(int ruleId, string reason, Exception innerException) : base(CoreStrings.FopePolicyRuleHasProhibitedRegularExpressions(ruleId, reason), innerException)
{
this.ruleId = ruleId;
this.reason = reason;
}
public void Use_of_custom_IPropertyBase_throws()
{
Assert.Equal(
CoreStrings.CustomMetadata(nameof(Use_of_custom_IPropertyBase_throws), nameof(IPropertyBase), "IPropertyBaseProxy"),
Assert.Throws <NotSupportedException>(() => Mock.Of <IPropertyBase>().AsPropertyBase()).Message);
}
public void Finding_targets_throws_for_entity_types_not_in_the_relationship()
{
var fk = CreateOneToManyFK();
var unrelatedType = fk.DeclaringEntityType.Model.AddEntityType(typeof(NavigationBase));
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityType(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityType(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFrom(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFrom(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsTo(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationshipStrict(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsTo(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveEntityTypeInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveEntityTypeInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityTypeInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.ResolveOtherEntityTypeInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFromInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsFromInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsToInHierarchy(unrelatedType)).Message);
Assert.Equal(
CoreStrings.EntityTypeNotInRelationship(
unrelatedType.DisplayName(), fk.DeclaringEntityType.DisplayName(), fk.PrincipalEntityType.DisplayName()),
Assert.Throws <InvalidOperationException>(() => fk.FindNavigationsToInHierarchy(unrelatedType)).Message);
}
/// <summary> /// The soundex function converts a string to its Soundex code. /// </summary> /// <remarks> /// The method call is translated to <c>soundex(text)</c>. /// /// See https://www.postgresql.org/docs/current/fuzzystrmatch.html. /// </remarks> public static string FuzzyStringMatchSoundex(this DbFunctions _, string text) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FuzzyStringMatchSoundex)));
public void Use_of_custom_IKey_throws()
{
Assert.Equal(
CoreStrings.CustomMetadata(nameof(Use_of_custom_IKey_throws), nameof(IKey), "IKeyProxy"),
Assert.Throws <NotSupportedException>(() => Mock.Of <IKey>().AsKey()).Message);
}
/// <summary> /// Returns the Levenshtein distance between two strings. /// </summary> /// <remarks> /// The method call is translated to <c>levenshtein(source, target)</c>. /// /// See https://www.postgresql.org/docs/current/fuzzystrmatch.html. /// </remarks> public static int FuzzyStringMatchLevenshtein(this DbFunctions _, string source, string target) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FuzzyStringMatchLevenshtein)));
public override void Value_conversion_on_enum_collection_contains()
{
Assert.Contains(
CoreStrings.TranslationFailed("").Substring(47),
Assert.Throws <InvalidOperationException>(() => base.Value_conversion_on_enum_collection_contains()).Message);
}
/// <summary> /// levenshtein_less_equal is an accelerated version of the Levenshtein function for use when only small distances are of interest. /// If the actual distance is less than or equal to maximum distance, then levenshtein_less_equal returns the correct distance; /// otherwise it returns some value greater than maximum distance. If maximum distance is negative then the behavior is the same as levenshtein. /// </summary> /// <remarks> /// The method call is translated to <c>levenshtein_less_equal(source, target, insertionCost, deletionCost, substitutionCost, maximumDistance)</c>. /// /// See https://www.postgresql.org/docs/current/fuzzystrmatch.html. /// </remarks> public static int FuzzyStringMatchLevenshteinLessEqual(this DbFunctions _, string source, string target, int insertionCost, int deletionCost, int substitutionCost, int maximumDistance) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FuzzyStringMatchLevenshteinLessEqual)));
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override ValueGenerator Create(IProperty property)
{
var type = property.ClrType.UnwrapNullableType().UnwrapEnumType();
if (type == typeof(int))
{
return(new TemporaryIntValueGenerator());
}
if (type == typeof(long))
{
return(new TemporaryLongValueGenerator());
}
if (type == typeof(short))
{
return(new TemporaryShortValueGenerator());
}
if (type == typeof(byte))
{
return(new TemporaryByteValueGenerator());
}
if (type == typeof(char))
{
return(new TemporaryCharValueGenerator());
}
if (type == typeof(ulong))
{
return(new TemporaryULongValueGenerator());
}
if (type == typeof(uint))
{
return(new TemporaryUIntValueGenerator());
}
if (type == typeof(ushort))
{
return(new TemporaryUShortValueGenerator());
}
if (type == typeof(sbyte))
{
return(new TemporarySByteValueGenerator());
}
if (type == typeof(decimal))
{
return(new TemporaryDecimalValueGenerator());
}
if (type == typeof(float))
{
return(new TemporaryFloatValueGenerator());
}
if (type == typeof(double))
{
return(new TemporaryDoubleValueGenerator());
}
throw new ArgumentException(
CoreStrings.InvalidValueGeneratorFactoryProperty(
nameof(TemporaryNumberValueGeneratorFactory), property.Name, property.DeclaringEntityType.DisplayName()));
}
/// <summary> /// The metaphone function converts a string to its Metaphone code. /// </summary> /// <remarks> /// The method call is translated to <c>metaphone(text, maximumOutputLength)</c>. /// /// See https://www.postgresql.org/docs/current/fuzzystrmatch.html. /// </remarks> public static string FuzzyStringMatchMetaphone(this DbFunctions _, string text, int maximumOutputLength) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FuzzyStringMatchMetaphone)));
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual Expression CreateMaterializeExpression(
IEntityType entityType,
string entityInstanceName,
Expression materializationContextExpression,
int[] indexMap = null)
{
if (!entityType.HasClrType())
{
throw new InvalidOperationException(CoreStrings.NoClrType(entityType.DisplayName()));
}
if (entityType.IsAbstract())
{
throw new InvalidOperationException(CoreStrings.CannotMaterializeAbstractType(entityType));
}
var constructorBinding = (InstantiationBinding)entityType[CoreAnnotationNames.ConstructorBinding];
if (constructorBinding == null)
{
var constructorInfo = entityType.ClrType.GetDeclaredConstructor(null);
if (constructorInfo == null)
{
throw new InvalidOperationException(CoreStrings.NoParameterlessConstructor(entityType.DisplayName()));
}
constructorBinding = new ConstructorBinding(constructorInfo, Array.Empty <ParameterBinding>());
}
var bindingInfo = new ParameterBindingInfo(
entityType,
materializationContextExpression,
indexMap);
var properties = new HashSet <IPropertyBase>(
entityType.GetServiceProperties().Cast <IPropertyBase>()
.Concat(
entityType
.GetProperties()
.Where(p => !p.IsShadowProperty())));
foreach (var consumedProperty in constructorBinding
.ParameterBindings
.SelectMany(p => p.ConsumedProperties))
{
properties.Remove(consumedProperty);
}
var constructorExpression = constructorBinding.CreateConstructorExpression(bindingInfo);
if (properties.Count == 0)
{
return(constructorExpression);
}
var instanceVariable = Expression.Variable(constructorBinding.RuntimeType, entityInstanceName);
var blockExpressions
= new List <Expression>
{
Expression.Assign(
instanceVariable,
constructorExpression)
};
var valueBufferExpression = Expression.Call(materializationContextExpression, MaterializationContext.GetValueBufferMethod);
foreach (var property in properties)
{
var memberInfo = property.GetMemberInfo(forConstruction: true, forSet: true);
var readValueExpression
= property is IServiceProperty serviceProperty
? serviceProperty.GetParameterBinding().BindToParameter(bindingInfo)
: CreateReadValueExpression(
valueBufferExpression,
memberInfo.GetMemberType(),
indexMap?[property.GetIndex()] ?? property.GetIndex(),
property);
blockExpressions.Add(
Expression.MakeMemberAccess(
instanceVariable,
memberInfo).Assign(
readValueExpression));
}
blockExpressions.Add(instanceVariable);
return(Expression.Block(
new[]
{
instanceVariable
}, blockExpressions));
}
/// <summary> /// The dmetaphone function converts a string to its primary Double Metaphone code. /// </summary> /// <remarks> /// The method call is translated to <c>dmetaphone(text)</c>. /// /// See https://www.postgresql.org/docs/current/fuzzystrmatch.html. /// </remarks> public static string FuzzyStringMatchDoubleMetaphone(this DbFunctions _, string text) => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FuzzyStringMatchDoubleMetaphone)));
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
{
foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
{
if (entityType.ClrType?.IsAbstract == false)
{
var maxServiceParams = 0;
var minPropertyParams = int.MaxValue;
var foundBindings = new List <ConstructorBinding>();
var bindingFailures = new List <IEnumerable <ParameterInfo> >();
foreach (var constructor in entityType.ClrType.GetTypeInfo()
.DeclaredConstructors
.Where(c => !c.IsStatic))
{
// Trying to find the constructor with the most service properties
// followed by the least scalar property parameters
if (_bindingFactory.TryBindConstructor(entityType, constructor, out var binding, out var failures))
{
var serviceParamCount = binding.ParameterBindings.OfType <ServiceParameterBinding>().Count();
var propertyParamCount = binding.ParameterBindings.Count - serviceParamCount;
if (serviceParamCount == maxServiceParams &&
propertyParamCount == minPropertyParams)
{
foundBindings.Add(binding);
}
else if (serviceParamCount > maxServiceParams)
{
foundBindings.Clear();
foundBindings.Add(binding);
maxServiceParams = serviceParamCount;
minPropertyParams = propertyParamCount;
}
else if (propertyParamCount < minPropertyParams)
{
foundBindings.Clear();
foundBindings.Add(binding);
maxServiceParams = serviceParamCount;
minPropertyParams = propertyParamCount;
}
}
else
{
bindingFailures.Add(failures);
}
}
if (foundBindings.Count == 0)
{
var constructorErrors = bindingFailures.SelectMany(f => f)
.GroupBy(f => f.Member as ConstructorInfo)
.Select(
x =>
CoreStrings.ConstructorBindingFailed(
string.Join("', '", x.Select(f => f.Name)),
entityType.DisplayName() + "(" +
string.Join(
", ", x.Key.GetParameters().Select(
y =>
y.ParameterType.ShortDisplayName() + " " + y.Name)
) +
")"
)
);
throw new InvalidOperationException(
CoreStrings.ConstructorNotFound(
entityType.DisplayName(),
string.Join("; ", constructorErrors)));
}
if (foundBindings.Count > 1)
{
throw new InvalidOperationException(
CoreStrings.ConstructorConflict(
FormatConstructorString(entityType, foundBindings[0]),
FormatConstructorString(entityType, foundBindings[1])));
}
entityType.Builder.HasAnnotation(
CoreAnnotationNames.ConstructorBinding,
foundBindings[0],
ConfigurationSource.Convention);
}
/// <summary>
/// Returns a warning-as-error exception wrapping the given message for this event.
/// </summary>
/// <param name="message"> The message to wrap. </param>
protected virtual Exception WarningAsError([NotNull] string message)
=> new InvalidOperationException(
CoreStrings.WarningAsErrorTemplate(
EventId.ToString(),
message,
EventIdCode ?? EventId.Id.ToString()));
