Как лучше оформлять несколько условий в select where?

[mazzy]

***** опрос пересоздан Как лучше оформлять несколько условий в select where? Повторная попытка *****


В коде часто встречаются select c несколькими условиями.
Вариант 1. (после условия)

    select firstonly paymentTrans
        where paymentTrans.AccountNum            == factureJour.CustVendInvoiceAccount &&
              paymentTrans.Voucher               == factureJour.Voucher                &&
              paymentTrans.CurrencyCode          == factureJour.CurrencyCode           &&
              paymentTrans.PrepaymentFactureId_W == factureJour.FactureId              &&
              paymentTrans.Prepayment            == NoYes::Yes;

Вариант 2. (до условия)

    select firstonly paymentTrans
        where paymentTrans.AccountNum            == factureJour.CustVendInvoiceAccount
           && paymentTrans.Voucher               == factureJour.Voucher
           && paymentTrans.CurrencyCode          == factureJour.CurrencyCode
           && paymentTrans.PrepaymentFactureId_W == factureJour.FactureId
           && paymentTrans.Prepayment            == NoYes::Yes;

Как вы предпочитаете ставить операторы между условиями?
Перед условием или после условия?
Почему?

А в более сложны случаях? Например,

    while select bankClientPayment_RU
    where bankClientPayment_RU.RContractAccount
    notexists join RContractTable
    where (
              ( RContractTable.RContractPartnerType == RContractPartnerType::Cust
             && BankClientPayment_RU.PartnerType == ModuleCustVend::Cust )
           || ( RContractTable.RContractPartnerType == RContractPartnerType::Vend
             && BankClientPayment_RU.PartnerType == ModuleCustVend::Vend )
          )
       && RContractTable.RContractAccount == bankClientPayment_RU.RContractAccount
       && RContractTable.RContractCode == bankClientPayment_RU.RContractCode

Добавлено: понятно, что при правке существующих select'ов скорее всего будете оставлять так как есть. Вопрос как вы предпочитаете, когда сами создаете select'ы

[samolalex]

Предпочитаю вариант 2:

    select firstonly paymentTrans
        where paymentTrans.AccountNum            == factureJour.CustVendInvoiceAccount
           && paymentTrans.Voucher               == factureJour.Voucher
           && paymentTrans.CurrencyCode          == factureJour.CurrencyCode
           && paymentTrans.PrepaymentFactureId_W == factureJour.FactureId
           && paymentTrans.Prepayment            == NoYes::Yes;

Использую данное оформление в силу таких факторов:
1) Более высокая читабельность кода;
2) Знаки && в начале каждого нового условия говорят о том, что данное условие является продолжением одного большого условия. Если же они стоят в конце, как в 1-м варианте, то снижается наглядность соединения условий. Данную привычку выработал, после прочтения книги Стива Макконелла "Секреты совершенного кода".

Третий пример я бы, скорее всего, оформил так:

while select bankClientPayment_RU
    where bankClientPayment_RU.RContractAccount
        notexists join RContractTable
            where ((RContractTable.RContractPartnerType == RContractPartnerType::Cust
                        && BankClientPayment_RU.PartnerType == ModuleCustVend::Cust)
                    ||(RContractTable.RContractPartnerType == RContractPartnerType::Vend
                        && BankClientPayment_RU.PartnerType == ModuleCustVend::Vend))
                  && RContractTable.RContractAccount == bankClientPayment_RU.RContractAccount
                  && RContractTable.RContractCode == bankClientPayment_RU.RContractCode

[pitersky]

Одно время ставил оператора в конце строки. Потом от этого отказался. Причина - добавление в select нового условия (или коммент старого) делать удобнее, если мы в той же строке указываем и оператор добавления. Иначе говоря, оператор после условия логически относится не к той строке, в которой он стоит, а к следующей.
Хотя эстетически первый вариант смотрится красивее

[mazzy]

Цитата:

