public JoinedTableExpression Replace(TableAlias aliasToFind, IAliasedExpression expressionReplacement)
{
JoinedTableExpression result;
if (LeftTable.Alias == aliasToFind)
{
LeftTable = expressionReplacement;
return (JoinedTableExpression)new Visitors.LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { aliasToFind, expressionReplacement.Alias } }).Visit(this);
}
if (RightTable.Alias == aliasToFind)
{
RightTable = expressionReplacement;
return (JoinedTableExpression)new Visitors.LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { aliasToFind, expressionReplacement.Alias } }).Visit(this);
}
if (LeftTable is JoinedTableExpression && (result = ((JoinedTableExpression)LeftTable).Replace(aliasToFind, expressionReplacement)) != null)
{
LeftTable = result;
//LeftTable = (JoinedTableExpression)new Visitors.LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { aliasToFind, expressionReplacement.Alias } }).Visit(this);
return this;
}
if (RightTable is JoinedTableExpression && (result = ((JoinedTableExpression)RightTable).Replace(aliasToFind, expressionReplacement)) != null)
{
RightTable = result;
//RightTable = new Visitors.LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { aliasToFind, expressionReplacement.Alias } }).Visit(this);
return this;
}
return null;
}
public JoinedTableExpression(IAliasedExpression left, IAliasedExpression right, JoinType joinType, TableAlias alias)
: base(alias)
{
LeftTable = left;
RightTable = right;
JoinType = joinType;
}
public CaseExpression(TableAlias alias, IDbExpression test, IDbExpression defaultResult, params CaseTestExpression[] caseTests)
: base(alias)
{
Test = test;
DefaultResult = defaultResult;
CaseTests = caseTests;
}
public JoinedTableExpression(IAliasedExpression left, IAliasedExpression right, JoinType joinType, TableAlias alias, Evaluant.NLinq.Expressions.BinaryExpression on)
: base(alias)
{
LeftTable = left;
RightTable = right;
JoinType = joinType;
On = on;
}
public SelectStatement(TableAlias alias, IEnumerable<IAliasedExpression> columns, FromClause from, OrderByClause orderby, WhereClause where)
: this(alias)
{
Columns = columns;
From = from;
OrderBy = orderby;
Where = where;
}
public override Identifier Visit(EntityIdentifier identifier)
{
if (visitingColumns)
{
currentAlias = identifier.Entity.Alias;
return identifier;
}
return base.Visit(identifier);
}
public ColumnExpression(TableAlias alias, string columnName, string columnAlias)
: base(alias)
{
if (columnName == AllColumns.Text)
ColumnName = AllColumns;
else
{
ColumnName = new Identifier(columnName);
if (!string.IsNullOrEmpty(columnAlias))
ColumnAlias = new Identifier(columnAlias);
}
}
public ColumnExpression(TableAlias alias) : base(alias) { }
public ColumnExpression(TableAlias alias, Identifier columnName)
: this(alias, columnName, null)
{
}
public override TableAlias Visit(TableAlias item)
{
if (item == null)
return null;
if (AliasesMapping.ContainsKey(item))
return AliasesMapping[item];
return item;
}
public override IDbExpression Visit(EntityExpression item)
{
if (item.Type != null)
currentEntity = mapping.Entities[item.Type];
currentEntityExpression = item;
currentAlias = item.Alias;
if (item.Expression is NLinq.Expressions.Identifier)
{
referencePath = new StringBuilder(((NLinq.Expressions.Identifier)item.Expression).Text);
if (loadedReferences.ContainsKey(referencePath.ToString()))
currentAlias = loadedReferences[referencePath.ToString()];
else
loadedReferences.Add(referencePath.ToString(), item.Alias);
}
if (!inFrom && item.Expression is Evaluant.NLinq.Expressions.MemberExpression)
{
NLinq.Expressions.Expression expression = Visit(item.Expression);
if (expression is IAliasedExpression)
currentAlias = ((IAliasedExpression)expression).Alias;
return updater.Update(item, expression, currentAlias, item.Type);
}
if (item.Expression != null && item.Expression.ExpressionType == NLinq.Expressions.ExpressionTypes.AnonymousParameter)
{
NLinq.Expressions.Expression expression = Visit(item.Expression);
return updater.Update(item, Visit(expression), currentAlias, item.Type);
}
return updater.Update(item, item.Expression, currentAlias, item.Type);
}
public virtual IAliasedExpression Update(ColumnExpression item, TableAlias alias, Evaluant.NLinq.Expressions.Identifier columnName)
{
if (item.ColumnName != columnName || item.Alias != alias)
return new ColumnExpression(alias, columnName);
return item;
}
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression item)
{
NLinq.Expressions.Expression target = Visit(item.Previous);
TableAlias entityAlias = currentAlias;
NLinq.Expressions.Expression statement = Visit(item.Statement);
if (statement.ExpressionType==NLinq.Expressions.ExpressionTypes.Identifier)
{
string propertyName = ((Evaluant.NLinq.Expressions.Identifier)statement).Text;
if (inFrom && currentEntity.References.ContainsKey(propertyName))
{
Mapping.Reference reference = currentEntity.References[propertyName];
TableAlias newTableAlias;
IAliasedExpression join = mapping.Mapper.Join(reference, out newTableAlias);
//registeredAliasedExpression.Add(join, newTableAlias);
lastAliasDefined = ((JoinedTableExpression)join).RightTable.Alias;
loadedReferences.Add(referencePath.ToString(), lastAliasDefined);
AliasesMapping.Add(newTableAlias, entityAlias);
return (NLinq.Expressions.Expression)join;
}
else
{
string targetReferencePath = referencePath.ToString().Substring(0, referencePath.Length - propertyName.Length);
//If this is not a reference leave the treatment to another visitor
if (currentEntity != null && currentEntity.References.ContainsKey(propertyName))
{
bool exists = currentFrom == null;
Mapping.Reference reference = currentEntity.References[propertyName];
if (!loadedReferences.ContainsKey(referencePath.ToString()))
{
currentEntity = reference.Target;
TableAlias newTableAlias;
//New target to reduce the already processed tree
target = (NLinq.Expressions.Expression)mapping.Mapper.Join(reference, out newTableAlias);
if (reference.IsComposite || loadedReferences.ContainsKey(targetReferencePath))
{
target = new LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { newTableAlias, currentAlias } }).Visit(target);
newTableAlias = currentAlias;
//AliasesMapping[loadedReferences[targetReferencePath]] = target.Alias;
}
//Add JoinedTableExpression to load reference in query
if (!exists)
target = ((JoinedTableExpression)target).Replace(newTableAlias, currentFrom[0]);
else
{
//Case of Exists in where clause
Evaluant.NLinq.Expressions.Expression constraint;
target = (NLinq.Expressions.Expression)((JoinedTableExpression)target).Replace(newTableAlias, loadedReferences[targetReferencePath], out constraint);
if (this.constraint == null)
this.constraint = constraint;
else
this.constraint = new NLinq.Expressions.BinaryExpression(NLinq.Expressions.BinaryExpressionType.And, this.constraint, constraint);
}
//if (target == null)
// throw new NotSupportedException("The alias specified could not be found");
if (loadedReferences.ContainsKey(targetReferencePath))
target = new LazyAliasResolver(new Dictionary<TableAlias, TableAlias>() { { loadedReferences[targetReferencePath], newTableAlias } }).Visit(target);
currentFrom = new FromClause((IAliasedExpression)target);
lastAliasDefined = ((JoinedTableExpression)target).RightTable.Alias;
loadedReferences.Add(referencePath.ToString(), lastAliasDefined);
}
else
{
if (!inFrom)
lastAliasDefined = loadedReferences[referencePath.ToString()];
}
if (exists)
{
var constraint = this.constraint;
this.constraint = null;
return constraint;
}
return new EntityExpression(lastAliasDefined) { Type = reference.Target.Type };
}
//else
//{
// if (!loadedReferences.ContainsKey(targetReferencePath))
// return updater.Update(item, target, statement);
// //return new ComplexColumnExpression(currentAlias, target is SelectStatement ? new EntityIdentifier(propertyName, currentEntityExpression) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
// return updater.Update(item, target, statement);
// //return new ComplexColumnExpression(currentAlias, target is SelectStatement ? new EntityIdentifier(propertyName, new EntityExpression(loadedReferences[targetReferencePath]) { Type = currentEntity.Type }) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
// //return updater.Update(item, target, target is SelectStatement ? new EntityIdentifier(propertyName, new EntityExpression(loadedReferences[targetReferencePath]) { Type = currentEntity.Type }) : new Evaluant.NLinq.Expressions.Identifier(propertyName));
//}
}
}
return updater.Update(item, target, statement);
}
public EntityReferenceExpression(TableAlias alias, IAliasedExpression target)
: base(alias)
{
this.Target = target;
}
public ColumnExpression(TableAlias alias, string columnName)
: this(alias, new Identifier(columnName), null)
{
}
internal IAliasedExpression Update(Union item, TableAlias alias, IAliasedExpression[] aliasedExpression)
{
if (item.SelectStatements != aliasedExpression || item.Alias != alias)
return new Union(alias, aliasedExpression);
return item;
}
public PropertyReferenceExpression(TableAlias alias, AliasedExpression target, Identifier propertyName)
: base(alias, target)
{
this.PropertyName = propertyName;
}
public virtual IAliasedExpression Update(TableSourceExpression original, TableAlias alias, Mapping.Table table)
{
if (original.Alias != alias || original.Table != table)
return new TableSourceExpression(alias, table);
return original;
}
internal IAliasedExpression Update(Exists item, TableAlias alias, NLinq.Expressions.Expression[] parameters)
{
if (item.Alias != alias || item.Parameters != parameters)
return new Exists(parameters[0]);
return item;
}
public virtual IAliasedExpression Update(ComplexColumnExpression item, TableAlias alias, Evaluant.NLinq.Expressions.Expression exp, Evaluant.NLinq.Expressions.Identifier columnAlias)
{
if (item.Alias != alias || item.Expression != exp || item.ColumnAlias != columnAlias)
return new ComplexColumnExpression(alias, exp, columnAlias);
return item;
}
public ColumnExpression(TableAlias alias, Identifier columnName, Identifier columnAlias)
: base(alias)
{
ColumnName = columnName;
ColumnAlias = columnAlias;
}
public virtual SqlExpressions.CaseTestExpression[] TestCases(string type, out TableAlias alias)
{
return mapper.TestCases(type, out alias);
}
public ColumnExpression(TableAlias alias, Identifier columnName, DbType type)
: base(alias)
{
ColumnName = columnName;
Type = type;
}
public virtual EntityExpression Update(EntityExpression item, Evaluant.NLinq.Expressions.Expression exp, TableAlias alias, string type)
{
if (item.Alias != alias || item.Type != type || item.Expression != exp)
return new EntityExpression(alias) { Type = type, Expression = exp };
return item;
}
public virtual IAliasedExpression Update(JoinedTableExpression item, IAliasedExpression leftTable, IAliasedExpression rightTable, JoinType joinType, TableAlias alias, Evaluant.NLinq.Expressions.BinaryExpression on)
{
if (item.LeftTable != leftTable || item.RightTable != rightTable || item.JoinType != joinType || item.Alias != alias)
return new JoinedTableExpression(leftTable, rightTable, joinType, alias, on);
return item;
}
public CaseTestExpression[] TestCases(string type, TableAlias currentAlias)
{
return mapper.TestCases(type, currentAlias);
}
public TableExpression(TableAlias alias)
: base(alias)
{
}
public virtual IAliasedExpression Update(CaseExpression item, Evaluant.NLinq.Expressions.Expression test, IDbExpression result, CaseTestExpression[] tests, TableAlias alias)
{
if (item.Test != test || item.DefaultResult != result || item.CaseTests != tests || item.Alias != alias)
return new CaseExpression(alias, (IDbExpression)test, (IDbExpression)result, tests);
return item;
}
public Union(TableAlias alias, params IAliasedExpression[] selects)
:base(alias)
{
this.SelectStatements = selects;
}
public virtual IAliasedExpression Update(SelectStatement item, IEnumerable<IAliasedExpression> columns, FromClause from, Evaluant.NLinq.Expressions.WhereClause where, Evaluant.NLinq.Expressions.OrderByClause orderby, TableAlias alias)
{
if (item.Alias != alias || item.Columns != columns || item.From != from || item.OrderBy != orderby || item.Where != where)
return new SelectStatement(alias, columns, from, orderby, where) { Top = item.Top, Distinct = item.Distinct };
return item;
}
