Linq to SQL慢查询

Question

My ASP.Net application has the following Linq to SQL function to get a distinct list of height values from the product table.

public static List<string> getHeightList(string catID)
        {
            using (CategoriesClassesDataContext db = new CategoriesClassesDataContext())
            {    
                var heightTable = (from p in db.Products
                                   join cp in db.CatProducts on p.ProductID equals cp.ProductID
                                   where p.Enabled == true && (p.CaseOnly == null || p.CaseOnly == false) && cp.CatID == catID
                                   select new { Height = p.Height, sort = Convert.ToDecimal(p.Height.Replace("\"", "")) }).Distinct().OrderBy(s => s.sort);

                List<string> heightList = new List<string>();

                foreach (var s in heightTable)
                {
                    heightList.Add(s.Height.ToString());
                }

                return heightList;
            }
        }

I ran Redgate SQL Monitor which shows that this query is using a lot of resources.

Redgate is also showing that I am running the following query:

select count(distinct [height]) from product p 
join catproduct cp on p.productid = cp.productid 
join cat c on cp.catid = c.catid 
where  p.enabled=1 and p.displayfilter = 1 and c.catid = 'C2-14'

My questions are:

1. A suggestion to change the function so that it uses less resources?
2. Also, how does linq to sql generate the above query from my function? (I did not write select count(distinct [height]) from product anywhere in the code)

There are 90,000 records in the products. This category which I am trying to get the distinct list of heights has 50,000 product records

Thank you in advance,

Nick

Answer 1

First of all your posted sql query and linq query doesn't match at all. it's not the LINQ query rather the underlying SQL query itself performing slow. Make sure, all the columns involved in JOIN ON clause and WHERE clause and ORDER BY clause are indexed properly in order to have a better execution plan; else you will end up getting a FULL Table Scan and a File Sort and query will deemed to perform slow.

Answer 2

The join multiplies the number of Product s the query returns. To undo that, you apply Distinct at the end. It will certainly reduce db resources if you return unique Product s right away:

var heightTable = (from p in db.Products
                   where p.CatProducts.Any(cp => cp.CatID == catID)
                      && p.Enabled && (p.CaseOnly == null || !p.CaseOnly)
                   select new 
                          {
                              Height = p.Height, 
                              sort = Convert.ToDecimal(p.Height.Replace("\"", ""))
                          }).OrderBy(s => s.sort);

This changes the join into a where clause. It saves the db engine the trouble of deduplicating the result.

If that still performs poorly, you should try to do the conversion and ordering in memory, ie after receiving the raw results from the database.

As for the count. I don't know where it comes from. Such queries typically get generated by paging libraries such as PagedList, but I see no trace of that in your code.

Side note: you can return ...

heightList.Select(x => x.Height.ToString()).ToList()

... instead of creating the list yourself.