public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
{
var commands = new List <Expression>();
var tables = this.mapping.GetTables(entity);
if (tables.Count < 2)
{
return(base.GetDeleteExpression(entity, instance, deleteCheck));
}
foreach (var table in this.GetDependencyOrderedTables(entity).Reverse())
{
var tex = new DbTableExpression(new TableAlias(), entity, this.mapping.GetTableName(table));
var where = this.GetIdentityCheck(tex, entity, instance);
commands.Add(new DbDeleteCommand(tex, where));
}
var block = new DbBlockCommand(commands) as Expression;
if (deleteCheck != null)
{
return(new DbIFCommand(this.GetEntityStateTest(entity, instance, deleteCheck), block, null));
}
return(block);
}
protected override Expression VisitTable(DbTableExpression table)
{
var newAlias = new TableAlias();
this.map[table.Alias] = newAlias;
return(new DbTableExpression(newAlias, table.Entity, table.Name));
}
protected DbInsertCommand UpdateInsert(DbInsertCommand insert, DbTableExpression table, IEnumerable <DbColumnAssignment> assignments)
{
if (table != insert.Table || assignments != insert.Assignments)
{
return(new DbInsertCommand(table, assignments));
}
return(insert);
}
protected DbDeleteCommand UpdateDelete(DbDeleteCommand delete, DbTableExpression table, Expression where)
{
if (table != delete.Table || where != delete.Where)
{
return(new DbDeleteCommand(table, where));
}
return(delete);
}
protected DbUpdateCommand UpdateUpdate(DbUpdateCommand update, DbTableExpression table, Expression where, IEnumerable <DbColumnAssignment> assignments)
{
if (table != update.Table || where != update.Where || assignments != update.Assignments)
{
return(new DbUpdateCommand(table, where, assignments));
}
return(update);
}
private DbCommandExpression GetDependentGeneratedVariableDeclaration(MappingEntity entity, MappingTable table, List <MemberInfo> members, Expression instance, Dictionary <MemberInfo, Expression> map)
{
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)
{
genIdCommand = this.GetGeneratedIdCommand(entity, members, map);
if (members.Count == generatedIds.Count)
{
return(genIdCommand);
}
}
members = members.Except(generatedIds).ToList();
var tableAlias = new TableAlias();
var tex = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(table));
var where = null as Expression;
if (generatedIds.Count > 0)
{
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 selectAlias = new TableAlias();
var columns = new List <DbColumnDeclaration>();
var variables = new List <DbVariableDeclaration>();
foreach (var mi in members)
{
var col = (DbColumnExpression)this.GetMemberExpression(tex, entity, mi);
columns.Add(new DbColumnDeclaration(this.mapping.GetColumnName(entity, mi), col, col.QueryType));
var vcol = new DbColumnExpression(col.Type, col.QueryType, selectAlias, col.Name);
variables.Add(new DbVariableDeclaration(mi.Name, col.QueryType, vcol));
map.Add(mi, new DbVariableExpression(mi.Name, col.Type, col.QueryType));
}
var genMembersCommand = new DbDeclarationCommand(variables, new DbSelectExpression(selectAlias, columns, tex, where));
if (genIdCommand != null)
{
return(new DbBlockCommand(genIdCommand, genMembersCommand));
}
return(genMembersCommand);
}
public override Expression GetUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression exp)
{
var tableAlias = new TableAlias();
var table = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var where = this.GetIdentityCheck(table, entity, instance);
if (updateCheck != null)
{
var typeProjector = this.GetEntityExpression(table, entity);
var pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector);
if (pred != null)
{
where = where.And(pred);
}
}
var assignments = this.GetColumnAssignments(table, instance, entity, (e, m) => this.mapping.IsUpdatable(e, m));
var update = new DbUpdateCommand(table, where, assignments);
if (selector != null)
{
return(new DbBlockCommand
(
update,
new DbIFCommand
(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).GreaterThan(Expression.Constant(0)),
this.GetUpdateResult(entity, instance, selector),
exp
)
));
}
else if (exp != null)
{
return(new DbBlockCommand
(
update,
new DbIFCommand
(
this.translator.Linguist.Language.GetRowsAffectedExpression(update).LessThanOrEqual(Expression.Constant(0)),
exp,
null
)
));
}
else
{
return(update);
}
}
internal override DbProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tableAlias = new TableAlias();
var selectAlias = new TableAlias();
var table = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var projector = this.GetEntityExpression(table, entity) as Expression;
var pc = DbColumnProjector.ProjectColumns(this.translator.Linguist.Language, projector, null, selectAlias, tableAlias);
var proj = new DbProjectionExpression(new DbSelectExpression(selectAlias, pc.Columns, table, null), pc.Projector);
return(this.Translator.Police.ApplyPolicy(proj, entity.ElementType.GetTypeInfo()) as DbProjectionExpression);
}
public override Expression GetUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression exp)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count < 2)
{
return(base.GetUpdateExpression(entity, instance, updateCheck, selector, exp));
}
var commands = new List <Expression>();
foreach (var table in this.GetDependencyOrderedTables(entity))
{
var tex = new DbTableExpression(new 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.IsUpdatable(e, m), null);
var where = this.GetIdentityCheck(tex, entity, instance);
commands.Add(new DbUpdateCommand(tex, where, assignments));
}
if (selector != null)
{
commands.Add(new DbIFCommand
(
this.Translator.Linguist.Language.GetRowsAffectedExpression(commands[commands.Count - 1]).GreaterThan(Expression.Constant(0)),
this.GetUpdateResult(entity, instance, selector), exp)
);
}
else if (exp != null)
{
commands.Add(new DbIFCommand
(
this.Translator.Linguist.Language.GetRowsAffectedExpression(commands[commands.Count - 1]).LessThanOrEqual(Expression.Constant(0)),
exp,
null
));
}
var block = new DbBlockCommand(commands) as Expression;
if (updateCheck != null)
{
return(new DbIFCommand(this.GetEntityStateTest(entity, instance, updateCheck), block, null));
}
return(block);
}
public override Expression GetInsertExpression(MappingEntity entity, Expression instance, LambdaExpression selector)
{
var tableAlias = new TableAlias();
var table = new DbTableExpression(tableAlias, entity, this.mapping.GetTableName(entity));
var assignments = this.GetColumnAssignments(table, instance, entity, (e, m) => !(mapping.IsGenerated(e, m) || mapping.IsReadOnly(e, m)));
if (selector != null)
{
return(new DbBlockCommand
(
new DbInsertCommand(table, assignments),
this.GetInsertResult(entity, instance, selector, null)
));
}
return(new DbInsertCommand(table, assignments));
}
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 DbTableExpression(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 DbInsertCommand(tex, totalAssignments));
if (map.TryGetValue(this.mapping.GetAlias(table), out List <MemberInfo> 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 DbBlockCommand(commands));
}
private Expression GetIdentityCheck(DbTableExpression root, MappingEntity entity, Expression instance, MappingTable table)
{
if (this.mapping.IsExtensionTable(table))
{
var keyColNames = this.mapping.GetExtensionKeyColumnNames(table).ToArray();
var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToArray();
var where = null as Expression;
for (int i = 0, n = keyColNames.Length; i < n; i++)
{
var relatedMember = relatedMembers[i];
var cex = new DbColumnExpression(TypeHelper.GetMemberType(relatedMember), this.GetColumnType(entity, relatedMember), root.Alias, keyColNames[n]);
var nex = this.GetMemberExpression(instance, entity, relatedMember);
var eq = cex.Equal(nex);
where = (where != null) ? where.And(eq) : where;
}
return(where);
}
return(base.GetIdentityCheck(root, entity, instance));
}
public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck)
{
var table = new DbTableExpression(new TableAlias(), entity, this.mapping.GetTableName(entity));
var where = null as Expression;
if (instance != null)
{
where = this.GetIdentityCheck(table, entity, instance);
}
if (deleteCheck != null)
{
var row = this.GetEntityExpression(table, entity);
var pred = DbExpressionReplacer.Replace(deleteCheck.Body, deleteCheck.Parameters[0], row);
if (pred != null)
{
where = (where != null) ? where.And(pred) : pred;
}
}
return(new DbDeleteCommand(table, where));
}
internal override DbProjectionExpression GetQueryExpression(MappingEntity entity)
{
var tables = this.mapping.GetTables(entity);
if (tables.Count <= 1)
{
return(base.GetQueryExpression(entity));
}
var aliases = new Dictionary <string, TableAlias>();
var rootTable = tables.Single(ta => !this.mapping.IsExtensionTable(ta));
var tex = new DbTableExpression(new TableAlias(), entity, this.mapping.GetTableName(rootTable));
aliases.Add(this.mapping.GetAlias(rootTable), tex.Alias);
var source = tex as Expression;
foreach (var table in tables.Where(t => this.mapping.IsExtensionTable(t)))
{
var joinedTableAlias = new TableAlias();
var extensionAlias = this.mapping.GetAlias(table);
aliases.Add(extensionAlias, joinedTableAlias);
var keyColumns = this.mapping.GetExtensionKeyColumnNames(table).ToList();
var relatedMembers = this.mapping.GetExtensionRelatedMembers(table).ToList();
var relatedAlias = this.mapping.GetExtensionRelatedAlias(table);
aliases.TryGetValue(relatedAlias, out TableAlias relatedTableAlias);
var joinedTex = new DbTableExpression(joinedTableAlias, entity, this.mapping.GetTableName(table));
var cond = null as Expression;
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 DbColumnExpression(memberType, colType, relatedTableAlias, this.mapping.GetColumnName(entity, relatedMembers[i]));
var joinedColumn = new DbColumnExpression(memberType, colType, joinedTableAlias, keyColumns[i]);
var eq = joinedColumn.Equal(relatedColumn);
cond = (cond != null) ? cond.And(eq) : eq;
}
source = new DbJoinExpression(JoinType.SingletonLeftOuter, source, joinedTex, cond);
}
var columns = new List <DbColumnDeclaration>();
this.GetColumns(entity, aliases, columns);
var root = new DbSelectExpression(new TableAlias(), columns, source, null);
var existingAliases = aliases.Values.ToArray();
var projector = this.GetEntityExpression(root, entity) as Expression;
var selectAlias = new TableAlias();
var pc = DbColumnProjector.ProjectColumns(this.Translator.Linguist.Language, projector, null, selectAlias, root.Alias);
var proj = new DbProjectionExpression
(
new DbSelectExpression(selectAlias, pc.Columns, root, null),
pc.Projector
);
return(this.Translator.Police.ApplyPolicy(proj, entity.ElementType.GetTypeInfo()) as DbProjectionExpression);
}
protected virtual bool CompareTable(DbTableExpression a, DbTableExpression b)
{
return(a.Name == b.Name);
}
protected virtual Expression VisitTable(DbTableExpression table)
{
return(table);
}
public DbUpdateCommand(DbTableExpression table, Expression where, IEnumerable <DbColumnAssignment> assignments) : base(DbExpressionType.Update, typeof(int))
{
this.Table = table;
this.Where = where;
this.Assignments = assignments.ToReadOnly();
}
public DbDeleteCommand(DbTableExpression table, Expression where) : base(DbExpressionType.Delete, typeof(int))
{
this.Table = table;
this.Where = where;
}
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);
}
public DbInsertCommand(DbTableExpression table, IEnumerable <DbColumnAssignment> assignments) : base(DbExpressionType.Insert, typeof(int))
{
this.Table = table;
this.Assignments = assignments.ToReadOnly();
}
protected override Expression VisitTable(DbTableExpression table)
{
this.aliases.Add(table.Alias);
return(table);
}