Develop Reference

Linq syntax to find subtotal of grouped rows in a DataTable and update the DataTable

I have been scratching my head about this one... I have a table in memory, a DataTable structured like this:
Input:
ID | Invoice | Account | Payment | Subtotal
-----------------------------------------------------------------
0 | 09310 | 123 | 6.0 | ?
-----------------------------------------------------------------
And I wish to use Linq to perform the following (I am pretty new to Linq!)
For each row that is for the same account, add together all the payments and write or update the subtotal field(s)
I do not want to collapse the table, the invoice numbers are going to be different. My thought is that there are two ways that this can be done
(A) start with a BLANK subtotal column for all records... the values from payment would be added together and then written into the subtotal column
(B) when table created, I DUPLICATE the payment values into the subtotal fields. Later, the linq would only have to add/replace the values in the same column
So we would ignore the ID and Invoice fields; its ACCOUNT and SUBTOTAL (and PAYMENT as well if using style (A))
(A) Input: *(note that there are two records for 123)*
ID | Invoice | Account | Payment | Subtotal
-----------------------------------------------------------------
0 | 03310 | 123 | 6.0 |
-----------------------------------------------------------------
1 | 09728 | 123 | 4.0 |
-----------------------------------------------------------------
2 | 07731 | 559 | 18.0 |
-----------------------------------------------------------------
 
(B) Input:
ID | Invoice | Account | Payment | Subtotal
-----------------------------------------------------------------
0 | 03310 | 123 | 6.0 | 6.0
-----------------------------------------------------------------
1 | 09728 | 123 | 4.0 | 4.0
-----------------------------------------------------------------
2 | 07731 | 559 | 18.0 | 18.0
-----------------------------------------------------------------
 
Result:
ID | Invoice | Account | Payment | Subtotal
-----------------------------------------------------------------
0 | 03310 | 123 | 6.0 | 10.0
-----------------------------------------------------------------
1 | 09728 | 123 | 4.0 | 10.0
-----------------------------------------------------------------
2 | 07731 | 559 | 18.0 | 18.0
-----------------------------------------------------------------
And so, each Subtotal cell would have the total of all PAYMENTS for each unique ACCOUNT
I am thinking that style (B) would be easier because we only have to deal with those two columns
For style (B), I have tried something like
rpTable.AsEnumerable().GroupBy(g => int.Parse(g.Field<string>("Account"))).Select(g => g.Sum(p => p.Field<decimal>("SubTotal")));
but I can tell its missing something.....hmmmm

By using Select, you will not update the table. This just returns an IEnumerable of the selected values.
What you want to do is add the column to the table and then fill it:
var subTotalByAccount = table.AsEnumerable()
.GroupBy(g => g.Field<string>("Account"))
.Select(g => new { Account = g.Key, SubTotal = g.Sum(p => p.Field<decimal>("Payment")) })
.ToDictionary(t => t.Account, t => t.SubTotal);
table.Columns.Add("SubTotal", typeof(decimal));
foreach (var row in table.AsEnumerable())
{
row.SetField(columnName: "SubTotal", value: subTotalByAccount[row.Field<string>("Account")]);
}

