protected override Expression VisitDeclaration(DbDeclarationCommand decl)
{
if (decl.Source != null)
{
var projection = new DbProjectionExpression
(
decl.Source,
Expression.NewArrayInit(typeof(object), decl.Variables.Select(v => v.Expression.Type.GetTypeInfo().IsValueType ? Expression.Convert(v.Expression, typeof(object)) : v.Expression).ToArray()),
DbAggregator.GetAggregator(typeof(object[]), typeof(IEnumerable <object[]>))
);
var vars = Expression.Parameter(typeof(object[]), "vars");
this.variables.Add(vars);
this.initializers.Add(Expression.Constant(null, typeof(object[])));
for (int i = 0, n = decl.Variables.Count; i < n; i++)
{
var v = decl.Variables[i];
var nv = new DbNamedValueExpression
(
v.Name, v.QueryType,
Expression.Convert(Expression.ArrayIndex(vars, Expression.Constant(i)), v.Expression.Type)
);
this.variableMap.Add(v.Name, nv);
}
return(MakeAssign(vars, this.Visit(projection)));
}
throw new InvalidOperationException("Declaration query not allowed for this langauge");
}
public override Expression GetMemberExpression(Expression root, MappingEntity entity, MemberInfo member)
{
if (this.mapping.IsAssociationRelationship(entity, member))
{
var relatedEntity = this.mapping.GetRelatedEntity(entity, member);
var projection = this.GetQueryExpression(relatedEntity);
var declaredTypeMembers = this.mapping.GetAssociationKeyMembers(entity, member).ToList();
var associatedMembers = this.mapping.GetAssociationRelatedKeyMembers(entity, member).ToList();
var where = null as Expression;
for (int i = 0, n = associatedMembers.Count; i < n; i++)
{
var equal = this.GetMemberExpression
(
projection.Projector,
relatedEntity,
associatedMembers[i]).Equal(this.GetMemberExpression(root, entity, declaredTypeMembers[i])
);
where = (where != null) ? where.And(equal) : equal;
}
var newAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns
(
this.translator.Linguist.Language,
projection.Projector, null,
newAlias,
projection.Select.Alias
);
var aggregator = DbAggregator.GetAggregator(TypeHelper.GetMemberType(member), typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new DbProjectionExpression
(
new DbSelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator
);
return(this.translator.Police.ApplyPolicy(result, member));
}
if (root is DbAliasedExpression aliasedRoot && this.mapping.IsColumn(entity, member))
{
return(new DbColumnExpression
(
TypeHelper.GetMemberType(member),
this.GetColumnType(entity, member),
aliasedRoot.Alias,
this.mapping.GetColumnName(entity, member)
));
}
return(DbQueryBinder.BindMember(root, member));
}
protected virtual Expression GetUpdateResult(MappingEntity entity, Expression instance, LambdaExpression selector)
{
var tq = this.GetQueryExpression(entity);
var where = this.GetIdentityCheck(tq.Select, entity, instance);
var selection = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], tq.Projector);
var newAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns(this.translator.Linguist.Language, selection, null, newAlias, tq.Select.Alias);
return(new DbProjectionExpression
(
new DbSelectExpression(newAlias, pc.Columns, tq.Select, where),
pc.Projector,
DbAggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(selector.Body.Type))
));
}
protected override Expression VisitExists(DbExistsExpression exists)
{
var colType = this.linguist.Language.TypeSystem.GetColumnType(typeof(int));
var newSelect = exists.Select.SetColumns(new[]
{
new DbColumnDeclaration("value", new DbAggregateExpression(typeof(int), "Count", null, false), colType)
});
var projection = new DbProjectionExpression
(
newSelect,
new DbColumnExpression(typeof(int), colType, newSelect.Alias, "value"),
DbAggregator.GetAggregator(typeof(int), typeof(IEnumerable <int>))
);
return(this.Visit(projection.GreaterThan(Expression.Constant(0))));
}
protected virtual Expression GetInsertResult(MappingEntity entity, Expression instance, LambdaExpression selector, Dictionary <MemberInfo, Expression> map)
{
var tableAlias = new TableAlias();
var tex = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var aggregator = DbAggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(selector.Body.Type));
var where = null as Expression;
var genIdCommand = null as DbDeclarationCommand;
var generatedIds = this.mapping.GetMappedMembers(entity).Where(m => this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)).ToList();
if (generatedIds.Count > 0)
{
if (map == null || !generatedIds.Any(m => map.ContainsKey(m)))
{
var localMap = new Dictionary <MemberInfo, Expression>();
genIdCommand = this.GetGeneratedIdCommand(entity, generatedIds.ToList(), localMap);
map = localMap;
}
if (selector.Body is MemberExpression mex && this.mapping.IsPrimaryKey(entity, mex.Member) && this.mapping.IsGenerated(entity, mex.Member))
{
if (genIdCommand != null)
{
return(new DbProjectionExpression
(
genIdCommand.Source,
new DbColumnExpression(mex.Type, genIdCommand.Variables[0].QueryType, genIdCommand.Source.Alias, genIdCommand.Source.Columns[0].Name),
aggregator
));
}
else
{
var alias = new TableAlias();
var colType = this.GetColumnType(entity, mex.Member);
return(new DbProjectionExpression
(
new DbSelectExpression(alias, new[] { new DbColumnDeclaration(string.Empty, map[mex.Member], colType) }, null, null),
new DbColumnExpression(TypeHelper.GetMemberType(mex.Member), colType, alias, string.Empty),
aggregator
));
}
}
where = generatedIds.Select((m, i) => this.GetMemberExpression(tex, entity, m).Equal(map[m])).Aggregate((x, y) => x.And(y));
}
else
{
where = this.GetIdentityCheck(tex, entity, instance);
}
var typeProjector = this.GetEntityExpression(tex, entity);
var selection = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], typeProjector);
var newAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns(this.translator.Linguist.Language, selection, null, newAlias, tableAlias);
var pe = new DbProjectionExpression
(
new DbSelectExpression(newAlias, pc.Columns, tex, where),
pc.Projector,
aggregator
);
if (genIdCommand != null)
{
return(new DbBlockCommand(genIdCommand, pe));
}
return(pe);
}
