Большое удобство составления запросов в строку в том, что можно динамически добавлять условия и собственно генерировать логику отбора в рантайме, так можно поступать и с LINQ, причем дополнительные условия можно накладывать не в виде вызова методов, а так же – декларативно.
При этом для уточнения условий отбора нужно просто выполнить запрос к запросу. Благодаря тому, что запрос выполняется не сразу, а в момент обращения к его результату – будет выполнено уточнение начального запроса. Если при этом тип возвращаемого результата остается тем же (выбираем тот же тип данных), то запрос можно присвоить той же переменной.
Для примера создадим в MS-SQL таблицу Test со столбцом Value типа int и ts типа TimeStamp (чтобы полей было всё же больше, чем те, с которыми нужно работать). Нам нужно выбрать из этой таблицы все четные значения больше 5, отсортированные по возрастанию.
Это можно написать в обычном запросе вот так:
var q = from item in DB.tests
where item.value % 2 == 0 && item.value > 5
orderby item.value
select item.value;
При этом мы получим IEnumerable<int> и в базу отправится запросexec sp_executesql N'SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
WHERE (([t0].[value] % @p0) = @p1) AND ([t0].[value] > @p2)
ORDER BY [t0].[value]',N'@p0 int,@p1 int,@p2 int',@p0=2,@p1=0,@p2=5
Это хорошо и удобно, но бывает что нужно уточнять параметры запроса в зависимости от каких-то условий или добавлять условия в цикле или что-то похожее, обычно это делается при формировании запроса в виде строки:
string query = "SELECT value FROM Test WHERE (1=1)";
query += " AND (Test.Value % 2 = 0@)";
if (flag)
query += " AND (Test.Value > 5)";
query += " ORDER BY Test.Value";Такую же гибкость предоставляет и LINQ, при осуществлении запроса к запросу. Сделаем тот же самый запрос на LINQ в несколько шагов:
1. Выберем базовый набор элементов с которыми хотим работать, пусть это будут вся таблица Test
var q = from item in DB.tests
select item;Это преобразуется в запрос
SELECT [t0].[value], [t0].[ts]
FROM [dbo].[test] AS [t0]
2. Но поскольку к результатам запроса мы еще не обращаемся, то к БД он не отправлен, уточняем наш запрос:
q = from item in q
where item.value % 2 == 0
select item;Мы добавили условие четности и запрос соответственно уточнился:
SELECT [t0].[value], [t0].[ts]
FROM [dbo].[test] AS [t0]
WHERE ([t0].[value] % @p0) = @p1
Теперь уточним запрос, т.к. мы хотим работать только со столбцом value – выбираем его.
var nums = from num in q
select num.value;3. Запрос уточняется до
SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
т.е. если запросить данные сейчас, то выберется уже только один столбец, а не вся таблица. Но суть даже не в этом – раз мы выбрали только один целочисленный столбец мы теперь и работаем с ним просто как с коллекцией целых чилел. Обратите внимание – у нас поменялся тип результата – вместо всех столбцов мы выбираем только один, поэтому нам нужна новая переменная (используется новый тип данных)
4. Выбираем из них четные:
nums = from num in nums
where num % 2 == 0
select num;и запрос снова уточняется:
SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
WHERE ([t0].[value] % @p0) = @p1
Здесь и дальше мы уже работает только с коллекцией int’ов, так что используем ту же самую переменную.
5. Теперь уточняем запрос в зависимости от какого-то нашего условия:
if (flag)
nums = from num in nums
where num > 5
select num;У меня влаг выставлен в true, поэтому условие уточняется:
SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
WHERE ([t0].[value] > @p0) AND (([t0].[value] % @p1) = @p2)
6. Сортируем полученный результат:
nums = from num in nums
orderby num
select num;Запрос еще раз уточняется:
SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
WHERE ([t0].[value] > @p0) AND (([t0].[value] % @p1) = @p2)
ORDER BY [t0].[value]
И наконец обращаемся к результату:
foreach (var num in nums)
Console.WriteLine(num);
Согласно SQL Profiler’у туда пришел запрос:
exec sp_executesql N'SELECT [t0].[value]
FROM [dbo].[test] AS [t0]
WHERE ([t0].[value] > @p0) AND (([t0].[value] % @p1) = @p2)
ORDER BY [t0].[value]',N'@p0 int,@p1 int,@p2 int',@p0=5,@p1=2,@p2=0
Запрос совершенно эквивалентные, отличаются только порядком условий в AND.
В чем плюсы такого подхода?
1. Мы работает с типизированной коллекцией того что нам нужно (контроль опечаток на стадии компиляции, автодополнения и т.п.)
2. Можем уточнять и добавлять новые условия запроса в зависимости от каких-то внешних условий, так же как при формировании запроса в виде строки.
3. Каждое уточнение выглядит человеко-читабельно: из уже выбраного выбираем то, что соответствует новому условию или условиям (можно доабвлять произвольное количество условий за раз).
4. Не смотря на такую конструкцию - запрос к запросу - реально в базу отправляется только один результирующий запрос, учитывающий сразу все условия, что собственно нам и нужно.
5. Можно писать условия отбора в человеческом порядке на человеческом языке, так что это потом будет просто понять и исправить (пример приведен ниже)
P.S. После написания поста стало интересно попробовать – а что если нам нужно будет выбрать из той же таблицы четные числа больше 5, но только среди чисел, которые идут с 5-го по 25-й если их отсортировать. Т.е. при переводе на русский это получается так:
Отсортировать числа в столбце value по возрастанию, взять из них элементы с 5-го по 25-й включительно и среди них выбрать четные числа больше 5.
Написал такой кусок кода:
var nums = from item in DB.tests
orderby item.value
select item.value;
nums = nums.Skip(4).Take(21);
nums = from num in nums
where num % 2 == 0 && num > 5
select num;
foreach (var num in nums)
Console.WriteLine(num);из чего сгенерировался запрос:
exec sp_executesql N'SELECT [t2].[value]
FROM (
SELECT [t1].[value], [t1].[ROW_NUMBER]
FROM (
SELECT ROW_NUMBER() OVER (ORDER BY [t0].[value]) AS [ROW_NUMBER], [t0].[value]
FROM [dbo].[test] AS [t0]
) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p0 + 1 AND @p0 + @p1
) AS [t2]
WHERE (([t2].[value] % @p2) = @p3) AND ([t2].[value] > @p4)
ORDER BY [t2].[ROW_NUMBER]',N'@p0 int,@p1 int,@p2 int,@p3 int,@p4 int',@p0=4,@p1=21,@p2=2,@p3=0,@p4=5
Вот фиг бы я такой запрос вручную написал, да если и написал бы, то не слишком он читабельный и правибельный, в LINQ как-то проще.