Thank you very much timcbaoth, yes I agree with what you said. I tried to upvote your post but the system says I may not :-(
I had figured it out (below) using brute force, but I will evaluate your solution as well! Thanks again!!
var query = from row in rpTable.AsEnumerable()
group row by int.Parse(row.Field<string>("Account")) into grp
orderby grp.Key
select new
{
Id = grp.Key,
Sum = grp.Sum(r => r.Field<decimal>("Payment"))
};
foreach (var grp in query)
{
rpTable.Select("Account ="+grp.Id).ToList<DataRow>().ForEach(r=>r["Payment"] = grp.Sum);
}

I found an insidious little bug, so FYI:
OLD: rpTable.Select("Account ="+grp.Id).ToList<DataRow>().ForEach(r=>r["Payment"] = grp.Sum);
NEW: rpTable.Select("Account ='"+ grp.Id +"'").ToList<DataRow>().ForEach(r => r["Payment"] = grp.Sum);

Convert SQL containing IN statement to chainable LINQ

I am trying to convert an MSSQL statement into LINQ. The overall functionality is broken up into many LINQ statements which are combined together, so the result must return type IQueryable.
Included in this question is an example of the schema and data. I am trying to see if the most recent (by DateCreated) value of Number is equal to 400, if so return the Table1Id.
The following is the MSSQL statement.
select * from Table1 t1
where 400 in (
select top 1 t2.Number
from Table2 t2
where t2.Table1Id = t1.id
order by t2.DateCreated desc
)
The LINQ I have come up with so far is:
//initial query
var query1 = _table1Repository.Table
//chain our query
var query2 = from t1 in query1
where ((from t2 in _table2Repository.Table
where t2.Table1Id == t1.Id
orderby t2.DateCreated descending
select t2.Number)
.Take(1)).Contains(400)
select t1;
//execute the query (may be more queries between last query and this)
var queryResult = query2.ToList();
Though upon executing the following error is thrown:
Unable to create a constant value of type 'Project.Domain.Table2'. Only primitive types or enumeration types are supported in this context.
Table 1 data
| Id |
|----|
| 1 |
| 2 |
| 3 |
Table 2 data
| Id | DateCreated | Table1Id | Number |
|----|------------ |-----------|---------|
| 1 | 1/1/2014 | 1 | 100 |
| 2 | 2/1/2014 | 1 | 200 |
| 3 | 3/1/2014 | 1 | 300 |
| 4 | 1/1/2014 | 2 | 200 |
| 5 | 2/1/2014 | 2 | 300 |
| 6 | 3/1/2014 | 2 | 400 |
| 7 | 1/1/2014 | 3 | 400 |
| 8 | 2/1/2014 | 3 | 300 |
| 9 | 3/1/2014 | 3 | 200 |
Expected result
| Id |
|----|
| 2 |

Assuming you still want to use the In keyword, the Lambda version would look like:
var intList = new List<int>(1) { 400 };
var test = _table1Repository.Table
.Where(t1 => intList.Contains(_table2Repository.Table
.Where(t2 => t2.Table1Id == t1.id)
.OrderByDescending(t2 => t2.Number)
.First()));
The only Caveat is that if there are no values in Table2, First() with throw an exception.
An example of mix'd Linq and Lambda:
var query1 = _table1Repository.Table
.OrderBy(t1 => t1.id);
var query2 = (from t1 in query1
select new { Id = t1.Id, Number = number } );
var query3 = query2.ToList();

Combine datatables with specific conditions

UPDATED: Forgot to mention, the table may contain more than one type of itemcode
I've got a problem for datatable. There're total 14 items with same itemcode. And now there're 2 tables come from different source. One is grouped by itemcode and sum up the quantity, when count equals to 10, go to next row, and each row contains specific information such as shipment and remarks. Another table contains more detail information.
Source1: Grouped table
ItemCode|TotalQty|Shipment|Remarks|Line
=========================================
ITEM01 | 1000 | S001 | R001 | 1 <==10 items here
ITEM01 | 400 | S002 | R002 | 2 <==4 items here
Source2: Detail table (14 items & rows)
RefNo|ItemCode|Quantity|Weight|From
=======================================
R001 | ITEM01 | 100 | 50 | US
R002 | ITEM01 | 100 | 50 | US
R003 | ITEM01 | 100 | 50 | US
. | . | . | . | .
. | . | . | . | .
R013 | ITEM01 | 100 | 50 | US
R014 | ITEM01 | 100 | 50 | US
I would like to combine source1 and source2 and get the result as below
Shipment|Line|Remarks|ItemCode|TotalQty|RefNo|Quantity|Weight|From
===================================================================
S001 | 1 | R001 | ITEM01 | 1000 | R001| 100 | 50 | US \\1
S001 | 1 | R001 | ITEM01 | 1000 | R002| 100 | 50 | US \\2
S001 | 1 | R001 | ITEM01 | 1000 | R003| 100 | 50 | US \\3
S001 | 1 | R001 | ITEM01 | 1000 | R004| 100 | 50 | US \\4
S001 | 1 | R001 | ITEM01 | 1000 | R005| 100 | 50 | US \\5
S001 | 1 | R001 | ITEM01 | 1000 | R006| 100 | 50 | US \\6
S001 | 1 | R001 | ITEM01 | 1000 | R007| 100 | 50 | US \\7
S001 | 1 | R001 | ITEM01 | 1000 | R008| 100 | 50 | US \\8
S001 | 1 | R001 | ITEM01 | 1000 | R009| 100 | 50 | US \\9
S001 | 1 | R001 | ITEM01 | 1000 | R010| 100 | 50 | US \\10
S002 | 2 | R002 | ITEM01 | 400 | R011| 100 | 50 | US \\11
S002 | 2 | R002 | ITEM01 | 400 | R012| 100 | 50 | US \\12
S002 | 2 | R002 | ITEM01 | 400 | R013| 100 | 50 | US \\13
S002 | 2 | R002 | ITEM01 | 400 | R014| 100 | 50 | US \\14
Is there any way (Linq or looping) to get the above result? Thanks for your help!

It can be done with LINQ (which I assume you're after, since you've included the LINQ tag), but not in what I would consider a nice fashion.
Given two DataTable objects with the above formats and data, named grouped and detail, here's a LINQ expression that will stitch the data together in the way you want:
IEnumerable<object[]> qry =
(
from DataRow rDetail in detail.Rows
let dgrp = detail.Rows.IndexOf(rDetail) / 10
join DataRow rGroup in grouped.Rows
on dgrp equals grouped.Rows.IndexOf(rGroup)
orderby rDetail["RefNo"]
select new object[] {
rGroup["Shipment"], rGroup["Line"], rGroup["Remarks"], rGroup["ItemCode"], rGroup["TotalQty"],
rDetail["RefNo"], rDetail["Quantity"], rDetail["Weight"], rDetail["From"]
}
);
Now you need another DataTable to pump those results into:
DataTable res = new DataTable();
res.Columns.Add("Shipment", typeof(string));
res.Columns.Add("Line", typeof(Int32));
res.Columns.Add("Remarks", typeof(string));
res.Columns.Add("ItemCode", typeof(string));
res.Columns.Add("TotalQty", typeof(Int32));
res.Columns.Add("RefNo", typeof(string));
res.Columns.Add("Quantity", typeof(Int32));
res.Columns.Add("Weight", typeof(Int32));
res.Columns.Add("From", typeof(string));
And finally, fill the res table with the results of the LINQ query:
foreach (object[] rowdata in qry)
res.Rows.Add(rowdata);
The code above works for this specific set of data, but I can't promise you anything more than that. It is heavily dependent on the row order in the source tables, and because I'm using DataTable.Rows.IndexOf to get the order it's quite possible that this will be terribly slow on large collections of data.
But then you're already using DataTables instead of a properly typed collection, so all bets are off in the performance- and code-sanity stakes anyway.
This is one case where I'd suggest not using LINQ to perform the task. IMHO this would be better done as an iterative loop rather than a query. You don't get much (if any) improvement over the iterative version, you lose a lot of clarity, and you have all sorts of fun getting things set up just right before you can use it.
And because I can't leave well-enough alone, here's a full (long, lots of code) solution using a combination of LINQ, classes to hold the data being processed and iteration to generate the table:
public DataTable MergeShippingData(DataTable groupTable, DataTable detailTable)
{
// convert group table to array of GroupEntry objects
var groupList =
(
from DataRow grouprow in groupTable.Rows
let ent = GroupEntry.FromRow(grouprow)
where ent != null
select ent
).ToArray();
// convert detail table to sequence of DetailEntry objects
var detailSeq =
from DataRow detailrow in detailTable.Rows
let ent = DetailEntry.FromRow(detailrow)
where ent != null
select ent;
// Create output DataTable
DataTable output = CreateOutputTable();
// Process all detail lines into shippings
foreach (var detail in detailSeq)
{
// Find available shipping group for the item code with enough remaining capacity
var grp = groupList.First (g => g.ItemCode == detail.ItemCode && g.Remainder >= detail.Quantity);
if (grp == null)
throw new Exception("No available shipping found for detail item...");
// update remaining space in shipping group
grp.Remainder -= detail.Quantity;
// add data to output table
output.Rows.Add(new object[] {
grp.Shipment, grp.Line, grp.Remarks, grp.ItemCode, grp.TotalQty,
detail.RefNo, detail.Quantity, detail.Weight, detail.From
});
}
return output;
}
// Class to hold the shipping groups while processing
public class GroupEntry
{
// fields from source DataTable
public string ItemCode;
public int TotalQty;
public string Shipment;
public string Remarks;
public int Line;
// process variable, holds remaining quantity value
public int Remainder;
// Convert DataRow into GroupEntry
public static GroupEntry FromRow(DataRow r)
{
try
{
return new GroupEntry
{
ItemCode = r.Field<string>(0),
TotalQty = r.Field<int>(1),
Shipment = r.Field<string>(2),
Remarks = r.Field<string>(3),
Line = r.Field<int>(4),
Remainder = r.Field<int>(1)
};
}
catch { }
return null;
}
}
// Class to hold shipping Detail records during processing
public class DetailEntry
{
public string RefNo;
public string ItemCode;
public int Quantity;
public int Weight;
public string From;
// Convert DataRow into DetailEntry
public static DetailEntry FromRow(DataRow r)
{
try
{
return new DetailEntry
{
RefNo = r.Field<string>(0),
ItemCode = r.Field<string>(1),
Quantity = r.Field<int>(2),
Weight = r.Field<int>(3),
From = r.Field<string>(4)
};
}
catch { }
return null;
}
}
// Create output DataTable
public DataTable CreateOutputTable()
{
DataTable res = new DataTable();
res.Columns.Add("Shipment", typeof(string));
res.Columns.Add("Line", typeof(Int32));
res.Columns.Add("Remarks", typeof(string));
res.Columns.Add("ItemCode", typeof(string));
res.Columns.Add("TotalQty", typeof(Int32));
res.Columns.Add("RefNo", typeof(string));
res.Columns.Add("Quantity", typeof(Int32));
res.Columns.Add("Weight", typeof(Int32));
res.Columns.Add("From", typeof(string));
return res;
}
Add some error handling and you're good to go.

linq query sum products across multiple collections

I have two datasets that look like this:
+------------------------------------+
| Products |
+------------------------------------+
| Id | Name | Price |
+------------------------------------+
| 1 | apples | 1.00 |
| 2 | oranges | 2.00 |
| 3 | pomengrate | 3.00 |
+------------------------------------+
+-------------------------------+
| Sales |
+-------------------------------+
| CustId | ProductId | Quantity |
+-------------------------------+
| 1 | 1 | 5 |
| 1 | 2 | 4 |
| 1 | 3 | 2 |
| 2 | 1 | 8 |
| 2 | 3 | 7 |
+-------------------------------+
I want to get the amount that each customer is spending, essentially ending up with a result like this:
+----------------+
| CustId | Total |
+----------------+
| 1 | 19.00 |
| 2 | 29.00 |
+----------------+
I can do a sum across a single table but the Sum method in LINQ takes a lambda with only one argument: the reference to the table that the values being summed are in. These values are in different tables. How do I sum these together?

var totals =
from sale in Sales
group sale by sale.CustId into custSales
select new
{
CustId = custSales.Key,
Total = (
from custSale in custSales
select custSale.Product.Price *
custSale.Quantity)
.Sum()
};

Give this a shot. It gives the results you were looking for:
var results = sales.Join(products,
sale => sale.ProductID,
product => product.ID,
(sale, product) => new { CustID = sale.CustID, Total = sale.Quantity * product.Price })
.GroupBy(r => r.CustID)
.Select(g => new { CustID = g.Key, Total = g.Sum(gt => gt.Total) });

For completeness sake, here's the query syntax version (utilizing joins as opposed to a subselect):
var totals =
from sale in sales
join prod in product on sale.ProductId equals prod.Id
let saleProds = new { sale.CustId, Total = prod.Price * sale.Quantity }
group saleProds by saleProds.CustId into custSale
select new { Customer = custSale.Key, Total = custSale.Sum(tr => tr.Total) };
The key part is that you need to somehow transform the joined collection results (sale and prod) into a single entity that can then be grouped by.

Query tabels to sort sums across rows and count based on a value in LINQ

Here is my problem. i have 3-5 persons that is going to set a grade on one person and they use their own individual row to do so, and what I'm having trouble to do is to sum and average the grade from individual data across multiple rows on the same table.
in the select new statement i have made a pseudo answer of what i want
var users = from workRew in db.Reviews
select new
{
UserID = workRew.UserID.DistinctOfSomeSort
AvgGrade = workRew.Grade.Sum/CountOfSomeSort
};
Here i a illustration.
So if i have this table
| SomeID | UserID | Grade |
| 1 | 2 | 3 |
| 2 | 3 | 1 |
| 3 | 2 | 1 |
And this is the output i want from the LINQ query on the above (In theory ateast)
| UserID | AvgGrade |
| 2 | 2 |
| 3 | 1 |
EDIT: Simplified the whole case, to a great extent.

It should look something like this fragment:
group by user.UserID
select new
{
User = user.UserID
TotGradeCount = workRew.Grade.Sum()
Graders = workRew.Grade.Count()
}