Сообщение от pitersky

Хотя эстетически первый вариант смотрится красивее

а почему?

[Lucky13]

Второй вариант, так как так нагляднее. В таком случае соблюдается правило Оператор <Условие>. Например,
Where <Условие>
And <Условие>
And <Условие>
....
и видна некоторая законченная структура. А еще чем-то напоминает LINQ. В более сложных случаях еще стараюсь скобки оставлять на отдельной строке - помогает при отладке, когда приходится комментровать условия

[S.Kuskov]

Ответил: "после условия", но обосновать причину не могу. Привычка эта вырабаталась уже давно, теперь пишу на задумываясь. В сложных случаях могу позвольть себе вынести оператор вообще на отдельную строку. Например так:

    while select bankClientPayment_RU
    where
        bankClientPayment_RU.RContractAccount != ""
    notexists join RContractTable
    where
        RContractTable.RContractAccount == bankClientPayment_RU.RContractAccount && 
        RContractTable.RContractCode == bankClientPayment_RU.RContractCode &&
        (
            (
                RContractTable.RContractPartnerType == RContractPartnerType::Cust &&
                BankClientPayment_RU.PartnerType == ModuleCustVend::Cust
            )
            || 
            ( 
                RContractTable.RContractPartnerType == RContractPartnerType::Vend &&
                BankClientPayment_RU.PartnerType == ModuleCustVend::Vend 
            )
        )

Upd: Попытался сейчас записать условия по другому (оператором вперёд). Понял как минимум одну из причину, почему я так не делаю. А также почему я привык оставлять ключевое слово where на отдельной строке. Все дело в табуляции. Я стараюсь по возможности как можно реже пользоваться пробелами для создания отступов. А при таком способе записи (оператором вперёд) для выравнивания условий приходится делать отступы не кратные четырём пробелам, либо не естественным образом выравнивать первую строку, подгоняя её под остальные.

[mazzy]

Цитата:

Сообщение от S.Kuskov

Ответил: "после условия", но обосновать причину не могу.

Насколько я вижу, вы не выравниваете операторы справа. так?
как относитесь к выравниванию? тратите ли время на выравнивание?
(см. вариант 1 в исходном сообщении)

[S.Kuskov]

Цитата:

Сообщение от mazzy

Насколько я вижу, вы не выравниваете операторы справа. так?
как относитесь к выравниванию? тратите ли время на выравнивание?
(см. вариант 1 в исходном сообщении)

Если в подряд идёт более двух однотипных условий, то стараюсь выравнивать

[Dron AKA andy]

Использую второй вариант. Причины совпадают с изложенными первыми 3мя ответившими.

[oip]

Привычный - первый вариант. Более удобный дла добавления новых условий - наверное второй. Использую - обычно первый. По причине того, что именно он чаще используется в стандартном приложении.

Сложный запрос написал бы как-то так:

    while select bankClientPayment_RU
        where bankClientPayment_RU.RContractAccount
        notexists join RContractTable
        where ((RContractTable.RContractPartnerType == RContractPartnerType::Cust &&
                BankClientPayment_RU.PartnerType    == ModuleCustVend::Cust)
               ||
               (RContractTable.RContractPartnerType == RContractPartnerType::Vend &&
                BankClientPayment_RU.PartnerType    == ModuleCustVend::Vend))
               && 
               RContractTable.RContractAccount == bankClientPayment_RU.RContractAccount
               && 
               RContractTable.RContractCode    == bankClientPayment_RU.RContractCode

Скобочки на отдельные строки выносить не люблю, получается слишком громоздко.

Цитата:

Сообщение от mazzy

тратите ли время на выравнивание?

Да!

[Владимир Максимов]

Тоже выношу оператор условия в начало строки.

where (...)
AND (...)
AND (...)

Причины те же:

1. Наглядность (для меня)
2. Удобство добавления/удаления условий

Трачу время на выравнивание для повышения наглядности кода.

