private Expression MakeSubquery(Expression expression)
{
TableAlias alias = new TableAlias();
HashSet <TableAlias> set = DeclaredAliasGatherer.Gather(expression);
List <ColumnDeclaration> columns = new List <ColumnDeclaration>();
foreach (TableAlias alias2 in set)
{
foreach (ColumnExpression expression2 in this.columns[alias2])
{
ColumnDeclaration item = new ColumnDeclaration(columns.GetAvailableColumnName(expression2.Name), expression2, expression2.QueryType);
columns.Add(item);
ColumnExpression expression3 = new ColumnExpression(expression2.Type, expression2.QueryType, alias, expression2.Name);
this.map.Add(expression2, expression3);
}
}
return(new SelectExpression(alias, columns, expression, null));
}
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>(from c in existingColumns select c.Name);
}
else
{
this.columns = new List <ColumnDeclaration>();
this.columnNames = new HashSet <string>();
}
this.candidates = Nominator.Nominate(language, expression);
}
private bool GetEquiJoinKeyExpressions(Expression predicate, TableAlias outerAlias, List <Expression> outerExpressions, List <Expression> innerExpressions)
{
if (predicate.NodeType == ExpressionType.Equal)
{
BinaryExpression expression = (BinaryExpression)predicate;
ColumnExpression columnExpression = this.GetColumnExpression(expression.Left);
ColumnExpression expression3 = this.GetColumnExpression(expression.Right);
if ((columnExpression != null) && (expression3 != null))
{
if (columnExpression.Alias == outerAlias)
{
outerExpressions.Add(expression.Left);
innerExpressions.Add(expression.Right);
return(true);
}
if (expression3.Alias == outerAlias)
{
innerExpressions.Add(expression.Left);
outerExpressions.Add(expression.Right);
return(true);
}
}
}
bool flag = false;
Expression[] expressionArray = predicate.Split(new ExpressionType[] { ExpressionType.And, ExpressionType.AndAlso });
if (expressionArray.Length > 1)
{
foreach (Expression expression4 in expressionArray)
{
if (ReferencedAliasGatherer.Gather(expression4).Contains(outerAlias))
{
if (!this.GetEquiJoinKeyExpressions(expression4, outerAlias, outerExpressions, innerExpressions))
{
return(false);
}
flag = true;
}
}
}
return(flag);
}
protected virtual DeclarationCommand GetGeneratedIdCommand(MappingEntity entity, List <MemberInfo> members, Dictionary <MemberInfo, Expression> map)
{
List <ColumnDeclaration> columns = new List <ColumnDeclaration>();
List <VariableDeclaration> variables = new List <VariableDeclaration>();
TableAlias alias = new TableAlias();
foreach (MemberInfo info in members)
{
Expression generatedIdExpression = this.translator.Linguist.Language.GetGeneratedIdExpression(info);
string name = info.Name;
QueryType columnType = this.GetColumnType(entity, info);
columns.Add(new ColumnDeclaration(info.Name, generatedIdExpression, columnType));
variables.Add(new VariableDeclaration(info.Name, columnType, new ColumnExpression(generatedIdExpression.Type, columnType, alias, info.Name)));
if (map != null)
{
VariableExpression expression2 = new VariableExpression(info.Name, King.Framework.Linq.TypeHelper.GetMemberType(info), columnType);
map.Add(info, expression2);
}
}
return(new DeclarationCommand(variables, new SelectExpression(alias, columns, null, null)));
}
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 SelectExpression(TableAlias alias, IEnumerable <ColumnDeclaration> columns, Expression from, Expression where, IEnumerable <OrderExpression> orderBy, IEnumerable <Expression> groupBy) : this(alias, columns, from, where, orderBy, groupBy, false, null, null, false)
{
}
public static SelectExpression AddRedundantSelect(this SelectExpression sel, QueryLanguage language, TableAlias newAlias)
{
IEnumerable <ColumnDeclaration> columns = from d in sel.Columns
let qt = (d.Expression is ColumnExpression) ? ((IEnumerable <ColumnDeclaration>)((ColumnExpression)d.Expression).QueryType) : ((IEnumerable <ColumnDeclaration>)language.TypeSystem.GetColumnType(d.Expression.Type))
select new ColumnDeclaration(d.Name, new ColumnExpression(d.Expression.Type, qt as QueryType, newAlias, d.Name), qt as QueryType);
return(new SelectExpression(sel.Alias, columns, new SelectExpression(newAlias, sel.Columns, sel.From, sel.Where, sel.OrderBy, sel.GroupBy, sel.IsDistinct, sel.Skip, sel.Take, sel.IsReverse), null, null, null, false, null, null, false));
}
public SelectExpression(TableAlias alias, IEnumerable <ColumnDeclaration> columns, Expression from, Expression where) : this(alias, columns, from, where, null, null)
{
}
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);
return(new ProjectedColumns(projector.Visit(expression), projector.columns.AsReadOnly()));
}
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 AggregateSubqueryExpression(TableAlias groupByAlias, Expression aggregateInGroupSelect, ScalarExpression aggregateAsSubquery) : base(DbExpressionType.AggregateSubquery, aggregateAsSubquery.Type)
{
this.aggregateInGroupSelect = aggregateInGroupSelect;
this.groupByAlias = groupByAlias;
this.aggregateAsSubquery = aggregateAsSubquery;
}
public TableExpression(TableAlias alias, MappingEntity entity, string name) : base(DbExpressionType.Table, typeof(void), alias)
{
this.entity = entity;
this.name = name;
}
internal Scope(ExecutionBuilder.Scope outer, ParameterExpression fieldReader, TableAlias alias, IEnumerable <ColumnDeclaration> columns)
{
this.outer = outer;
this.fieldReader = fieldReader;
this.Alias = alias;
//this.nameMap = columns.Select(((Func<ColumnDeclaration, int, <>f__AnonymousType0<ColumnDeclaration, int>>) ((c, i) => new { c = c, i = i }))).ToDictionary(x => x.c.Name, x => x.i);
}
protected AliasedExpression(DbExpressionType nodeType, Type type, TableAlias alias) : base(nodeType, type)
{
this.alias = alias;
}
protected virtual BindResult RebindOrderings(IEnumerable <OrderExpression> orderings, TableAlias alias, HashSet <TableAlias> existingAliases, IEnumerable <ColumnDeclaration> existingColumns)
{
List <ColumnDeclaration> columns = null;
List <OrderExpression> list2 = new List <OrderExpression>();
foreach (OrderExpression expression in orderings)
{
Expression expression2 = expression.Expression;
ColumnExpression expression3 = expression2 as ColumnExpression;
if ((expression3 == null) || ((existingAliases != null) && existingAliases.Contains(expression3.Alias)))
{
int num = 0;
foreach (ColumnDeclaration declaration in existingColumns)
{
ColumnExpression expression4 = declaration.Expression as ColumnExpression;
if ((declaration.Expression == expression.Expression) || ((((expression3 != null) && (expression4 != null)) && (expression3.Alias == expression4.Alias)) && (expression3.Name == expression4.Name)))
{
expression2 = new ColumnExpression(expression3.Type, expression3.QueryType, alias, declaration.Name);
break;
}
num++;
}
if (expression2 == expression.Expression)
{
if (columns == null)
{
columns = new List <ColumnDeclaration>(existingColumns);
existingColumns = columns;
}
string baseName = (expression3 != null) ? expression3.Name : ("c" + num);
baseName = columns.GetAvailableColumnName(baseName);
QueryType columnType = this.language.TypeSystem.GetColumnType(expression2.Type);
columns.Add(new ColumnDeclaration(baseName, expression.Expression, columnType));
expression2 = new ColumnExpression(expression2.Type, columnType, alias, baseName);
}
list2.Add(new OrderExpression(expression.OrderType, expression2));
}
}
return(new BindResult(existingColumns, list2));
}
public ColumnExpression(Type type, King.Framework.Linq.Data.Common.QueryType queryType, TableAlias alias, string name) : base(DbExpressionType.Column, type)
{
if (queryType == null)
{
throw new ArgumentNullException("queryType");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
this.alias = alias;
this.name = name;
this.queryType = queryType;
}
private bool IsColumnUsed(TableAlias alias, string name)
{
HashSet <string> set;
return((this.allColumnsUsed.TryGetValue(alias, out set) && (set != null)) && set.Contains(name));
}
private void ClearColumnsUsed(TableAlias alias)
{
this.allColumnsUsed[alias] = new HashSet <string>();
}
private ColumnMapper(IEnumerable <TableAlias> oldAliases, TableAlias newAlias)
{
this.oldAliases = new HashSet <TableAlias>(oldAliases);
this.newAlias = newAlias;
}
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));
}
