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; }