public Evaluant.Uss.Commands.Command Visit(Evaluant.Uss.Commands.Command item)
{
switch (item.CommandType)
{
case Evaluant.Uss.Commands.CommandTypes.CompoundCreate:
return Visit((CompoundCreateCommand)item);
case Evaluant.Uss.Commands.CommandTypes.CompoundUpdate:
return Visit((CompoundUpdateCommand)item);
case Evaluant.Uss.Commands.CommandTypes.CreateAttribute:
return Visit((CreateAttributeCommand)item);
case Evaluant.Uss.Commands.CommandTypes.CreateEntity:
return Visit((CreateEntityCommand)item);
case Evaluant.Uss.Commands.CommandTypes.CreateReference:
return Visit((CreateReferenceCommand)item);
case Evaluant.Uss.Commands.CommandTypes.DeleteAttribute:
return Visit((DeleteAttributeCommand)item);
case Evaluant.Uss.Commands.CommandTypes.DeleteEntity:
return Visit((DeleteEntityCommand)item);
case Evaluant.Uss.Commands.CommandTypes.DeleteReference:
return Visit((DeleteReferenceCommand)item);
case Evaluant.Uss.Commands.CommandTypes.UpdateAttribute:
return Visit((UpdateAttributeCommand)item);
default:
throw new NotSupportedException();
}
}
public SqlMapperTransformer(Mapping mapping, Evaluant.Uss.Models.Model model)
{
_Mapping = mapping;
_Model = model;
_ExprLevel = new Stack();
_AliasColumnMapping = new Hashtable();
_IsAliasColumnComputed = false;
// Add "Type" and "Id" field. Avoid duplicated field if mapping model contains these two keyword fields.
// _AliasColumnMapping.Add("Type", "Type");
foreach (EntityMapping em in mapping.Entities)
{
if (em.DiscriminatorField == null || em.DiscriminatorField == string.Empty)
continue;
if (_AliasColumnMapping.ContainsKey(em.DiscriminatorField))
continue;
_AliasColumnMapping.Add(em.DiscriminatorField, em.DiscriminatorField);
}
//_AliasColumnMapping.Add("Id", "Id");
}
public override Evaluant.NLinq.Expressions.QueryBodyClause Visit(Evaluant.NLinq.Expressions.WhereClause expression)
{
inWhere = true;
Evaluant.NLinq.Expressions.QueryBodyClause result = base.Visit(expression);
inWhere = false;
return result;
}
public override Evaluant.Uss.Commands.CompoundCreateCommand Visit(Evaluant.Uss.Commands.CompoundCreateCommand item)
{
Visit((CreateEntityCommand)item);
foreach (Command c in item.InnerCommands)
Visit(c);
return item;
}
public override Evaluant.NLinq.Expressions.SelectOrGroupClause Visit(Evaluant.NLinq.Expressions.SelectClause expression)
{
inSelect = true;
base.Visit(expression);
inSelect = false;
return expression;
}
public override Evaluant.Uss.Commands.CreateEntityCommand Visit(Evaluant.Uss.Commands.CreateEntityCommand item)
{
InsertMessage insert;
IRequestMessage message;
if (this.insert != null)
{
Domain.Entity e = new Evaluant.Uss.Domain.Entity(item.ParentEntity.Type);
e.Id = item.ParentId;
//e.AddValue("_id", item.ParentId);
this.insert.Documents.Add(e);
commands.Add(item.ParentEntity, this.insert);
}
else if (!commands.TryGetValue(item.ParentEntity, out message))
{
this.insert = new InsertMessage() { FullCollectionName = database + "." + item.Type };
messages.Add(this.insert);
message = this.insert;
commands.Add(item.ParentEntity, message);
insert = (InsertMessage)message;
Domain.Entity e = new Evaluant.Uss.Domain.Entity(item.ParentEntity.Type);
e.Id = item.ParentId;
//e.AddValue("_id", item.ParentId);
insert.Documents.Add(e);
}
else
throw new NotSupportedException();
return item;
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.MemberExpression expression)
{
if (expression.Previous == null)
return base.Visit(expression);
NLinq.Expressions.Expression previous = Visit(expression.Previous);
Evaluant.NLinq.Expressions.Identifier propertyName = expression.Statement as Evaluant.NLinq.Expressions.Identifier;
if (propertyName != null)
{
if (currentEntity.References.ContainsKey(propertyName.Text))
{
currentReference = currentEntity.References[propertyName.Text];
currentEntity = engine.Factory.Model.Entities[currentReference.ChildType];
}
else
{
currentReference = null;
}
}
else
{
currentEntity = null;
currentReference = null;
}
return updater.Update(expression, previous, Visit(expression.Statement));
}
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 override Evaluant.NLinq.Expressions.QueryBodyClause Visit(Evaluant.NLinq.Expressions.WhereClause expression)
{
if (select.Where == null)
select.Where = (Evaluant.NLinq.Expressions.WhereClause)base.Visit(expression);
else
select.Where = new NLinq.Expressions.WhereClause(new NLinq.Expressions.BinaryExpression(NLinq.Expressions.BinaryExpressionType.And, select.Where.Expression, Visit(expression.Expression)));
return select.Where;
}
public override string Render(Evaluant.NLinq.Expressions.Expression expression)
{
type = SqlExpressions.DbExpressionType.Unknown;
TraceHelper.TraceEvent(SqlMapperProvider.TraceSource, System.Diagnostics.TraceEventType.Start, 1, "Rendering");
string sql = base.Render(expression);
TraceHelper.TraceEvent(SqlMapperProvider.TraceSource, System.Diagnostics.TraceEventType.Stop, 1, "Rendering");
TraceHelper.TraceData(SqlMapperProvider.TraceSource, System.Diagnostics.TraceEventType.Information, (int)type, sql);
return sql;
}
public override IAliasedExpression Visit(Evaluant.Uss.SqlExpressions.Mapping.EntitySourceExpression item)
{
Mapping.Entity em = mapping.Entities[item.EntityType];
if (em.Inherit != null && em.Inheritance.DiscriminatorExpression != null)
{
additionnalClauses.Add(new NLinq.Expressions.WhereClause(new DiscriminatorMutator(item).Visit(em.Inheritance.DiscriminatorExpression)));
}
return new TableSourceExpression(item.Alias, mapping.Entities[item.EntityType].Table);
}
public override Evaluant.NLinq.Expressions.QueryBodyClause Visit(Evaluant.NLinq.Expressions.WhereClause expression)
{
//Evaluant.NLinq.Expressions.Expression exp = Visit(expression.Expression);
//if (exp == null)
// return null;
if (constraint != null)
return updater.Update((NLinq.Expressions.WhereClause)base.Visit(expression), new NLinq.Expressions.BinaryExpression(NLinq.Expressions.BinaryExpressionType.And, expression.Expression, constraint));
return base.Visit(expression);
}
public override Evaluant.NLinq.Expressions.QueryBodyClause Visit(Evaluant.NLinq.Expressions.FromClause expression)
{
Query = new QueryMessage();
Query.NumberToReturn = 1;
if (currentEntity == null)
{
currentEntity = new Entity(expression.Type);
identifiers.Add(expression.Identifier.Text, currentEntity);
}
else
{
currentEntity = new Entity(expression.Type);
identifiers.Add(expression.Identifier.Text, currentEntity);
}
return expression;
}
//public override MethodCall VisitMethodCall(MethodCall call)
//{
// if (call.MethodName.Text == "Count")
// {
// newAggregates.Push(new Aggregate(AggregateFunctionType.Count, call.Target));
// return newAggregates.Peek();
// }
// return base.VisitMethodCall(call);
//}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.MemberExpression expression)
{
//Evaluant.NLinq.Expressions.Expression previous = null;
//if (expression.Previous != null)
// previous = Visit(expression.Previous);
if (expression.Statement is NLinq.Expressions.MethodCall)
{
NLinq.Expressions.Expression exp = Visit(expression.Statement);
IDbExpression dbExp = exp as IDbExpression;
if (dbExp != null && dbExp.DbExpressionType == DbExpressionType.Aggregate)
return new SelectStatement(new TableAlias(), new IAliasedExpression[] { new ComplexColumnExpression(null, exp) }, new FromClause(new ComplexColumnExpression(null, Visit(expression.Previous))), null, null);
return new SelectStatement(new TableAlias(), new IAliasedExpression[] { new ComplexColumnExpression(null, new Constant("true", System.Data.DbType.Boolean)) }, new FromClause(new ComplexColumnExpression(null, Visit(expression.Previous))), null, new NLinq.Expressions.WhereClause(exp));
}
else
{
NLinq.Expressions.Expression statement = Visit(expression.Statement);
return updater.Update(expression, expression.Previous, statement);
}
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.MethodCall item)
{
if (item.Identifier.Text == "Count")
{
if (item.LambdaExpression == null)
newAggregates.Push(new Aggregate(AggregateFunctionType.Count));
else
newAggregates.Push(new Aggregate(AggregateFunctionType.Count, Visit(item.LambdaExpression)));
return newAggregates.Peek();
}
if (item.Identifier.Text == "Any")
{
if (item.LambdaExpression == null)
newAggregates.Push(new Exists(null));
else
newAggregates.Push(new Exists(Visit(item.LambdaExpression)));
return newAggregates.Peek();
}
return base.VisitMethodCall(item);
}
public override Evaluant.Uss.Commands.CreateAttributeCommand Visit(Evaluant.Uss.Commands.CreateAttributeCommand item)
{
IRequestMessage message;
if (item.Type == typeof(Guid))
return item;
if (!commands.TryGetValue(item.ParentEntity, out message))
throw new NotSupportedException();
InsertMessage im = message as InsertMessage;
if (im != null)
{
foreach (Domain.Entity e in im.Documents)
{
if (e.Id == item.ParentId)
{
e.Add(item.Name, item.Value, item.Type, State.New);
break;
}
}
}
return item;
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.MemberExpression expression)
{
if (expression.Previous == null)
return Visit(expression.Statement);
List<Evaluant.NLinq.Expressions.Expression> expressions = new List<Evaluant.NLinq.Expressions.Expression>(expression.Expressions);
Evaluant.NLinq.Expressions.Expression exp = Visit(expressions[1]);
if (exp is NLinq.Expressions.MethodCall)
{
NLinq.Expressions.MethodCall oldCall = exp as NLinq.Expressions.MethodCall;
expressions.RemoveAt(1);
MethodCall call = new MethodCall(Visit(expressions[0]), oldCall.Identifier, oldCall.Parameters);
if (expressions.Count == 1)
return call;
expressions[0] = call;
return Visit(updater.Update(expression, expressions.ToArray()));
}
return base.Visit(expression);
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.BinaryExpression item)
{
NLinq.Expressions.Expression left = Visit(item.LeftExpression);
NLinq.Expressions.Expression right = Visit(item.RightExpression);
if (left == null)
return right;
if (right == null)
return left;
Constant constant = left as Constant;
if (constant != null && right is NLinq.Expressions.MemberExpression)
{
if (currentReference != null && currentReference.Cardinality is Cardinality.ToMany && constant.Value == null)
return null;
}
constant = right as Constant;
if (constant != null && left is NLinq.Expressions.MemberExpression)
{
if (currentReference != null && currentReference.Cardinality is Cardinality.ToMany && constant.Value == null)
return null;
}
return item;
}
public override EntitySet Load(Evaluant.NLinq.NLinqQuery query, string[] attributes, string orderby, int first, int max)
{
if (first <= 0)
throw new ArgumentException("first must be greater than 0");
if (max < 0)
throw new ArgumentException("max must be none negative");
XPathTransformer transformer = new XPathTransformer(Factory.Model);
string xpath = transformer.ConvertToXPath(query);
EntitySet result = LoadWithXPath(xpath);
LoadAttribute(result, attributes);
// sort
if (orderby != null)
result.Sort(orderby.Split(','));
// page
EntitySet pageResult = new EntitySet();
Utils.TruncateList(result, pageResult, first, max);
return pageResult;
}
public virtual CaseTestExpression Update(CaseTestExpression test, Evaluant.NLinq.Expressions.Expression exp, Evaluant.NLinq.Expressions.Expression result)
{
if (test.TestExpression != exp || test.TestResult != result)
return new CaseTestExpression(exp, result);
return test;
}
protected override Evaluant.NLinq.Expressions.Identifier VisitIdentifier(Evaluant.NLinq.Expressions.Identifier identifier)
{
if (identifier == null)
return null;
referencePath.Append(identifier.Text);
return base.VisitIdentifier(identifier);
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.BinaryExpression item)
{
NLinq.Expressions.Expression exp = base.Visit(item);
if (exp is NLinq.Expressions.BinaryExpression)
{
//item = (NLinq.Expressions.BinaryExpression)exp;
if (item.Type == Evaluant.NLinq.Expressions.BinaryExpressionType.NotEqual)
{
NLinq.Expressions.Expression otherMember = null;
if (item.LeftExpression is Constant && ((Constant)item.LeftExpression).Value == null)
otherMember = item.RightExpression;
if (item.RightExpression is Constant && ((Constant)item.RightExpression).Value == null)
otherMember = item.LeftExpression;
var analyzer = new Analyzers.ReferenceAnalyzer(mapping.Model);
analyzer.Visit(otherMember);
if (analyzer.Reference != null && analyzer.Reference.Cardinality is Era.Cardinality.ToMany)
return null;
}
else if (item.Type == Evaluant.NLinq.Expressions.BinaryExpressionType.And || item.Type == Evaluant.NLinq.Expressions.BinaryExpressionType.Or)
{
if (item.LeftExpression == null)
return item.RightExpression;
if (item.RightExpression == null)
return item.LeftExpression;
}
}
return exp;
}
public override Evaluant.NLinq.Expressions.Expression Visit(Evaluant.NLinq.Expressions.MemberExpression expression)
{
if (visitingSelect && expression.Previous != null)
return expression;
return base.Visit(expression);
}
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 Like Update(Like item, Evaluant.NLinq.Expressions.Expression[] expressions)
{
if (item.Parameters != expressions)
return new Like(expressions[0], expressions[1]);
return item;
}
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;
}
public virtual KeyValuePair<ColumnExpression, NLinq.Expressions.Expression> Update(KeyValuePair<ColumnExpression, NLinq.Expressions.Expression> item, IAliasedExpression column, Evaluant.NLinq.Expressions.Expression value)
{
if (item.Key != column || item.Value != value)
return new KeyValuePair<ColumnExpression, NLinq.Expressions.Expression>((ColumnExpression)column, value);
return item;
}
public virtual IDbStatement Update(DeleteStatement item, FromClause from, Evaluant.NLinq.Expressions.WhereClause where)
{
if (item.Where != where)
return new DeleteStatement(from, where);
return item;
}
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 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;
}
