protected internal virtual Expression VisitCorrelatedGroupBy(CorrelatedGroupByExpression node)
 {
     return(node.Update(
                Visit(node.Source),
                Visit(node.Id),
                Visit(node.Accumulators)));
 }
 protected internal virtual Expression VisitCorrelatedGroupBy(CorrelatedGroupByExpression node)
 {
     return node.Update(
         Visit(node.Source),
         Visit(node.Id),
         Visit(node.Accumulators));
 }
        protected internal override Expression VisitCorrelatedGroupBy(CorrelatedGroupByExpression node)
        {
            if (_lookup != null && _lookup.Contains(node.CorrelationId))
            {
                var source = Visit(node.Source);
                var accumulators = new List<SerializationExpression>();
                var comparer = new ExpressionComparer();
                foreach (var correlatedAccumulator in _lookup[node.CorrelationId])
                {
                    var index = accumulators.FindIndex(x => comparer.Compare(x.Expression, correlatedAccumulator.Accumulator));

                    if (index == -1)
                    {
                        var serializer = _serializerRegistry.GetSerializer(correlatedAccumulator.Type);
                        var info = new BsonSerializationInfo(
                            "__agg" + accumulators.Count,
                            serializer,
                            serializer.ValueType);

                        var serializationExpression = new SerializationExpression(correlatedAccumulator.Accumulator, info);
                        accumulators.Add(serializationExpression);
                        _map[correlatedAccumulator] = serializationExpression;
                    }
                    else
                    {
                        _map[correlatedAccumulator] = accumulators[index];
                    }
                }

                node = node.Update(
                    source,
                    node.Id,
                    accumulators.OfType<Expression>());
            }

            return base.VisitCorrelatedGroupBy(node);
        }
        private void VisitCorrelatedGroupBy(CorrelatedGroupByExpression node)
        {
            Visit(node.Source);

            var group = new BsonDocument();
            group.Add("_id", AggregateLanguageTranslator.Translate(node.Id));

            foreach (var accumulator in node.Accumulators)
            {
                var serializationExpression = (SerializationExpression)accumulator;
                group.Add(
                    serializationExpression.SerializationInfo.ElementName,
                    AggregateLanguageTranslator.Translate(serializationExpression.Expression));
            }

            _stages.Add(new BsonDocument("$group", group));
        }