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