private void BuildCTE_SelectItems(ISqlSelectQuery query, BuildQueryContext ctx, bool forTeeNodePath = false)
{
//ctx.IsBuildCTESelectItem = true;
foreach (var si in query.Selects.Values)
{
FieldExpression fsi = si.Expression as FieldExpression;
if (!Expression.IsNull(fsi))
{
if (Equals(fsi.Owner.Owner, null))
{
if (forTeeNodePath)
{
ctx.AppendFormat("t.\"{0}\" \"{1}\",", fsi.Name, si.AliasName);
}
else
{
ctx.AppendFormat("t.\"{0}\",", fsi.Name);
}
}
}
//else if (forTeeNodePath)
//{
// var aggRefField = si.Expression as AggregationRefFieldExpression;
// if (!object.Equals(null, aggRefField))
// {
// BuildAggregationRefFieldExpression(aggRefField, ctx);
// ctx.AppendFormat(" \"{0}\",", si.AliasName);
// }
//}
}
//ctx.IsBuildCTESelectItem = false;
}
protected internal override Expression VisitField(FieldExpression node)
{
return new FieldExpression(
node.PrependFieldName(_prefix),
node.Serializer,
node.Original);
}
protected override Expression VisitField(FieldExpression field)
{
_stringBuilder.Append(field.Name);
if (!field.Properties.Any())
{
return(field);
}
_stringBuilder.Append("(");
foreach (var(property, index) in field.Properties.WithIndex())
{
if (index > 0)
{
_stringBuilder.Append(",");
}
_stringBuilder.Append(property.Name);
Visit(property.Expression);
}
_stringBuilder.Append(")");
return(field);
}
public SerializationExpression BindProjector(ref Expression selector)
{
var projector = selector as SerializationExpression;
if (selector.NodeType == ExpressionType.MemberInit || selector.NodeType == ExpressionType.New)
{
var serializer = SerializerBuilder.Build(selector, _serializerRegistry);
projector = new DocumentExpression(serializer);
}
else if (projector == null || projector is PipelineExpression || projector is IFieldExpression || projector is ArrayIndexExpression)
{
var newFieldName = "__fld0";
if (projector is IFieldExpression)
{
// We don't have to do this, but it makes the output a little nicer.
newFieldName = ((IFieldExpression)projector).FieldName;
}
// the output of a $project stage must be a document, so
// if this isn't already a serialization expression and it's not
// a new expression or member init, then we need to create an
// artificial field to project the computation into.
var serializer = GetSerializer(selector.Type, selector);
selector = new FieldAsDocumentExpression(selector, newFieldName, serializer);
projector = new FieldExpression(newFieldName, serializer);
}
return(projector);
}
protected IFieldExpression CallMethodOnGroup
(
TypeCreator typeCreator,
Expression parameter,
LambdaExpression lambda,
MethodInfo methodInfo
)
{
var queryType = typeof(IQueryable <>).MakeGenericType(parameter.Type);
var queryParameter = Expression.Parameter(queryType);
Expression expression = queryParameter;
var method = methodInfo
.MakeGenericMethod(parameter.Type);
expression = Expression.Call
(
method,
expression,
Expression.Quote(lambda)
);
var fieldValue = new FieldExpression(expression, parameter);
return(fieldValue);
}
private void ProcessFieldOwner(FieldExpression fieldExpression)
{
if (TreatEntityAsKey || fieldExpression.Owner == null)
{
return;
}
var entity = fieldExpression.Owner as EntityExpression;
var structure = fieldExpression.Owner as StructureFieldExpression;
while (entity == null && structure != null)
{
entity = structure.Owner as EntityExpression;
structure = structure.Owner as StructureFieldExpression;
}
if (entity == null)
{
throw new InvalidOperationException(String.Format(Strings.ExUnableToResolveOwnerOfFieldExpressionX, fieldExpression));
}
AddColumns(fieldExpression,
entity
.Key
.Mapping
.GetItems()
.AddOne(entity
.Fields
.Single(field => field.Name == WellKnown.TypeIdFieldName)
.Mapping
.Offset));
}
protected internal override Expression VisitField(FieldExpression node)
{
return(new FieldExpression(
node.PrependFieldName(_prefix),
node.Serializer,
node.Original));
}
protected override Expression VisitField(FieldExpression f)
{
_inField = true;
var e = base.VisitField(f);
_inField = false;
return e;
}
protected override Expression VisitField(FieldExpression field)
{
if(!_isMapReduce)
return Visit(field.Expression);
var parts = field.Name.Split('.');
bool isGroupingField = _determiner.IsGroupingKey(field);
Expression current;
if(parts.Contains("Key") && isGroupingField)
current = _document;
else
current = Expression.Call(
_document,
"Get",
new[] {typeof(Document)},
Expression.Constant("value"));
for(int i = 0, n = parts.Length; i < n; i++)
{
var type = i == n - 1 ? field.Type : typeof(Document);
if(parts[i] == "Key" && isGroupingField)
parts[i] = "_id";
current = Expression.Call(
current,
"Get",
new[] {type},
Expression.Constant(parts[i]));
}
return current;
}
// private methods
private Expression BindElementAt(MethodCallExpression node)
{
if (!ExpressionHelper.IsLinqMethod(node))
{
return(base.VisitMethodCall(node));
}
var newNode = base.VisitMethodCall(node);
var methodCallExpression = newNode as MethodCallExpression;
if (node != newNode && methodCallExpression != null &&
(methodCallExpression.Method.DeclaringType == typeof(Enumerable) || methodCallExpression.Method.DeclaringType == typeof(Queryable)))
{
var serializationExpression = methodCallExpression.Arguments[0] as ISerializationExpression;
if (serializationExpression != null)
{
var arraySerializer = serializationExpression.Serializer as IBsonArraySerializer;
BsonSerializationInfo itemSerializationInfo;
if (arraySerializer != null && arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
{
var index = (int)((ConstantExpression)methodCallExpression.Arguments[1]).Value;
var name = index >= 0 ? index.ToString() : "$";
var newName = serializationExpression.AppendFieldName(name);
newNode = new FieldExpression(newName, itemSerializationInfo.Serializer, methodCallExpression);
}
}
}
return(newNode);
}
public static void FieldExpression_Parse_Url()
{
var sut = FieldExpression.Parse("$url");
Assert.Equal(FieldExpressionType.Url, sut.ExpressionType);
Assert.Equal("$url", sut.ToString());
}
public static void FieldExpression_Parse_Method()
{
var sut = FieldExpression.Parse("$method");
Assert.Equal(FieldExpressionType.Method, sut.ExpressionType);
Assert.Equal("$method", sut.ToString());
}
private FieldExpression GetDottedFieldExpression(FieldExpression node)
{
var fieldNames = new List <string> {
node.FieldName
};
var document = node.Document as FieldExpression;
while (document != null)
{
fieldNames.Add(document.FieldName);
document = document.Document as FieldExpression;
}
string dottedFieldName;
if (fieldNames.Count > 1)
{
fieldNames.Reverse();
dottedFieldName = string.Join(".", fieldNames);
}
else
{
dottedFieldName = fieldNames[0];
}
return(new FieldExpression(null, dottedFieldName, node.Serializer, node.Original));
}
private void CheckFieldExpression(FieldExpression e, TypeCheckingContext context)
{
if (!e.IsStatic)
{
PerformTypeChecking(e.Operand, context);
}
e.Field = (e.IsStatic ? e.OwnerType : e.Operand.Type).GetField(e.FieldName);
if (e.Field != null)
{
e.Type = e.Field.FieldType;
}
else
{
e.Property = (e.IsStatic ? e.OwnerType : e.Operand.Type).GetProperty(e.FieldName);
if (e.Property != null)
{
e.Type = e.Property.PropertyType;
}
else
{
context.ErrorProvider.ThrowException(string.Format("Field or property {0}.{1} not found.", e.Operand.Type, e.FieldName), e);
}
}
}
/// <summary>
/// Retrieve concrete expression of an fieldexpression
/// </summary>
/// <param name="expression">FieldExpression</param>
/// <returns>Concrete expression</returns>
private Expression GetExpression(FieldExpression expression)
{
Expression expr = expression.GetExpression();
//Get real expression, not a variable
while (expr is VarExpression)
{
expr = SymbolTable.GetVariableDefinition(((VarExpression)expr).GetVariableIdentifier());
}
//Get specific record from recordExpression
if (expr is RecordExpression)
{
RecordExpression record = (RecordExpression)expr;
ISyntaxNode[] recordArray = record.GetRecords().ToArray();
foreach (KeyValuePair pair in recordArray)
{
if (pair.GetKey() == expression.GetIdentifier())
{
return(pair.GetValue());
}
}
}
return(null);
}
public virtual Expression Visit(FieldExpression expression)
{
return(new FieldExpression(expression.Token, expression.Left.Accept(this))
{
EndToken = expression.EndToken
});
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
Expression keySelector;
var previousSelectExpression = source as SelectExpression;
if (previousSelectExpression != null)
{
keySelector = previousSelectExpression.Selector;
source = previousSelectExpression.Source;
var fieldAsDocumentExpression = keySelector as FieldAsDocumentExpression;
if (fieldAsDocumentExpression != null)
{
keySelector = fieldAsDocumentExpression.Expression;
}
}
else if (pipeline.Projector is FieldExpression)
{
keySelector = pipeline.Projector;
}
else
{
var currentProjector = (ISerializationExpression)pipeline.Projector;
keySelector = new FieldExpression("$ROOT", currentProjector.Serializer);
}
var serializer = bindingContext.GetSerializer(keySelector.Type, keySelector);
return(new PipelineExpression(
new GroupByExpression(
source,
keySelector),
new FieldExpression("_id", serializer)));
}
public void IfThenClauseNegated()
{
// Arrange
var mockField = new Mock <IField>().Object;
var expr = new FieldExpression(mockField);
var pred = new ConstantClause(expr, ComparisonOperator.GTE, DBValue.Create(100));
var subseq = new ConstantClause(expr, ComparisonOperator.LTE, DBValue.Create(200));
var subseqNeg = new ConstantClause(expr, ComparisonOperator.GT, DBValue.Create(200));
var clause = Clause.IfThen(pred, subseq).Negation();
var mockBuilder = new Mock <IConstraintDeclBuilder>();
// Sequence
var sequence = mockBuilder.MakeSequence();
sequence.Add(builder => builder.StartClause());
sequence.Add(builder => builder.AddClause(subseqNeg.Matcher()));
sequence.Add(builder => builder.And());
sequence.Add(builder => builder.AddClause(pred.Matcher()));
sequence.Add(builder => builder.EndClause());
// Act
var fields = clause.GetDependentFields();
clause.AddDeclarationTo(mockBuilder.Object);
// Assert
fields.Should().BeEquivalentTo(new IField[] { mockField, mockField });
sequence.VerifyCompleted();
mockBuilder.VerifyNoOtherCalls();
}
private void EvalItem
(
TypeCreator typeCreator,
Expression parameter,
JObject jObject
)
{
var props = jObject.Properties()
.ToDictionary(o => o.Name, o => o.Value);
var left = props["name"];
var rule = props["rule"];
var right = props["value"];
var leftExpression = typeCreator.BuildProjection(parameter, (JArray)left, false);
var rightExpression = default(IFieldExpression);
if (right is JArray)
{
rightExpression = typeCreator.BuildProjection(parameter, (JArray)right, false);
}
else
{
rightExpression = new FieldExpression(Expression.Constant(right.Value <object>()), parameter);
}
}
public static void FieldExpression_Parse_StatusCode()
{
var sut = FieldExpression.Parse("$statusCode");
Assert.Equal(FieldExpressionType.StatusCode, sut.ExpressionType);
Assert.Equal("$statusCode", sut.ToString());
}
/// <summary>
/// FieldExpression を作成する.
/// </summary>
/// <returns></returns>
public static GeneratedExpression CreateField()
{
FieldExpression exp = new FieldExpression();
exp.Type = ExpressionType.Field;
return(exp);
}
private bool Method(FieldExpression field, out MethodExpression op)
{
var args = ReadMethodArguments();
op = new MethodExpression(field.FieldValue, args);
return(true);
}
protected override Expression VisitField(FieldExpression field)
{
FieldExpression mapped;
if (_map.TryGetValue(field, out mapped))
return mapped;
return field;
}
// protected methods
protected override Expression VisitBinary(BinaryExpression node)
{
var newNode = base.VisitBinary(node);
var binary = newNode as BinaryExpression;
if (binary != null && binary.NodeType == ExpressionType.ArrayIndex)
{
var serializationExpression = binary.Left as IBsonSerializationInfoExpression;
if (serializationExpression != null)
{
var arraySerializer = serializationExpression.SerializationInfo.Serializer as IBsonArraySerializer;
var indexExpression = binary.Right as ConstantExpression;
if (arraySerializer != null && indexExpression != null && indexExpression.Type == typeof(int))
{
var index = (int)indexExpression.Value;
var itemSerializationInfo = arraySerializer.GetItemSerializationInfo();
itemSerializationInfo = new BsonSerializationInfo(
index.ToString(),
itemSerializationInfo.Serializer,
itemSerializationInfo.NominalType);
var serializationInfo = serializationExpression.SerializationInfo.Merge(itemSerializationInfo);
newNode = new FieldExpression(binary, serializationInfo, serializationExpression.IsProjected);
}
}
}
return(newNode);
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var newType = node.Method.GetGenericArguments()[0];
var serializer = bindingContext.GetSerializer(newType, pipeline.Projector);
var projector = pipeline.Projector;
var fieldProjector = projector as IFieldExpression;
if (fieldProjector != null)
{
projector = new FieldExpression(
fieldProjector.FieldName,
serializer);
}
else
{
projector = new DocumentExpression(serializer);
}
return(new PipelineExpression(
new WhereExpression(
pipeline.Source,
"__p",
Expression.TypeIs(pipeline.Projector, newType)),
projector));
}
protected override Expression VisitBinary(BinaryExpression node)
{
var newNode = base.VisitBinary(node);
var binaryExpression = newNode as BinaryExpression;
if (binaryExpression != null && binaryExpression.NodeType == ExpressionType.ArrayIndex)
{
var serializationExpression = binaryExpression.Left as ISerializationExpression;
if (serializationExpression != null)
{
var arraySerializer = serializationExpression.Serializer as IBsonArraySerializer;
var indexExpression = binaryExpression.Right as ConstantExpression;
BsonSerializationInfo itemSerializationInfo;
if (arraySerializer != null &&
indexExpression != null &&
indexExpression.Type == typeof(int) &&
arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
{
var index = (int)indexExpression.Value;
var name = index >= 0 ? index.ToString() : "$";
var newName = serializationExpression.AppendFieldName(name);
newNode = new FieldExpression(newName, itemSerializationInfo.Serializer, binaryExpression);
}
}
}
return(newNode);
}
protected override Expression VisitFieldExpression(FieldExpression expression)
{
var tupleExpression = GetTupleExpression(expression);
// Materialize non-owned field.
if (expression.Owner == null || expression.UnderlyingProperty == null)
{
if (expression.Field.IsEnum)
{
var underlyingType = Enum.GetUnderlyingType(expression.Type.StripNullable());
if (expression.Field.IsNullable)
{
underlyingType = underlyingType.ToNullable();
}
var result = Expression.Convert(
tupleExpression.MakeTupleAccess(underlyingType, expression.Mapping.Offset),
expression.Type);
return(result);
}
if (typeof(Key).IsAssignableFrom(expression.Field.ValueType))
{
Expression <Func <Domain, string, Key> > keyParseLambda = (d, s) => Key.Parse(d, s);
Expression <Func <ItemMaterializationContext, Domain> > domainExtractorLambda = imc => imc.Session.Domain;
var result = keyParseLambda.BindParameters(
domainExtractorLambda.BindParameters(itemMaterializationContextParameter),
tupleExpression.MakeTupleAccess(typeof(string), expression.Mapping.Offset));
return(result);
}
var tupleAccess = tupleExpression.MakeTupleAccess(expression.Type, expression.Mapping.Offset);
return(tupleAccess);
}
return(MaterializeThroughOwner(expression, tupleExpression));
}
protected override Expression VisitField(FieldExpression field)
{
if (_oldAliases.Contains(field.Alias))
{
return(new FieldExpression(field.Expression, _newAlias, field.Name, field.MemberMap));
}
return(field);
}
protected virtual Expression VisitField(FieldExpression field)
{
var e = Visit(field.Expression);
if (field.Expression != e)
field = new FieldExpression(e, field.Alias, field.Name);
return field;
}
protected override Expression VisitField(FieldExpression f)
{
_inField = true;
var e = base.VisitField(f);
_inField = false;
return(e);
}
protected virtual Expression VisitField(FieldExpression field)
{
var properties = VisitFieldDeclarations(field.Properties);
return(properties.Equals(field.Properties)
? field
: new FieldExpression(field.Type, field.Name, properties));
}
public UpdateBuilder<T> SetPartial<TV>(Expression<Func<T, TV>> field, Action<UpdateBuilder<TV>> build)
{
var expression = new FieldExpression<T, TV>(field);
_updates.Add(new AqlUpdateSetPartial<T, TV>(expression.Field, (_fieldname ?? expression.Name) + "." + expression.Field, build));
return this;
}
public UpdateBuilder<T> Inc<TV>(Expression<Func<T, TV>> field, IAqlValue<TV> build)
{
var expression = new FieldExpression<T, TV>(field);
_updates.Add(new AqlUpdateInc(expression.Field, (_fieldname ?? expression.Name), build));
return this;
}
protected override Expression VisitField(FieldExpression field)
{
if (field.Alias == this.documentAlias) {
return Expression.Convert(Expression.Call(this.documentParameter, miGetValue, Expression.Constant(field.Name), Expression.Constant(field.Type)), field.Type);
}
return field;
}
public UpdateBuilder<T> Set<TV>(Expression<Func<T, TV>> field, IAqlValue<TV> value)
{
var expression = new FieldExpression<T, TV>(field);
_updates.Add(new AqlUpdateSetValue(expression.Field, value));
return this;
}
public string Visit(FieldExpression node)
{
var codeWriter = new XzaarCodeWriter();
codeWriter.Write(node.FieldType + " " + node.Name, currentIndent);
codeWriter.NewLine();
return(codeWriter.ToString());
}
protected override Expression VisitField(FieldExpression field)
{
Alias newAlias;
if (_map.TryGetValue(field.Alias, out newAlias))
return new FieldExpression(field.Expression, newAlias, field.Name);
return field;
}
protected override Expression VisitField(FieldExpression field)
{
var fields = new FieldGatherer().Gather(field.Expression);
if (fields.Count == 0)
_fields.Add(field);
else
_fields.AddRange(fields);
return base.VisitField(field);
}
protected internal override Expression VisitField(FieldExpression node)
{
var document = Visit(node.Document) as IFieldExpression;
if (document != null)
{
return new FieldExpression(
node.PrependFieldName(document.FieldName),
node.Serializer,
node.Original);
}
return node;
}
protected internal override Expression VisitField(FieldExpression node)
{
if (node.Document is IFieldExpression || node.Document is ArrayIndexExpression)
{
return node.Update(
Visit(node.Document),
node.Original);
}
return new FieldExpression(
node.Document,
node.PrependFieldName(_prefix),
node.Serializer,
node.Original);
}
protected override Expression Visit(Expression expression)
{
if (this.candidates.Contains(expression))
{
if (expression.NodeType == (ExpressionType)LuceneExpressionType.Field)
{
FieldExpression field = (FieldExpression)expression;
FieldExpression mapped;
if (this.map.TryGetValue(field, out mapped))
{
return mapped;
}
if (this.existingAlias == field.Alias)
{
int ordinal = this.fields.Count;
string fieldName = this.GetUniqueFieldName(field.Name);
this.fields.Add(new FieldDeclaration(fieldName, field));
mapped = new FieldExpression(field.Type, this.newAlias, fieldName, ordinal, field.Analyzer);
this.map[field] = mapped;
this.fieldNames.Add(fieldName);
return mapped;
}
// must be referring to outer scope
return field;
}
else
{
string fieldName = this.GetNextFieldName();
int ordinal = this.fields.Count;
this.fields.Add(new FieldDeclaration(fieldName, expression));
return new FieldExpression(expression.Type, this.newAlias, fieldName, ordinal, new StandardAnalyzer());
}
}
else
{
return base.Visit(expression);
}
}
protected override Expression VisitField(FieldExpression field)
{
if (!_isMapReduce)
return Visit(field.Expression);
var parts = field.Name.Split('.');
bool isGroupingField = _determiner.IsGroupingKey(field);
Expression current;
if (parts.Contains("Key") && isGroupingField)
current = _document;
else
current = Expression.Call(
_document,
"GetValue",
Type.EmptyTypes,
Expression.Constant("value"));
for (int i = 0; i < parts.Length; i++)
{
if (parts[i] == "Key" && isGroupingField)
parts[i] = "_id";
current = Expression.Call(
Expression.Convert(
current,
typeof(BsonDocument)),
"GetValue",
Type.EmptyTypes,
Expression.Constant(parts[i]));
}
return Expression.Convert(
current = Expression.Call(
typeof(Convert),
"ChangeType",
Type.EmptyTypes,
Expression.MakeMemberAccess(current, typeof(BsonValue).GetProperty("RawValue")),
Expression.Constant(field.Type)),
field.Type);
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
var fields = select.Fields.OrderBy(f => f.Name).ToList();
var removed = new BitArray(fields.Count);
var anyRemoved = false;
for (int i = 0, n = fields.Count; i < n; i++)
{
var fi = fields[i];
var fxi = new FieldExpression(fi.Expression, select.Alias, fi.Name);
for (int j = i + 1; j < n; j++)
{
if (!removed.Get(i))
{
FieldDeclaration fj = fields[j];
if (AreSameExpression(fi.Expression, fj.Expression))
{
var fxj = new FieldExpression(fj.Expression, select.Alias, fj.Name);
_map.Add(fxj, fxi);
removed.Set(j, true);
anyRemoved = true;
}
}
}
}
if (anyRemoved)
{
var newFields = new List<FieldDeclaration>();
for (int i = 0, n = fields.Count; i < n; i++)
{
if (!removed.Get(i))
newFields.Add(fields[i]);
}
select = select.SetFields(newFields);
}
return select;
}
protected override Expression VisitField(FieldExpression f)
{
return f;
}
private BsonClassMap BuildClassMap(Type type, ProjectionMapping mapping)
{
if (type == null || type == typeof(object))
{
return null;
}
var baseClassMap = BuildClassMap(type.GetTypeInfo().BaseType, mapping);
if (baseClassMap != null)
{
baseClassMap.Freeze();
}
var classMap = new BsonClassMap(type, baseClassMap);
foreach (var memberMapping in mapping.Members.Where(x => x.Member.DeclaringType == type))
{
var serializationExpression = memberMapping.Expression as SerializationExpression;
if (serializationExpression == null)
{
var serializer = Build(memberMapping.Expression);
serializationExpression = new FieldExpression(
memberMapping.Member.Name,
serializer,
memberMapping.Expression);
}
var memberMap = classMap.MapMember(memberMapping.Member)
.SetSerializer(serializationExpression.Serializer)
.SetElementName(memberMapping.Member.Name);
if (classMap.IdMemberMap == null && serializationExpression is GroupingKeyExpression)
{
classMap.SetIdMember(memberMap);
}
}
return classMap;
}
protected internal virtual Expression VisitField(FieldExpression node)
{
return node.Update(
Visit(node.Document),
node.Original);
}
private Expression VisitCorrelatedGroup(CorrelatedExpression node)
{
var groupExpression = (GroupByExpression)node.Expression;
if (_accumulatorLookup != null && _accumulatorLookup.Contains(node.CorrelationId))
{
var source = Visit(groupExpression.Source);
var accumulators = new List<AccumulatorExpression>();
var fieldExpressions = new List<FieldExpression>();
var comparer = new ExpressionComparer();
foreach (var correlatedAccumulator in _accumulatorLookup[node.CorrelationId])
{
var index = accumulators.FindIndex(x => comparer.Compare((Expression)x, correlatedAccumulator.Expression));
FieldExpression fieldExpression;
if (index == -1)
{
var accumulator = (AccumulatorExpression)correlatedAccumulator.Expression;
// TODO: might not need to do any renames...
accumulator = new AccumulatorExpression(
accumulator.Type,
"__agg" + accumulators.Count,
accumulator.Serializer,
accumulator.AccumulatorType,
accumulator.Argument);
accumulators.Add(accumulator);
fieldExpression = new FieldExpression(accumulator.FieldName, accumulator.Serializer);
fieldExpressions.Add(fieldExpression);
}
else
{
fieldExpression = fieldExpressions[index];
}
_accumulatorReplacementMap[correlatedAccumulator] = fieldExpression;
}
groupExpression = new GroupByExpression(
groupExpression.Type,
source,
groupExpression.KeySelector,
accumulators.AsReadOnly());
}
return Visit(groupExpression);
}
private BsonValue TranslateField(FieldExpression expression)
{
if (expression.Document == null)
{
return "$" + expression.FieldName;
}
// 2 possibilities.
// 1. This is translatable into a single string:
// 2. This has an array index operation in it which we must then use a $let expression for
var parent = expression.Document;
var currentName = expression.FieldName;
while (parent != null)
{
var field = parent as IFieldExpression;
if (field != null)
{
currentName = field.FieldName + "." + currentName;
parent = field.Document;
}
else
{
var array = parent as ArrayIndexExpression;
if (array != null)
{
return new BsonDocument("$let", new BsonDocument
{
{ "vars", new BsonDocument("item", TranslateValue(parent)) },
{ "in", "$$item." + currentName }
});
}
break;
}
}
return "$" + currentName;
}
protected internal override void VisitFieldExpression(FieldExpression expression)
{
WriteMemberAccess((ComponentMetadata)expression.Field.DeclaringObject);
_writer.Append("{0}", expression.Field.Name);
}
protected override Expression VisitField(FieldExpression field)
{
QueryString.Append(field.Name).Append(":");
return field;
}
public virtual LinqExpression VisitField(FieldExpression field)
{
var target = Visit(field.Target);
var mi = target.Type.GetFieldOrProperty(field.Name);
if (mi is FieldInfo)
{
return LinqExpression.Field(target, (FieldInfo)mi);
}
if (mi is PropertyInfo)
{
return LinqExpression.Property(target, (PropertyInfo)mi);
}
throw new NotSupportedException(field.ToString());
}
protected override Expression VisitField(FieldExpression field)
{
if (_oldAliases.Contains(field.Alias))
return new FieldExpression(field.Expression, _newAlias, field.Name);
return field;
}
private BindResult RebindOrderings(IEnumerable<OrderExpression> orderings, Alias alias, ICollection<Alias> existingAliases, IEnumerable<FieldDeclaration> existingFields)
{
List<FieldDeclaration> newFields = null;
var newOrderings = new List<OrderExpression>();
foreach (var ordering in orderings)
{
var expression = ordering.Expression;
var field = expression as FieldExpression;
if(field != null && (existingAliases == null || !existingAliases.Contains(field.Alias)))
continue;
int ordinal = 0;
foreach (var fieldDecl in existingFields)
{
var fieldDeclExpression = fieldDecl.Expression as FieldExpression;
if (fieldDecl.Expression == ordering.Expression || (field != null && fieldDeclExpression != null && field.Alias == fieldDeclExpression.Alias && field.Name == fieldDeclExpression.Name))
{
if(field != null)
expression = new FieldExpression(field.Expression, alias, fieldDecl.Name, field.MemberMap);
break;
}
ordinal++;
}
if (expression == ordering.Expression)
{
if (newFields == null)
{
newFields = new List<FieldDeclaration>(existingFields);
existingFields = newFields;
}
var fieldName = field != null ? field.Name : "_$f" + ordinal;
newFields.Add(new FieldDeclaration(fieldName, ordering.Expression));
expression = new FieldExpression(expression, alias, fieldName);
}
newOrderings.Add(new OrderExpression(ordering.OrderType, expression));
}
return new BindResult(existingFields, newOrderings);
}
public string GetExpression(FieldExpression expression, ref List<OleDbParameter> parameters)
{
return " " + _entityQueryWrapper.GetDbFieldName(expression.FieldName) + " ";
}
protected internal override void VisitFieldExpression(FieldExpression expression)
{
_expr = Ssm.Expr.NewVarExpr(Ssm.Var.NewField(expression.Field.Name, Transform(expression.Field.Type)));
}
public SerializationExpression BindProjector(ref Expression selector)
{
var projector = selector as SerializationExpression;
if (selector.NodeType == ExpressionType.MemberInit || selector.NodeType == ExpressionType.New)
{
var serializer = GetSerializer(selector.Type, selector);
projector = new DocumentExpression(serializer);
}
else if (projector == null || projector is IFieldExpression || projector is ArrayIndexExpression)
{
var newFieldName = "__fld0";
if (projector is IFieldExpression)
{
// We don't have to do this, but it makes the output a little nicer.
newFieldName = ((IFieldExpression)projector).FieldName;
}
// the output of a $project stage must be a document, so
// if this isn't already a serialization expression and it's not
// a new expression or member init, then we need to create an
// artificial field to project the computation into.
var serializer = GetSerializer(selector.Type, selector);
selector = new FieldAsDocumentExpression(selector, newFieldName, serializer);
projector = new FieldExpression(newFieldName, serializer);
}
return projector;
}
protected virtual bool CompareField(FieldExpression a, FieldExpression b)
{
return CompareAlias(a.Alias, b.Alias) && a.Name == b.Name && Compare(a.Expression, b.Expression);
}
private BsonValue TranslateField(FieldExpression expression)
{
return "$" + expression.FieldName;
}
/// <summary>
/// Visits an element of type <see cref="FieldExpression" />.
/// </summary>
/// <param name="expression">The <see cref="FieldExpression" /> instance that should be visited.</param>
protected internal virtual void VisitFieldExpression(FieldExpression expression)
{
DefaultVisit(expression);
}
protected internal virtual Expression VisitField(FieldExpression node)
{
return node;
}
