Непроходимый, где предложения LINQ-to-SQL

Question

Поскольку я изо всех сил пытаюсь изучить LINQ, мне удалось сгенерировать оператор SQL с «AND (0 = 1)» как часть предложения where. Мне просто интересно, распространен ли этот результат в плохо написанных запросах и это известные проблемы, которых следует избегать, или я делаю что-то совершенно обратное, чтобы закончить с этим.

---

Обновление

public static IEnumerable<ticket> GetTickets(stDataContext db,string subgroup, bool? active)
    {
        var results = from p in db.tickets
               where 
                   ( active == null || p.active == active ) 
                   /*(active == null ? true :
                   ((bool)active ? p.active : !p.active))*/ &&
                   p.sub_unit == db.sub_units.Where(c=>subgroup.Contains(c.sub_unit_name))
               select p;
        return results;
    }

Если я игнорирую активную часть и просто запускаю

public static IEnumerable<ticket> GetTickets1(stDataContext db,string subgroup, bool? active)
    {
        return db.tickets.Where(c => c.sub_unit.sub_unit_name == subgroup);
    }

Возвращает группы заявок, которые я хочу игнорировать активную часть.

Answer 1

Это довольно серьезное злоупотребление троичным оператором.

Это выражение:

(active == null ? true :
    ((bool)active ? p.active : !p.active))

эквивалентно следующей логике:

bool result;
if (active == null)
{
    result = true;
}
else
{
    if ((bool)active)
    {
        result = p.active;
    }
    else
    {
        result = !p.active;
    }
}
result &= ...

Подумайте внимательноо том, что это делает:

• Если active равно null, все в порядке, оно переходит к следующему условию.
• Если active равно true, result равно true в конце условного.
• Если active равно false, result равно false в конце условного.

В последнем случае запрос никогда не сможет вернуть ни одной строки!

@ Tanzelax уже предоставил простое переписывание.Основная идея заключается в том, что вы хотите сравнить p.active с active, а не оценивать условие как p.active.

Answer 2

Я бы вытащил обработку из троичных операторов.

where ( active == null || p.active == active )

EDIT

Остальная часть предложения where тоже выглядит странно ... почему она не просто

&& p.sub_unit.sub_unit_name == subgroup

или

&& subgroup.Contains(p.sub_unit.sub_unit_name)

Answer 3

Это, вероятно, вызвано нулевым значением в одном из столбцов, которые вы объявили как необнуляемые. LINQ2SQL делает все столбцы необнуляемыми по умолчанию. Вернитесь к конструктору и измените поля, чтобы значения могли быть нулевыми. К сожалению, эта функция является По типу (см. Ссылку connect.microsoft.com ниже.)

(linq) неверный sql, сгенерированный для row.column == localVar, когда localVar имеет значение null (должно быть проверено "is null")