Dynamic aggregation

This feature is an another way to do aggregations and in contrast to Map-Reduce indexes, it allows to create much more complex queries. It gives you more options for reporting applications, dynamic selection and complex aggregation with additional filtering.

When working with a map/reduce index we are able to do only limited amount of queries. Let's imagine a sample SQL query:

select sum(Total) from Orders where Total > 500 group by Product

In order give you the ability to query like this, we introduced the dynamic aggregation feature. Thanks this you can build the following query:

FacetResults facetResults = session
	.Query<Order, Orders_All>()
	.Where(x => x.Total > 500)
	.AggregateBy(x => x.Product)
		.SumOn(x => x.Total)
	.ToList();

Assuming that your classes look like this:

public enum Currency
{
	EUR,
	USD
}

public class Order
{
	public double Total { get; set; }

	public string Product { get; set; }

	public Currency Currency { get; set; }
}

The Orders/All index used in the query is a simple map-only index. The only difference is that you have to specify sort options for numeric fields used in the query. This is needed for recognizing by RavenDB types of numeric fields when such a query will come in.

public class Orders_All : AbstractIndexCreationTask<Order>
{
	public Orders_All()
	{
		Map = orders => from order in orders
				select new
				{
					order.Total,
					order.Product,
					Concurrency = order.Currency
				};

		Sort(x => x.Total, SortOptions.Double);
	}
}

Extended faceted search

Under the covers this is a faceted search with an extended support for doing aggregations. For example you can aggregate ranges:

FacetResults facetResults = session.Query<Order, Orders_All>()
				.AggregateBy(x => x.Product)
				.AddRanges(
					x => x.Total < 100,
					x => x.Total >= 100 && x.Total < 500,
					x => x.Total >= 500 && x.Total < 1500,
					x => x.Total >= 1500
				)
				.SumOn(x => x.Total)
				.ToList();

It also supports an aggregation on multiple levels:

FacetResults facetResults = session.Query<Order, Orders_All>()
				.AggregateBy(x => x.Product)
					.SumOn(x => x.Total)
					.CountOn(x => x.Total)
				.AndAggregateOn(x => x.Currency)
					.MinOn(x => x.Total)
				.ToList();

Another example is an aggregation on different fields based on same facet:

FacetResults facetResults = session.Query<Order, Orders_All>()
				.AggregateBy(x => x.Product)
					.MaxOn(x => x.Total)
					.MinOn(x => x.Currency)
				.ToList();

Remarks