public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { alone = false; var result=base.Visit(expression); alone = true; return result; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { if (inWhere) { Visit(expression.Previous); Visit(expression.Statement); } else if (inFrom) { Visit(expression.Previous); if (currentProperty.Target != null) throw new NotSupportedException(); currentProperty.Target = new PropertyExpression(); currentProperty = currentProperty.Target; Visit(expression.Statement); } else { if (uri.Filter != null || uri.Expand != null || uri.InLineCount != null || uri.Top != null || uri.Skip != null || uri.Select != null) return expression; currentProperty.Target = new PropertyExpression(); currentProperty = currentProperty.Target; Visit(expression.Statement); } return expression; }
public override Evaluant.NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression item) { if (item.Statement is Evaluant.NLinq.Expressions.MethodCall) return base.Visit(item); if (item.Previous is SelectStatement) { Visit(item.Statement); if (item.Statement is Evaluant.NLinq.Expressions.Identifier) { ((SelectStatement)item.Previous).Columns = new ColumnExpression[]{ new ColumnExpression(((IAliasedExpression)item.Previous).Alias,currentEntity.Attributes[((NLinq.Expressions.Identifier)item.Statement).Text].ColumnName) }; return item.Previous; } } Visit(item.Previous); Mapping.Attribute attribute; if (currentEntity != null && currentEntity.Attributes.TryGetValue(((NLinq.Expressions.Identifier)item.Statement).Text, out attribute)) { if (visitingColumns) return new ColumnExpression(currentAlias, attribute.ColumnName, attribute.Name); return new ColumnExpression(currentAlias, attribute.ColumnName); } else return new ColumnExpression(currentAlias, ((NLinq.Expressions.Identifier)item.Statement).Text); }
public override NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.WhereClause expression) { bool wasInWhere = inWhere; inWhere = true; var result = base.Visit(expression); inWhere = wasInWhere; return result; }
public override NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.FromClause expression) { bool wasInFrom = inFrom; inFrom = true; NLinq.Expressions.QueryBodyClause result = base.Visit(expression); inFrom = wasInFrom; return result; }
public override NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.WhereClause expression) { bool wasInFrom = inFrom; inFrom = false; var result = base.Visit(expression); inFrom = wasInFrom; return result; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { bool wasInMember = isInMember; isInMember = true; var result = updater.Update(expression, Visit(expression.Previous), expression.Statement); isInMember = wasInMember; return result; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MethodCall item) { if (item.Identifier.Text == "Infer") { RelationShips.Add((MemberExpression)Visit(item.Parameters[0])); return null; } return base.Visit(item); }
public override NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.FromClause expression) { if (isFirstFrom) { isFirstFrom = false; identifiers.Add(expression.Identifier.Text, null); } return expression; }
public override Evaluant.NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.FromClause expression) { TableAlias alias; if (entityIdentifierAliases.TryGetValue(expression.Identifier.Text, out alias)) { if (alias != ((EntityIdentifier)expression.Identifier).Entity.Alias) throw new NotSupportedException("The same identifier refers to a different Alias"); } else entityIdentifierAliases.Add(expression.Identifier.Text, ((EntityIdentifier)expression.Identifier).Entity.Alias); if (expression.Type != null) { IAliasedExpression src; if (expression.Type.StartsWith("System.")) src = ((EntityIdentifier)expression.Identifier).Entity; else src = new SqlExpressions.Mapping.EntitySourceExpression(((EntityIdentifier)expression.Identifier).Entity.Alias, expression.Type); if (select.From == null) select.From = new FromClause(src); else select.From = new FromClause( new JoinedTableExpression( select.From[0], src, new Evaluant.NLinq.Expressions.BinaryExpression( Evaluant.NLinq.Expressions.BinaryExpressionType.Unknown, expression.Identifier, Visit(expression.Expression)) ) ); } else { SelectStatement currentSelect = select; var result = Visit(expression.Expression); if (select != currentSelect) { select = (SelectStatement)new LazyAliasResolver(new Dictionary<TableAlias, TableAlias> { { select.Alias, ((EntityIdentifier)expression.Identifier).Entity.Alias } }).Visit(select); if (currentSelect.From == null) currentSelect.From = new FromClause(select); else currentSelect.From = new FromClause( new JoinedTableExpression( currentSelect.From[0], select, new NLinq.Expressions.BinaryExpression( NLinq.Expressions.BinaryExpressionType.Unknown, expression.Identifier, result) ) ); } select = currentSelect; } return expression; }
public override NLinq.Expressions.SelectOrGroupClause Visit(NLinq.Expressions.SelectClause expression) { AnonymousParameterList parameters = new AnonymousParameterList(); foreach (var attribute in target.Attributes) { if (!attribute.Value.IsId) continue; parameters.Add(new AnonymousParameter(attribute.Key, new MemberExpression(new Identifier(attribute.Key), targetIdentifier))); } parameters.Add(new AnonymousParameter("Entity", expression.Expression)); return updater.Update(expression, new AnonymousNew(null, parameters)); }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.ValueExpression c) { if (c.Value == null) throw new NotSupportedException(string.Format("The value for the field {0} has to be not null to determine the value type", lastField.ColumnName)); driver.GetTypeInformation(new Model.Attribute(lastField.ColumnName.Text, c.Value.GetType()), new Mapping.Attribute(lastField.ColumnName.Text) { Field = lastField }); lastField.DefaultValue = c.Value.ToString(); lastField.Size = (lastField.DefaultValue.Length / 50 + 1) * 50; return c; }
public override NLinq.Expressions.SelectOrGroupClause Visit(NLinq.Expressions.SelectClause expression) { if (expression.Expression.ExpressionType == NLinq.Expressions.ExpressionTypes.Identifier) { identifierToFind = (Identifier)expression.Expression; return expression; } //visitingSelect = true; base.Visit(expression); //visitingSelect = false; return expression; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { if (expression.Previous != null) Visit(expression.Previous); if (currentEntity != null) { reference = ((Model.Model)currentEntity.Model).GetReference(currentEntity.Type, ((Identifier)expression.Statement).Text); if (reference == null) currentEntity = null; else currentEntity = Reference.Target; } return expression; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { bool changeTempTarget = tempTarget == null; if (changeTempTarget) { tempTarget = target; tempIdentifier = Query.From.Identifier; } var result = base.Visit(expression); if (changeTempTarget) { tempTarget = null; tempIdentifier = null; } return result; }
public override NLinq.Expressions.QueryBodyClause Visit(NLinq.Expressions.FromClause expression) { if (!inQueryBodyClauses) { uri = new RootContainerExpression() { Type = expression.Type }; identifiers.Add(expression.Identifier.Text, uri); } else { inFrom = true; currentProperty = new PropertyExpression(); identifiers.Add(expression.Identifier.Text, currentProperty); Visit(expression.Expression); inFrom = false; } return expression; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { Visit(expression.Previous); if (expression.Statement.ExpressionType == NLinq.Expressions.ExpressionTypes.Identifier) { string propertyName = ((NLinq.Expressions.Identifier)expression.Statement).Text; Model.Attribute attribute = model.GetAttribute(Type, propertyName, false); Model.Reference reference = model.GetReference(Type, propertyName, false); if (attribute != null) { DbType = mapping[Type].Attributes[propertyName].DbType; Type = attribute.TypeName; } else if (reference != null) Type = reference.ChildType; } return base.Visit(expression); }
protected override NLinq.Expressions.Identifier VisitIdentifier(NLinq.Expressions.Identifier identifier) { if (inWhere) { PropertyExpression currentProperty; if (identifiers.TryGetValue(identifier.Text, out currentProperty)) this.currentProperty = currentProperty; else { constraintBuilder.Append(identifier.Text); } } else { if (string.IsNullOrEmpty(currentProperty.Name)) currentProperty.Name = identifier.Text; else throw new NotSupportedException(); } return identifier; }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.BinaryExpression item) { switch (item.Type) { case BinaryExpressionType.And: case BinaryExpressionType.Or: return base.Visit(item); default: string oldIdentifier = currentIdentifier; currentIdentifier = null; Visit(item.LeftExpression); if (currentIdentifier == null) Visit(item.RightExpression); BinaryExpression constraint; if (!identifiers.TryGetValue(currentIdentifier, out constraint)) identifiers[currentIdentifier] = item; else identifiers[currentIdentifier] = new BinaryExpression(BinaryExpressionType.And, constraint, item); return item; } }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { if (expression.Statement.ExpressionType == ExpressionTypes.Call) { MethodCall item = (MethodCall)expression.Statement; switch (item.Identifier.Text) { case "ToLower": return new SqlExpressions.Functions.Lower(Visit(expression.Previous)); case "ToUpper": return new SqlExpressions.Functions.Upper(Visit(expression.Previous)); case "StartsWith": return new Like( Visit(expression.Previous), new BinaryExpression(BinaryExpressionType.Plus, item.Parameters[0], percent)); case "EndsWith": return new Like( Visit(expression.Previous), new BinaryExpression(BinaryExpressionType.Plus, percent, item.Parameters[0] )); case "Contains": return new Like( Visit(expression.Previous), new BinaryExpression(BinaryExpressionType.Plus, percent, new BinaryExpression(BinaryExpressionType.Plus, item.Parameters[0], percent))); } } return base.Visit(expression); }
protected override NLinq.Expressions.Identifier VisitIdentifier(NLinq.Expressions.Identifier identifier) { lastField = new Field(identifier.Text, false); Fields.Add(lastField); return identifier; }
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 override NLinq.Expressions.Expression Visit(NLinq.Expressions.MethodCall item) { return base.Visit(item); }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.Identifier identifier) { if (alone) return new ColumnExpression(defaultAlias, identifier); return base.Visit(identifier); }
public override NLinq.Expressions.Expression Visit(NLinq.Expressions.MemberExpression expression) { var result = Visit(expression.Previous); if (previousIsDateTime) { if (expression.Statement.ExpressionType == ExpressionTypes.Call) { var call = ((MethodCall)expression.Statement); switch (call.Identifier.Text) { case "AddDays": return new DateAdd(DatePart.Day, Visit(call.Parameters[0]), result); case "AddHours": return new DateAdd(DatePart.Hour, Visit(call.Parameters[0]), result); case "AddMilliseconds": return new DateAdd(DatePart.Millisecond, Visit(call.Parameters[0]), result); case "AddMinutes": return new DateAdd(DatePart.Minute, Visit(call.Parameters[0]), result); case "AddMonths": return new DateAdd(DatePart.Month, Visit(call.Parameters[0]), result); case "AddSeconds": return new DateAdd(DatePart.Second, Visit(call.Parameters[0]), result); case "AddTicks": return new DateAdd(DatePart.Microsecond, Visit(call.Parameters[0]), result); case "AddYears": return new DateAdd(DatePart.Year, Visit(call.Parameters[0]), result); default: throw new NotSupportedException(); } } else if (expression.Statement.ExpressionType == ExpressionTypes.Identifier) { switch (((Identifier)expression.Statement).Text) { case "Value": //Case of nullable return result; case "Second": return new DatePart(DatePart.Second, result); case "Minute": return new DatePart(DatePart.Minute, result); case "Hour": return new DatePart(DatePart.Hour, result); case "Day": return new DatePart(DatePart.Day, result); case "Month": return new DatePart(DatePart.Month, result); case "Year": return new DatePart(DatePart.Year, result); default: throw new NotSupportedException(); break; } } } else if (result != null && result.ExpressionType == ExpressionTypes.Identifier) { var identifier = result as EntityIdentifier; if (identifier != null && expression.Statement.ExpressionType == ExpressionTypes.Identifier) { if (identifier.Entity.Type != null) { Mapping.Attribute attribute; if (mapping.Entities[identifier.Entity.Type].Attributes.TryGetValue(((Identifier)expression.Statement).Text, out attribute)) { previousIsDateTime = attribute.DbType == DbType.DateTime || attribute.DbType == DbType.DateTime2; } } else if(identifier.Entity.Expression!=null) { if(identifier.Entity.Expression.ExpressionType==ExpressionTypes.AnonymousNew) { foreach(var param in ((AnonymousNew)identifier.Entity.Expression).Parameters) { if (param.Identifier.Text == ((Identifier)expression.Statement).Text) { Visit(param.Expression); break; } } } } } } return expression; }
public virtual Function Update(Functions.DateAdd item, NLinq.Expressions.Expression[] expression) { if (item.Parameters != expression) return new Functions.DateAdd((Identifier)expression[0], expression[1], expression[2]); return item; }
public virtual Function Update(Functions.Upper item, NLinq.Expressions.Expression[] expression) { if (item.Parameters != expression) return new Functions.Upper(expression[0]); return item; }
internal Function Update(Functions.Exec item, NLinq.Expressions.Expression[] expression) { if (item.Parameters != expression) return new Functions.Exec((IDbStatement)expression[0]); return item; }
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; }
internal IAliasedExpression Update(RowNumber item, NLinq.Expressions.OrderByClause order) { if (item.OverOrder != order) return new RowNumber(order); return item; }