public override ProjectionExpression GetQueryExpression(MappingEntity entity)
{
IList <MappingTable> tables = this.mapping.GetTables(entity);
if (tables.Count <= 1)
{
return(base.GetQueryExpression(entity));
}
Dictionary <string, TableAlias> aliases = new Dictionary <string, TableAlias>();
MappingTable table = tables.Single <MappingTable>(ta => !this.mapping.IsExtensionTable(ta));
TableExpression expression = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(table));
aliases.Add(this.mapping.GetAlias(table), expression.Alias);
Expression left = expression;
foreach (MappingTable table2 in from t in tables
where this.mapping.IsExtensionTable(t)
select t)
{
TableAlias alias2;
TableAlias alias = new TableAlias();
string key = this.mapping.GetAlias(table2);
aliases.Add(key, alias);
List <string> list2 = this.mapping.GetExtensionKeyColumnNames(table2).ToList <string>();
List <MemberInfo> list3 = this.mapping.GetExtensionRelatedMembers(table2).ToList <MemberInfo>();
string extensionRelatedAlias = this.mapping.GetExtensionRelatedAlias(table2);
aliases.TryGetValue(extensionRelatedAlias, out alias2);
TableExpression right = new TableExpression(alias, entity, this.mapping.GetTableName(table2));
Expression expression4 = null;
int num = 0;
int count = list2.Count;
while (num < count)
{
Type memberType = King.Framework.Linq.TypeHelper.GetMemberType(list3[num]);
QueryType columnType = this.GetColumnType(entity, list3[num]);
ColumnExpression expression5 = new ColumnExpression(memberType, columnType, alias2, this.mapping.GetColumnName(entity, list3[num]));
Expression expression7 = new ColumnExpression(memberType, columnType, alias, list2[num]).Equal(expression5);
expression4 = (expression4 != null) ? expression4.And(expression7) : expression7;
num++;
}
left = new JoinExpression(JoinType.SingletonLeftOuter, left, right, expression4);
}
List <ColumnDeclaration> list4 = new List <ColumnDeclaration>();
this.GetColumns(entity, aliases, list4);
SelectExpression root = new SelectExpression(new TableAlias(), list4, left, null);
Expression entityExpression = this.GetEntityExpression(root, entity);
TableAlias newAlias = new TableAlias();
ProjectedColumns columns = ColumnProjector.ProjectColumns(this.Translator.Linguist.Language, entityExpression, null, newAlias, new TableAlias[] { root.Alias });
ProjectionExpression expression10 = new ProjectionExpression(new SelectExpression(newAlias, columns.Columns, root, null), columns.Projector);
return((ProjectionExpression)this.Translator.Police.ApplyPolicy(expression10, entity.ElementType));
}
public override Expression GetUpdateExpression(MappingEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector, Expression @else)
{
if (this.mapping.GetTables(entity).Count < 2)
{
return(base.GetUpdateExpression(entity, instance, updateCheck, selector, @else));
}
List <Expression> commands = new List <Expression>();
using (IEnumerator <MappingTable> enumerator = this.GetDependencyOrderedTables(entity).GetEnumerator())
{
while (enumerator.MoveNext())
{
Func <MappingEntity, MemberInfo, bool> fnIncludeColumn = null;
MappingTable table = enumerator.Current;
TableExpression expression = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(table));
if (fnIncludeColumn == null)
{
fnIncludeColumn = (e, m) => (this.mapping.GetAlias(e, m) == this.mapping.GetAlias(table)) && this.mapping.IsUpdatable(e, m);
}
IEnumerable <ColumnAssignment> assignments = this.GetColumnAssignments(expression, instance, entity, fnIncludeColumn, null);
Expression where = this.GetIdentityCheck(expression, entity, instance);
commands.Add(new UpdateCommand(expression, where, assignments));
}
}
if (selector != null)
{
commands.Add(new IFCommand(this.Translator.Linguist.Language.GetRowsAffectedExpression(commands[commands.Count - 1]).GreaterThan(Expression.Constant(0)), this.GetUpdateResult(entity, instance, selector), @else));
}
else if (@else != null)
{
commands.Add(new IFCommand(this.Translator.Linguist.Language.GetRowsAffectedExpression(commands[commands.Count - 1]).LessThanOrEqual(Expression.Constant(0)), @else, null));
}
Expression ifTrue = new BlockCommand(commands);
if (updateCheck != null)
{
return(new IFCommand(this.GetEntityStateTest(entity, instance, updateCheck), ifTrue, null));
}
return(ifTrue);
}
public override Expression GetInsertExpression(MappingEntity entity, Expression instance, LambdaExpression selector)
{
if (this.mapping.GetTables(entity).Count < 2)
{
return(base.GetInsertExpression(entity, instance, selector));
}
List <Expression> commands = new List <Expression>();
Dictionary <string, List <MemberInfo> > dependentGeneratedColumns = this.GetDependentGeneratedColumns(entity);
Dictionary <MemberInfo, Expression> map = new Dictionary <MemberInfo, Expression>();
using (IEnumerator <MappingTable> enumerator = this.GetDependencyOrderedTables(entity).GetEnumerator())
{
while (enumerator.MoveNext())
{
List <MemberInfo> list3;
Func <MappingEntity, MemberInfo, bool> fnIncludeColumn = null;
MappingTable table = enumerator.Current;
TableAlias alias = new TableAlias();
TableExpression expression = new TableExpression(alias, entity, this.mapping.GetTableName(table));
if (fnIncludeColumn == null)
{
fnIncludeColumn = (e, m) => (this.mapping.GetAlias(e, m) == this.mapping.GetAlias(table)) && !this.mapping.IsGenerated(e, m);
}
IEnumerable <ColumnAssignment> assignments = this.GetColumnAssignments(expression, instance, entity, fnIncludeColumn, map).Concat <ColumnAssignment>(this.GetRelatedColumnAssignments(expression, entity, table, map));
commands.Add(new InsertCommand(expression, assignments));
if (dependentGeneratedColumns.TryGetValue(this.mapping.GetAlias(table), out list3))
{
CommandExpression item = this.GetDependentGeneratedVariableDeclaration(entity, table, list3, instance, map);
commands.Add(item);
}
}
}
if (selector != null)
{
commands.Add(this.GetInsertResult(entity, instance, selector, map));
}
return(new BlockCommand(commands));
}
public abstract bool IsExtensionTable(MappingTable table);
public abstract string GetTableName(MappingTable table);
public abstract IEnumerable <MemberInfo> GetExtensionRelatedMembers(MappingTable table);
public abstract string GetExtensionRelatedAlias(MappingTable table);
public abstract IEnumerable <string> GetExtensionKeyColumnNames(MappingTable table);
public abstract string GetAlias(MappingTable table);
private IEnumerable <ColumnAssignment> GetRelatedColumnAssignments(Expression expr, MappingEntity entity, MappingTable table, Dictionary <MemberInfo, Expression> map)
{
if (this.mapping.IsExtensionTable(table))
{
string[] iteratorVariable0 = this.mapping.GetExtensionKeyColumnNames(table).ToArray <string>();
MemberInfo[] iteratorVariable1 = this.mapping.GetExtensionRelatedMembers(table).ToArray <MemberInfo>();
int index = 0;
int length = iteratorVariable0.Length;
while (index < length)
{
MemberInfo member = iteratorVariable1[index];
Expression expression = map[member];
yield return(new ColumnAssignment((ColumnExpression)this.GetMemberExpression(expr, entity, member), expression));
index++;
}
}
}
private Expression GetIdentityCheck(TableExpression root, MappingEntity entity, Expression instance, MappingTable table)
{
if (this.mapping.IsExtensionTable(table))
{
string[] strArray = this.mapping.GetExtensionKeyColumnNames(table).ToArray <string>();
MemberInfo[] infoArray = this.mapping.GetExtensionRelatedMembers(table).ToArray <MemberInfo>();
Expression expression = null;
int index = 0;
int length = strArray.Length;
while (index < length)
{
MemberInfo mi = infoArray[index];
ColumnExpression expression2 = new ColumnExpression(King.Framework.Linq.TypeHelper.GetMemberType(mi), this.GetColumnType(entity, mi), root.Alias, strArray[length]);
Expression expression3 = this.GetMemberExpression(instance, entity, mi);
Expression expression4 = expression2.Equal(expression3);
expression = (expression != null) ? expression.And(expression4) : expression;
index++;
}
return(expression);
}
return(base.GetIdentityCheck(root, entity, instance));
}
private CommandExpression GetDependentGeneratedVariableDeclaration(MappingEntity entity, MappingTable table, List <MemberInfo> members, Expression instance, Dictionary <MemberInfo, Expression> map)
{
Func <MemberInfo, int, Expression> selector = null;
DeclarationCommand command = null;
List <MemberInfo> second = (from m in this.mapping.GetMappedMembers(entity)
where this.mapping.IsPrimaryKey(entity, m) && this.mapping.IsGenerated(entity, m)
select m).ToList <MemberInfo>();
if (second.Count > 0)
{
command = this.GetGeneratedIdCommand(entity, members, map);
if (members.Count == second.Count)
{
return(command);
}
}
members = members.Except <MemberInfo>(second).ToList <MemberInfo>();
TableAlias alias = new TableAlias();
TableExpression tex = new TableExpression(alias, entity, this.mapping.GetTableName(table));
Expression where = null;
if (second.Count > 0)
{
if (selector == null)
{
selector = (m, i) => this.GetMemberExpression(tex, entity, m).Equal(map[m]);
}
where = second.Select <MemberInfo, Expression>(selector).Aggregate <Expression>((x, y) => x.And(y));
}
else
{
where = this.GetIdentityCheck(tex, entity, instance);
}
TableAlias alias2 = new TableAlias();
List <ColumnDeclaration> columns = new List <ColumnDeclaration>();
List <VariableDeclaration> variables = new List <VariableDeclaration>();
foreach (MemberInfo info in members)
{
ColumnExpression expression = (ColumnExpression)this.GetMemberExpression(tex, entity, info);
columns.Add(new ColumnDeclaration(this.mapping.GetColumnName(entity, info), expression, expression.QueryType));
ColumnExpression expression3 = new ColumnExpression(expression.Type, expression.QueryType, alias2, expression.Name);
variables.Add(new VariableDeclaration(info.Name, expression.QueryType, expression3));
map.Add(info, new VariableExpression(info.Name, expression.Type, expression.QueryType));
}
DeclarationCommand command2 = new DeclarationCommand(variables, new SelectExpression(alias2, columns, tex, where));
if (command != null)
{
return(new BlockCommand(new Expression[] { command, command2 }));
}
return(command2);
}
