New features in Dynamic Data Store (DDS)

Working on the “LinqToDDS” project is the most fun I’ve ever had at work. Therefore, it’s a pleasure to announce new LINQ support in the R2 wave.

Earlier we only supported the deferred execution methods “ToList()”, “ToArray”, “ToDictionary”, “ToLookup”, and “Count”. In the R2 wave, we have added the support for “First”, “FirstAndDefault”, “Single”, “SingleOrDefault”, “Last”, and “LastOrDefault”. We have also added support for multiple group by, “contains” on .Net collections, and predicate support on “count”.

Single object support

When developers used the LINQ support to query DDS for only one object, they had to make a query like “.ToList().First()”. This isn’t only ugly, it’s also inefficient. This query receives all identities matching the query, and puts them into memory. Then it takes the first item from memory, and query the database for the inline properties for that item (if the object is in the cache, it will be received from the cache).

Now, we’ve added support for “First”, “FirstOrDefault”, “Single”, “SingleOrDefault”, “Last”, and “LastOrDefault”. All of those both with and without predicates.

Fist and Last

When making a query directly against “First” (same with “Last”), the database will only receive the inline properties for the first/last object matching the query, and therefore we have everything needed to recreate the object for you.

Single

When making a query against “Single” we will do the same as for “First” and “Last”, but we will try to receive the two first objects matching the query instead of one. If we receive two objects, we throw an exception, because this is what you should used “Single” for.

Defaults

When using “FirstOrDefault”, SingleOrDefault”, or “LastOrDefault”, we will return default(T) if the query didn’t receive any result from the database. For “First”, “Single”, and “Last” an exception will be thrown if no result was received.

Multiple group by support

Earlier we only had support for grouping on one property. This could be a problem if you for example want to sum number of visits on a page for a specified group. Than, page and group should be grouped to get sum of visits for the rows where page and group are the same.

Now, this is possible. A query could look like:

var groupedQuery = GetStore().Items<MyClass>()

.GroupBy(myClass => new { Page = myClass.PageId, Group = myClass.AccessGroup })

.Select(grouped => new { Page = grouped.Key.Page, Group = grouped.Key.Group, Hits = grouped.Sum(s => s.Visits) });

Contains on .Net Collection

If you have a .Net list and wants to check if a property in the DDS has the same value as any of the items in the list, we now have support for that.

var myList = new List<string>();

myList.Add("Jonas");

myList.Add("Erik");

myList.Add("Per");

var query = GetStore().Items<MyClass>()

.Where(p => myList.Contains(p.FirstName));

Count with predicate

In the earlier versions, it wasn’t possible to use predicates in the “Count” deferrer. This is now fixed.

var query = GetStore().Items<MyClass>().Count(p => p.LastName == "Bergqvist");