Для сложного условия постараюсь визуально выделить "не очевидные" операторы сравнения

    while select bankClientPayment_RU
        where bankClientPayment_RU.RContractAccount
        notexists join RContractTable
        where (
                (   RContractTable.RContractPartnerType == RContractPartnerType::Cust
                    && BankClientPayment_RU.PartnerType == ModuleCustVend::Cust)
                ||
                (   RContractTable.RContractPartnerType == RContractPartnerType::Vend
                    && BankClientPayment_RU.PartnerType == ModuleCustVend::Vend)
              )
           && RContractTable.RContractAccount   == bankClientPayment_RU.RContractAccount
           && RContractTable.RContractCode      == bankClientPayment_RU.RContractCode

То же самое делаю с математическими знаками в длинных выражениях

value = value1
            + value2
            - value3;

По тем же причинам.

Также, зачастую выношу запятые в списке параметров в начало

this.MyMethod(param1
                            ,param2
                            ,param3
                            );

container = [
                         value1
                        ,value2
                        ,value3
                        ];

Причина в том, что в случае добавления/удаления параметров, скорее всего, это надо будет сделать в конце списка параметров, а не в начале. В этом случае запятая в начале просто удобнее.

PS: Или я не понял формулировку голосования, или она противоречит нумерации примеров, приведенных в первом посте. Я так понимаю, что формулировка "оператор ДО условия" соответствует примеру №2 первого поста. Или это не так надо понимать?

[Владимир Максимов]

Может изменить формулировку пунктов голосования примерно так:

- Оператор сравнения в начале строки
- Оператор сравнения в конце строки

Термин "До/После условия", в данном случае, можно понимать очень по разному

[mazzy]

проголосовало уже 14 человек.
предлагаю не менять.

если хочется, то лучше создать новую тему с новым опросом.
здесь дать ссылку на новую. в новой дать ссылку сюда.

[lev]

на прошлом месте работы, я писал операторы до условия:

while select inventTable
    where inventTable.ItemId      == '1'
        && inventTable.ItemName == '2'

и мне казалось что так удобнее, например потому, что если вдруг надо закомментировать одно условие, то просто комментируется одна строка, а если оператор был бы в конце условия, то надо было бы комментировать ещё и его.

while select inventTable
    where inventTable.ItemId      == '1'
        //&& inventTable.ItemName == '2' // удобно

while select inventTable
    where inventTable.ItemId      == '1'  //&& // неудобно
              //inventTable.ItemName == '2'

когда пришел на другое место работы, ведущий разработчик настоял на том, что бы я писал оператор в конце строки условия. я долго с ним спорил, и пытался понять глубокий смысл написания условия именно таким способом. но в итоге получил ответ, что так требует BP и что так красивее (кстати понятие красоты у всех разное ). в итоге сейчас я пишу оператор в конце строки с условием, и уже привык

P.S. если говорить кратко, то сейчас пользуюсь первым вариантом (по привычке), но считаю более удобным второй (почему написал выше).
Вот такой вот, парадокс

[pitersky]

Цитата:

Сообщение от lev

в итоге получил ответ, что так требует BP и что так красивее (кстати понятие красоты у всех разное ).

Насчёт ВР я тоже слышал - мол МС в сертификационных тестах разработчиков по 2009 в обязательном порядке требует условие справа. Хз правда или нет...

Насчёт красоты - всё-таки эстетичнее, когда границы текста ровные и справа, и слева. Не зря же текстовые редакторы умеют выравнивать текст

[lev]

Цитата:

Сообщение от pitersky

Насчёт красоты - всё-таки эстетичнее, когда границы текста ровные и справа, и слева. Не зря же текстовые редакторы умеют выравнивать текст

Ага, люблю когда все выровнено и слева и справа и посередине

[Zabr]

