linq-to-sql group by连接表中的字符串列表

Question

I have a DB table [Table1] with a one to many relationship.
This related table [Table2] has a type field which is a string.

Table 1          Table 2
Field | Type     Field    | Type
------|-----     ---------|-----
Id    | int      Id       | int
                 Table1Id | int
                 Type     | string

I am trying to create a summary of how often each combination of types occurs, and am attempting to do as much work on the DB as possible as it is too slow to bring it all into memory.

The code I have works but seems repetitive to me.

        items
        .Where(x => x.Table2s.Count > 1)
        .Select(x => new
        {
            Type = x.Table2s.Select(y => y.Type)
        })
        .ToList() // into memory as string.join has no translation into sql
        .Select(x => new
        {
            Type = string.Join(",", x.Type) // no sql translation
        })
        .GroupBy(x => x.Type) // can't work on IEnumerable[string]
        .Select(x => new Result()
        {
            Type = x.Key,
            Count = x.Count()
        })
        .OrderByDescending(x => x.Count)
        .ToList();

Is there a way to group by this list of strings so that I can do the grouping on the DB and also reduce the number of select statements in my code

Answer 1

Linq to SQL doesn't support Aggregate or String.Join or corresponding SQL tricks, so unless you want to use a stored procedure, some of the work has to happen on the client side.

One alternative would be to create the groupings first and then send them back to the server to count the matches, but that doesn't seem like a gain.

I think the best you can do is something like

var sqlans = items.Where(x => x.Table2s.Count > 0).AsEnumerable();
var ans = sqlans.Select(x => String.Join(",", x.Table2s.Select(t2 => t2.Type).OrderBy(ty => ty).ToArray())).GroupBy(ty => ty, ty => ty, (key, g) => new { key, Count = g.Count() });

I ordered the Type s belonging to an item so they would match up when grouped. The sqlans portion would be executed by the server, but the rest has to execute on the client to process the String.Join .

Instead of using EF I would be tempted to work on Table2 (doing left semi join if you might have orphan Table2 entries) directly

var sqlans = Table2.GroupBy(t2 => t2.Table1Id, t2 => t2.Type, (key, g) => g).AsEnumerable();
var ans = sqlans.Select(x => String.Join(",", x.OrderBy(ty => ty).ToArray())).GroupBy(ty => ty, ty => ty, (key, g) => new { key, Count = g.Count() });