internal Expression GetProjectorExpression(Alias tableAlias, QueryBinder binder)
{
Expression?id = GetIdExpression(tableAlias);
if (IsView)
{
var bindings = this.Fields.Values.Select(ef => new FieldBinding(ef.FieldInfo, ef.Field.GetExpression(tableAlias, binder, id !, null, null))).ToReadOnly();
var hasValue = id == null?Expression.Constant(true) : SmartEqualizer.NotEqualNullable(id, Expression.Constant(null, id.Type.Nullify()));
return(new EmbeddedEntityExpression(this.Type, hasValue, bindings, null, null, this, null));
}
else
{
Schema.Current.AssertAllowed(Type, inUserInterface: false);
var entityContext = new EntityContextInfo((PrimaryKeyExpression)id !, null);
var period = GenerateSystemPeriod(tableAlias, binder);
var bindings = GenerateBindings(tableAlias, binder, id !, period, entityContext);
var mixins = GenerateMixins(tableAlias, binder, id !, period, entityContext);
var result = new EntityExpression(this.Type, (PrimaryKeyExpression)id !, period, tableAlias, bindings, mixins, period, avoidExpandOnRetrieving: false);
return(result);
}
}
internal override Expression GetExpression(Alias tableAlias, QueryBinder binder, Expression id)
{
var bindings = (from kvp in EmbeddedFields
let fi = kvp.Value.FieldInfo
select new FieldBinding(fi, kvp.Value.Field.GetExpression(tableAlias, binder, id))).ToReadOnly();
Expression hasValue = HasValue == null?SmartEqualizer.NotEqualNullable(id,
id is PrimaryKeyExpression?QueryBinder.NullId(((PrimaryKeyExpression)id).ValueType) : (Expression)Expression.Constant(null, id.Type.Nullify())) :
new ColumnExpression(((IColumn)HasValue).Type, tableAlias, HasValue.Name);
return(new EmbeddedEntityExpression(this.FieldType, hasValue, bindings, this));
}
internal override Expression GetExpression(Alias tableAlias, QueryBinder binder, Expression id, IntervalExpression?period, EntityContextInfo?entityContext)
{
var bindings = (from kvp in EmbeddedFields
let fi = kvp.Value.FieldInfo
select new FieldBinding(fi, kvp.Value.Field.GetExpression(tableAlias, binder, id, period, entityContext)))
.Concat(entityContext == null ? Enumerable.Empty <FieldBinding>() : Schema.Current.GetAdditionalQueryBindings(this.Route, entityContext, period))
.ToReadOnly();
Expression hasValue = HasValue == null?SmartEqualizer.NotEqualNullable(id,
id is PrimaryKeyExpression?QueryBinder.NullId(((PrimaryKeyExpression)id).ValueType) : (Expression)Expression.Constant(null, id.Type.Nullify())) :
new ColumnExpression(((IColumn)HasValue).Type, tableAlias, HasValue.Name);
return(new EmbeddedEntityExpression(this.FieldType, hasValue, bindings, this, null, entityContext));
}
private Expression?LiteToString(LiteReferenceExpression lite, Expression typeId)
{
if (lite.CustomToStr != null)
{
return(Visit(lite.CustomToStr));
}
if (lite.Reference is ImplementedByAllExpression)
{
return(null);
}
if (lite.LazyToStr)
{
return(null);
}
if (IsCacheable(typeId))
{
return(null);
}
if (lite.Reference is EntityExpression entityExp)
{
if (entityExp.AvoidExpandOnRetrieving)
{
return(null);
}
return(binder.BindMethodCall(Expression.Call(entityExp, EntityExpression.ToStringMethod)));
}
if (lite.Reference is ImplementedByExpression ibe)
{
if (ibe.Implementations.Any(imp => imp.Value.AvoidExpandOnRetrieving))
{
return(null);
}
return(ibe.Implementations.Values.Select(ee =>
new When(SmartEqualizer.NotEqualNullable(ee.ExternalId, QueryBinder.NullId(ee.ExternalId.ValueType)),
binder.BindMethodCall(Expression.Call(ee, EntityExpression.ToStringMethod)))
).ToCondition(typeof(string)));
}
return(binder.BindMethodCall(Expression.Call(lite.Reference, EntityExpression.ToStringMethod)));
}
private static Expression?EnumEquals(Expression exp1, Expression exp2)
{
bool anyEnum = false;
var exp1Clean = RemoveConvertChain(exp1, ref anyEnum);
var exp2Clean = RemoveConvertChain(exp2, ref anyEnum);
if (exp1Clean.Type.UnNullify() == typeof(DayOfWeek) ||
exp2Clean.Type.UnNullify() == typeof(DayOfWeek))
{
return(SmartEqualizer.EqualNullable(
ConstantToDayOfWeek(exp1Clean) ?? exp1Clean,
ConstantToDayOfWeek(exp2Clean) ?? exp2Clean));
}
if (anyEnum)
{
var type = exp2.Type.IsNullable() ? exp1.Type.Nullify(): exp1.Type;
return(SmartEqualizer.EqualNullable(exp1Clean.TryConvert(type), exp2Clean.TryConvert(type)));
}
return(null);
}
public static Expression PolymorphicEqual(Expression exp1, Expression exp2)
{
if (exp1.NodeType == ExpressionType.New || exp2.NodeType == ExpressionType.New)
{
if (exp1.IsNull() || exp2.IsNull())
{
return(Expression.Constant(false));
}
exp1 = ConstanToNewExpression(exp1) ?? exp1;
exp2 = ConstanToNewExpression(exp2) ?? exp2;
return(((NewExpression)exp1).Arguments.ZipStrict(
((NewExpression)exp2).Arguments, (o, i) => SmartEqualizer.PolymorphicEqual(o, i)).AggregateAnd());
}
Expression?result;
result = PrimaryKeyEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = ObjectEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = ConditionalEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = CoalesceEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = LiteEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = EntityEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = TypeEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = MListElementEquals(exp1, exp2);
if (result != null)
{
return(result);
}
result = EnumEquals(exp1, exp2);
if (result != null)
{
return(result);
}
return(EqualNullable(exp1, exp2));
}