Вы удивитесь, но я предпочитаю ставить && слева, а || справа. (Если кто-то хочет пофлудить, то это отличная тема для флуда ). Аргументы:
- && слева - не требует дополнительного выравнивания
- && слева - удобнее вставлять, убирать и комментировать условия
- && слева, а || справа - улучшает восприятие, и уменьшает вероятность ошибки при последующем возможном изменении условия (!). Знаков && как правило много, а знак || как правило один, поэтому проблем с выравниванием с ним не возникает..

Если пишу сам с нуля - ставлю слева. Если модифицирую код, где стоят справа - то не меняю (ну разве что если условие сильно запутанное или я его сильно меняю).

А еще я предпочитаю переносить "точку с запятой" отдельно на последнюю строку. Хотя иногда не делаю от лени. Аргументы для переноса:
- удобнее вставлять дополнительную строку в условие
- удобнее убирать (удалять или комментировать) последнюю строку в условии
- дополнительная строка между этим и следующим оператором, содержашая только одну точку с запятой, улучшает визуальное восприятие кода

[mazzy]

Цитата:

Сообщение от Zabr

Вы удивитесь, но я предпочитаю ставить && слева, а || справа.

а можно попросить отформатировать третий пример из первого в этой ветке сообщения.
любопытно было бы посмотреть

[Wamr]

Солидарен с Zabr
&& слева, || справа, ( ) меня пугают
цель - быстро понять какие условия в запросе и какое нам мешает
сначала читаются условия в одну строку начинающиеся с &&
потом с простыми перечислениями (например статусов)
потом разбор сложных-многоскобочных (в них уже последовательность скобочек знаков и отступов определяется текущим ощущением прекрасного)

    while select bankClientPayment_RU
        where bankClientPayment_RU.RContractAccount
    notexists join RContractTable
        where ( ( RContractTable.RContractPartnerType == RContractPartnerType::Cust
                  && BankClientPayment_RU.PartnerType == ModuleCustVend::Cust ) ||
                ( RContractTable.RContractPartnerType == RContractPartnerType::Vend
                  && BankClientPayment_RU.PartnerType == ModuleCustVend::Vend )  )
           && RContractTable.RContractAccount == bankClientPayment_RU.RContractAccount
           && RContractTable.RContractCode == bankClientPayment_RU.RContractCode

[gl00mie]

Уже столько всего сказано... я предпочитаю форматировать запросы так:

while select createdbBy, createdDateTime, RecId
    from    bankClientPayment_RU
    where   bankClientPayment_RU.RContractAccount
    notexists join RContractTable
    where       (   (   RContractTable.RContractPartnerType == RContractPartnerType::Cust
                    &&  BankClientPayment_RU.PartnerType    == ModuleCustVend::Cust 
                    )
                ||  (   RContractTable.RContractPartnerType == RContractPartnerType::Vend
                    &&  BankClientPayment_RU.PartnerType    == ModuleCustVend::Vend 
                    )
                )
            &&          RContractTable.RContractAccount     == bankClientPayment_RU.RContractAccount
            &&          RContractTable.RContractCode        == bankClientPayment_RU.RContractCode

С notexists join, конечно, засада - все отступы рушит, а так, если после where/join/from использовать табуляцию, получается все выровнено одинаково. А еще в сложных логических выражениях или в одиночных запросах select (если только они совсем уж не какие-нить тривиальные) предпочитаю точку с запятой ставить на новой строке - так, в случае чего, удобно новые условия добавлять.
Собственно, основной принцип, как уже отмечали тут, - это возможность править впоследствии код, затрагивая минимум исходных строк, в идеале - лишь добавляя новые строки, чтобы на сравнении они были бы четко отделены от исходного варианта кода. В этом отношении очень раздражает, что в стандартном функционале какой-нить вызов метода с тучей параметров бывает если и написан даже с каждым параметром на отдельной строке, то последний обязательно оказывается на одной строке с закрывающей скобкой. Ну <censored> просто, ни фига о других не думают...