public override Expression GetInsertExpression(MappingEntity entity, Expression instance, LambdaExpression selector)
{
var tableAlias = new TableAlias();
var table = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var assignments = this.GetColumnAssignments(table, instance, entity, (e, m) => !(mapping.IsGenerated(e, m) || mapping.IsReadOnly(e, m))); // #MLCHANGE
if (selector != null)
{
return(new BlockCommand(
new InsertCommand(table, assignments),
this.GetInsertResult(entity, instance, selector, null)
));
}
return(new InsertCommand(table, assignments));
}
public override ProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tableAlias = new TableAlias();
var selectAlias = new TableAlias();
var table = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
Expression projector = this.GetEntityExpression(table, entity);
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, projector, null, selectAlias, tableAlias);
var proj = new ProjectionExpression(
new SelectExpression(selectAlias, pc.Columns, table, null),
pc.Projector
);
return((ProjectionExpression)this.Translator.Police.ApplyPolicy(proj, entity.ElementType));
}
private bool GetEquiJoinKeyExpressions(Expression predicate, TableAlias outerAlias, List <Expression> outerExpressions, List <Expression> innerExpressions)
{
if (predicate.NodeType == ExpressionType.Equal)
{
var b = (BinaryExpression)predicate;
ColumnExpression leftCol = this.GetColumnExpression(b.Left);
ColumnExpression rightCol = this.GetColumnExpression(b.Right);
if (leftCol != null && rightCol != null)
{
if (leftCol.TableAlias == outerAlias)
{
outerExpressions.Add(b.Left);
innerExpressions.Add(b.Right);
return(true);
}
else if (rightCol.TableAlias == outerAlias)
{
innerExpressions.Add(b.Left);
outerExpressions.Add(b.Right);
return(true);
}
}
}
bool hadKey = false;
var parts = predicate.Split(ExpressionType.And, ExpressionType.AndAlso);
if (parts.Length > 1)
{
foreach (var part in parts)
{
bool hasOuterAliasReference = ReferencedAliasGatherer.Gather(part).Contains(outerAlias);
if (hasOuterAliasReference)
{
if (!GetEquiJoinKeyExpressions(part, outerAlias, outerExpressions, innerExpressions))
{
return(false);
}
hadKey = true;
}
}
}
return(hadKey);
}
private ColumnProjector(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
this.language = language;
this.newAlias = newAlias;
this.existingAliases = new HashSet <TableAlias>(existingAliases);
this.map = new Dictionary <ColumnExpression, ColumnExpression>();
if (existingColumns != null)
{
this.columns = new List <ColumnDeclaration>(existingColumns);
this.columnNames = new HashSet <string>(existingColumns.Select(c => c.Name));
}
else
{
this.columns = new List <ColumnDeclaration>();
this.columnNames = new HashSet <string>();
}
this.candidates = Nominator.Nominate(language, expression);
}
public override Expression GetPartialUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression @else)
{
var tableAlias = new TableAlias();
var table = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var where = this.GetIdentityCheck(table, entity, instance);
if (updateCheck != null)
{
Expression typeProjector = this.GetEntityExpression(table, entity);
Expression pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector);
where = where.And(pred);
}
var assignments = this.GetColumnAssignments(table, instance, entity, (e, m) => this.mapping.IsUpdatable(e, m));
Expression update = new PartialUpdateCommand(table, where, assignments);
if (selector != null)
{
return(new BlockCommand(
update,
new IFCommand(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).GreaterThan(Expression.Constant(0)),
this.GetUpdateResult(entity, instance, selector),
@else
)
));
}
else if (@else != null)
{
return(new BlockCommand(
update,
new IFCommand(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).LessThanOrEqual(Expression.Constant(0)),
@else,
null
)
));
}
else
{
return(update);
}
}
protected override Expression VisitProjection(ProjectionExpression proj)
{
if (isTopLevel)
{
isTopLevel = false;
this.currentSelect = proj.Select;
Expression projector = this.Visit(proj.Projector);
if (projector != proj.Projector || this.currentSelect != proj.Select)
{
return(new ProjectionExpression(this.currentSelect, projector, proj.Aggregator));
}
return(proj);
}
if (proj.IsSingleton && this.CanJoinOnServer(this.currentSelect))
{
TableAlias newAlias = new TableAlias();
this.currentSelect = this.currentSelect.AddRedundantSelect(this.language, newAlias);
// remap any references to the outer select to the new alias;
SelectExpression source = (SelectExpression)ColumnMapper.Map(proj.Select, newAlias, this.currentSelect.Alias);
// add outer-join test
ProjectionExpression pex = this.language.AddOuterJoinTest(new ProjectionExpression(source, proj.Projector));
var pc = ColumnProjector.ProjectColumns(this.language, pex.Projector, this.currentSelect.Columns, this.currentSelect.Alias, newAlias, proj.Select.Alias);
JoinExpression join = new JoinExpression(JoinType.OuterApply, this.currentSelect.From, pex.Select, null);
this.currentSelect = new SelectExpression(this.currentSelect.Alias, pc.Columns, join, null);
return(this.Visit(pc.Projector));
}
var saveTop = this.isTopLevel;
var saveSelect = this.currentSelect;
this.isTopLevel = true;
this.currentSelect = null;
Expression result = base.VisitProjection(proj);
this.isTopLevel = saveTop;
this.currentSelect = saveSelect;
return(result);
}
public override Expression GetMemberExpression(Expression root, MappingEntity entity, MemberInfo member)
{
if (this.mapping.IsAssociationRelationship(entity, member))
{
MappingEntity relatedEntity = this.mapping.GetRelatedEntity(entity, member);
ProjectionExpression projection = this.GetQueryExpression(relatedEntity);
// make where clause for joining back to 'root'
var declaredTypeMembers = this.mapping.GetAssociationKeyMembers(entity, member).ToList();
var associatedMembers = this.mapping.GetAssociationRelatedKeyMembers(entity, member).ToList();
Expression where = null;
for (int i = 0, n = associatedMembers.Count; i < n; i++)
{
Expression equal =
this.GetMemberExpression(projection.Projector, relatedEntity, associatedMembers[i]).Equal(
this.GetMemberExpression(root, entity, declaredTypeMembers[i])
);
where = (where != null) ? where.And(equal) : equal;
}
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, projection.Projector, null, newAlias, projection.Select.Alias);
LambdaExpression aggregator = Aggregator.GetAggregator(TypeHelper.GetMemberType(member), typeof(IEnumerable <>).MakeGenericType(pc.Projector.Type));
var result = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, projection.Select, where),
pc.Projector, aggregator
);
return(this.translator.Police.ApplyPolicy(result, member));
}
else
{
AliasedExpression aliasedRoot = root as AliasedExpression;
if (aliasedRoot != null && this.mapping.IsColumn(entity, member))
{
return(new ColumnExpression(TypeHelper.GetMemberType(member), this.GetColumnType(entity, member), aliasedRoot.Alias, this.mapping.GetColumnName(entity, member), new ColumnAlias(this.mapping.GetColumnAlias(entity, member))));
}
return(QueryBinder.BindMember(root, member));
}
}
public override Expression GetInsertExpression(MappingEntity entity, Expression instance, LambdaExpression selector)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count < 2)
{
return(base.GetInsertExpression(entity, instance, selector));
}
var commands = new List <Expression>();
var map = this.GetDependentGeneratedColumns(entity);
var vexMap = new Dictionary <MemberInfo, Expression>();
foreach (var table in this.GetDependencyOrderedTables(entity))
{
var tableAlias = new TableAlias();
var tex = new TableExpression(tableAlias, entity, this.mapping.GetTableName(table));
var assignments = this.GetColumnAssignments(tex, instance, entity,
(e, m) => this.mapping.GetAlias(e, m) == this.mapping.GetAlias(table) && !this.mapping.IsGenerated(e, m),
vexMap
);
var totalAssignments = assignments.Concat(
this.GetRelatedColumnAssignments(tex, entity, table, vexMap)
);
commands.Add(new InsertCommand(tex, totalAssignments));
List <MemberInfo> members;
if (map.TryGetValue(this.mapping.GetAlias(table), out members))
{
var d = this.GetDependentGeneratedVariableDeclaration(entity, table, members, instance, vexMap);
commands.Add(d);
}
}
if (selector != null)
{
commands.Add(this.GetInsertResult(entity, instance, selector, vexMap));
}
return(new BlockCommand(commands));
}
private Expression MakeSubquery(Expression expression)
{
var newAlias = new TableAlias();
var aliases = DeclaredAliasGatherer.Gather(expression);
var decls = new List <ColumnDeclaration>();
foreach (var ta in aliases)
{
foreach (var col in this.columns[ta])
{
string name = decls.GetAvailableColumnName(col.Name);
var decl = new ColumnDeclaration(name, null, col, col.QueryType);
decls.Add(decl);
var newCol = new ColumnExpression(col.Type, col.QueryType, newAlias, col.Name, null);
this.map.Add(col, newCol);
}
}
return(new SelectExpression(newAlias, decls, expression, null));
}
protected virtual DeclarationCommand GetGeneratedIdCommand(MappingEntity entity, List <MemberInfo> members, Dictionary <MemberInfo, Expression> map)
{
var columns = new List <ColumnDeclaration>();
var decls = new List <VariableDeclaration>();
var alias = new TableAlias();
foreach (var member in members)
{
Expression genId = this.translator.Linguist.Language.GetGeneratedIdExpression(member);
var name = member.Name;
var colType = this.GetColumnType(entity, member);
columns.Add(new ColumnDeclaration(mapping.GetColumnName(entity, member), mapping.GetColumnAlias(entity, member), genId, colType));
decls.Add(new VariableDeclaration(member.Name, colType, new ColumnExpression(genId.Type, colType, alias, member.Name, new ColumnAlias(mapping.GetColumnAlias(entity, member)))));
if (map != null)
{
var vex = new VariableExpression(member.Name, TypeHelper.GetMemberType(member), colType);
map.Add(member, vex);
}
}
var select = new SelectExpression(alias, columns, null, null);
return(new DeclarationCommand(decls, select));
}
public SelectExpression(
TableAlias alias,
IEnumerable <ColumnDeclaration> columns,
Expression from,
Expression where,
IEnumerable <OrderExpression> orderBy,
IEnumerable <Expression> groupBy,
bool isDistinct,
Expression skip,
Expression take,
bool reverse
)
: base(DbExpressionType.Select, typeof(void), alias)
{
this.columns = columns.ToReadOnly();
this.isDistinct = isDistinct;
this.from = from;
this.where = where;
this.orderBy = orderBy.ToReadOnly();
this.groupBy = groupBy.ToReadOnly();
this.take = take;
this.skip = skip;
this.reverse = reverse;
}
protected AliasedExpression(DbExpressionType nodeType, Type type, TableAlias alias)
: base(nodeType, type)
{
this.alias = alias;
}
public override int GetHashCode()
{
return(TableAlias.GetHashCode() + Name.GetHashCode());
}
public AllColumnExpression(TableAlias tableAlias)
: base(DbExpressionType.AllColumn, null)
{
this.TableAlias = tableAlias;
this.Name = ColumnName;
}
public TableExpression(TableAlias alias, MappingEntity entity, string name)
: base(DbExpressionType.Table, typeof(void), alias)
{
this.entity = entity;
this.name = name;
}
protected override Expression VisitProjection(ProjectionExpression proj)
{
SelectExpression save = this.currentSelect;
this.currentSelect = proj.Select;
try
{
if (!this.isTopLevel)
{
if (this.CanJoinOnClient(this.currentSelect))
{
// make a query that combines all the constraints from the outer queries into a single select
SelectExpression newOuterSelect = (SelectExpression)QueryDuplicator.Duplicate(save);
// remap any references to the outer select to the new alias;
SelectExpression newInnerSelect = (SelectExpression)ColumnMapper.Map(proj.Select, newOuterSelect.Alias, save.Alias);
// add outer-join test
ProjectionExpression newInnerProjection = this.language.AddOuterJoinTest(new ProjectionExpression(newInnerSelect, proj.Projector));
newInnerSelect = newInnerProjection.Select;
Expression newProjector = newInnerProjection.Projector;
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.language, newProjector, null, newAlias, newOuterSelect.Alias, newInnerSelect.Alias);
JoinExpression join = new JoinExpression(JoinType.OuterApply, newOuterSelect, newInnerSelect, null);
SelectExpression joinedSelect = new SelectExpression(newAlias, pc.Columns, join, null, null, null, proj.IsSingleton, null, null, false);
// apply client-join treatment recursively
this.currentSelect = joinedSelect;
newProjector = this.Visit(pc.Projector);
// compute keys (this only works if join condition was a single column comparison)
List <Expression> outerKeys = new List <Expression>();
List <Expression> innerKeys = new List <Expression>();
if (this.GetEquiJoinKeyExpressions(newInnerSelect.Where, newOuterSelect.Alias, outerKeys, innerKeys))
{
// outerKey needs to refer to the outer-scope's alias
var outerKey = outerKeys.Select(k => ColumnMapper.Map(k, save.Alias, newOuterSelect.Alias));
// innerKey needs to refer to the new alias for the select with the new join
var innerKey = innerKeys.Select(k => ColumnMapper.Map(k, joinedSelect.Alias, ((ColumnExpression)k).TableAlias));
ProjectionExpression newProjection = new ProjectionExpression(joinedSelect, newProjector, proj.Aggregator);
return(new ClientJoinExpression(newProjection, outerKey, innerKey));
}
}
else
{
bool saveJoin = this.canJoinOnClient;
this.canJoinOnClient = false;
var result = base.VisitProjection(proj);
this.canJoinOnClient = saveJoin;
return(result);
}
}
else
{
this.isTopLevel = false;
}
return(base.VisitProjection(proj));
}
finally
{
this.currentSelect = save;
}
}
public static ProjectedColumns ProjectColumns(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
ColumnProjector projector = new ColumnProjector(language, expression, existingColumns, newAlias, existingAliases);
Expression expr = projector.Visit(expression);
return(new ProjectedColumns(expr, projector.columns.AsReadOnly()));
}
public static SelectExpression AddRedundantSelect(this SelectExpression sel, QueryLanguage language, TableAlias newAlias)
{
var newColumns =
from d in sel.Columns
let qt = (d.Expression is ColumnExpression) ? ((ColumnExpression)d.Expression).QueryType : language.TypeSystem.GetColumnType(d.Expression.Type)
select new ColumnDeclaration(d.Name, d.Alias, new ColumnExpression(d.Expression.Type, qt, newAlias, d.Name, new ColumnAlias(d.Alias)), qt);
var newFrom = new SelectExpression(newAlias, sel.Columns, sel.From, sel.Where, sel.OrderBy, sel.GroupBy, sel.IsDistinct, sel.Skip, sel.Take, sel.IsReverse);
return(new SelectExpression(sel.Alias, newColumns, newFrom, null, null, null, false, null, null, false));
}
public static Expression Map(Expression expression, TableAlias newAlias, params TableAlias[] oldAliases)
{
return(Map(expression, newAlias, (IEnumerable <TableAlias>)oldAliases));
}
public static Expression Map(Expression expression, TableAlias newAlias, IEnumerable <TableAlias> oldAliases)
{
return(new ColumnMapper(oldAliases, newAlias).Visit(expression));
}
/// <summary>
/// Rebind order expressions to reference a new alias and add to column declarations if necessary
/// </summary>
protected virtual BindResult RebindOrderings(IEnumerable <OrderExpression> orderings, TableAlias alias, HashSet <TableAlias> existingAliases, IEnumerable <ColumnDeclaration> existingColumns)
{
List <ColumnDeclaration> newColumns = null;
List <OrderExpression> newOrderings = new List <OrderExpression>();
foreach (OrderExpression ordering in orderings)
{
Expression expr = ordering.Expression;
ColumnExpression column = expr as ColumnExpression;
if (column == null || (existingAliases != null && existingAliases.Contains(column.TableAlias)))
{
// check to see if a declared column already contains a similar expression
int iOrdinal = 0;
foreach (ColumnDeclaration decl in existingColumns)
{
ColumnExpression declColumn = decl.Expression as ColumnExpression;
if (decl.Expression == ordering.Expression ||
(column != null && declColumn != null && column.TableAlias == declColumn.TableAlias && column.Name == declColumn.Name))
{
// found it, so make a reference to this column
expr = new ColumnExpression(column.Type, column.QueryType, alias, decl.Name, null);
break;
}
iOrdinal++;
}
// if not already projected, add a new column declaration for it
if (expr == ordering.Expression)
{
if (newColumns == null)
{
newColumns = new List <ColumnDeclaration>(existingColumns);
existingColumns = newColumns;
}
string colName = column != null ? column.Name : "c" + iOrdinal;
colName = newColumns.GetAvailableColumnName(colName);
var colType = this.language.TypeSystem.GetColumnType(expr.Type);
newColumns.Add(new ColumnDeclaration(colName, null, ordering.Expression, colType));
expr = new ColumnExpression(expr.Type, colType, alias, colName, null);
}
newOrderings.Add(new OrderExpression(ordering.OrderType, expr));
}
}
return(new BindResult(existingColumns, newOrderings));
}
public static ProjectedColumns ProjectColumns(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, params TableAlias[] existingAliases)
{
return(ProjectColumns(language, expression, existingColumns, newAlias, (IEnumerable <TableAlias>)existingAliases));
}
public override ProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count <= 1)
{
return(base.GetQueryExpression(entity));
}
var aliases = new Dictionary <string, TableAlias>();
MappingTable rootTable = tables.Single(ta => !this.mapping.IsExtensionTable(ta));
var tex = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(rootTable));
aliases.Add(this.mapping.GetAlias(rootTable), tex.Alias);
Expression source = tex;
foreach (MappingTable table in tables.Where(t => this.mapping.IsExtensionTable(t)))
{
TableAlias joinedTableAlias = new TableAlias();
string extensionAlias = this.mapping.GetAlias(table);
aliases.Add(extensionAlias, joinedTableAlias);
List <string> keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToList();
List <MemberInfo> relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToList();
string relatedAlias = this.mapping.GetExtensionRelatedAlias(table);
TableAlias relatedTableAlias;
aliases.TryGetValue(relatedAlias, out relatedTableAlias);
TableExpression joinedTex = new TableExpression(joinedTableAlias, entity, this.mapping.GetTableName(table));
Expression cond = null;
for (int i = 0, n = keyColumns.Count; i < n; i++)
{
var memberType = TypeHelper.GetMemberType(relatedMembers[i]);
var colType = this.GetColumnType(entity, relatedMembers[i]);
var relatedColumn = new ColumnExpression(memberType, colType, relatedTableAlias, this.mapping.GetColumnName(entity, relatedMembers[i]), new ColumnAlias(""));
var joinedColumn = new ColumnExpression(memberType, colType, joinedTableAlias, keyColumns[i], new ColumnAlias(""));
var eq = joinedColumn.Equal(relatedColumn);
cond = (cond != null) ? cond.And(eq) : eq;
}
source = new JoinExpression(JoinType.SingletonLeftOuter, source, joinedTex, cond);
}
var columns = new List <ColumnDeclaration>();
this.GetColumns(entity, aliases, columns);
SelectExpression root = new SelectExpression(new TableAlias(), columns, source, null);
var existingAliases = aliases.Values.ToArray();
Expression projector = this.GetEntityExpression(root, entity);
var selectAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.Translator.Linguist.Language, projector, null, selectAlias, root.Alias);
var proj = new ProjectionExpression(
new SelectExpression(selectAlias, pc.Columns, root, null),
pc.Projector
);
return((ProjectionExpression)this.Translator.Police.ApplyPolicy(proj, entity.ElementType));
}
protected virtual Expression GetInsertResult(MappingEntity entity, Expression instance, LambdaExpression selector, Dictionary <MemberInfo, Expression> map)
{
var tableAlias = new TableAlias();
var tex = new TableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var aggregator = Aggregator.GetAggregator(selector.Body.Type, typeof(IEnumerable <>).MakeGenericType(selector.Body.Type));
Expression where;
DeclarationCommand genIdCommand = null;
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;
}
// is this just a retrieval of one generated id member?
var mex = selector.Body as MemberExpression;
if (mex != null && this.mapping.IsPrimaryKey(entity, mex.Member) && this.mapping.IsGenerated(entity, mex.Member))
{
if (genIdCommand != null)
{
// just use the select from the genIdCommand
return(new ProjectionExpression(
genIdCommand.Source,
new ColumnExpression(mex.Type, genIdCommand.Variables[0].QueryType, genIdCommand.Source.Alias, genIdCommand.Source.Columns[0].Name, null),
aggregator
));
}
else
{
TableAlias alias = new TableAlias();
var colType = this.GetColumnType(entity, mex.Member);
return(new ProjectionExpression(
new SelectExpression(alias, new[] { new ColumnDeclaration("", null, map[mex.Member], colType) }, null, null),
new ColumnExpression(TypeHelper.GetMemberType(mex.Member), colType, alias, "", null),
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);
}
Expression typeProjector = this.GetEntityExpression(tex, entity);
Expression selection = DbExpressionReplacer.Replace(selector.Body, selector.Parameters[0], typeProjector);
TableAlias newAlias = new TableAlias();
var pc = ColumnProjector.ProjectColumns(this.translator.Linguist.Language, selection, null, newAlias, tableAlias);
var pe = new ProjectionExpression(
new SelectExpression(newAlias, pc.Columns, tex, where),
pc.Projector,
aggregator
);
if (genIdCommand != null)
{
return(new BlockCommand(genIdCommand, pe));
}
return(pe);
}
private ColumnMapper(IEnumerable <TableAlias> oldAliases, TableAlias newAlias)
{
this.oldAliases = new HashSet <TableAlias>(oldAliases);
this.newAlias = newAlias;
}
private void ClearColumnsUsed(TableAlias alias)
{
this.allColumnsUsed[alias] = new HashSet <string>();
}