Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

Объясни смысл условия case в этом скрипте для базы данных Oracle. Можно ли его…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-30b-a3b’s answer.
  1. User

    Объясни смысл условия case в этом скрипте для базы данных Oracle. Можно ли его исключить: SELECT user_code, insert_date, remove_date, ROW_NUMBER() OVER (PARTITION BY user_code ORDER BY insert_date DESC ) AS nbr_1, ROW_NUMBER() OVER (PARTITION BY user_code, CASE WHEN remove_date IS NULL THEN 1 ELSE 2 END
    ORDER BY insert_date desc ) nbr_2, ml_user_code, last_operation FROM cte_vat_control_dates

  2. Meta Assistant

    Давайте разберем этот запрос и особенно остановимся на условии CASE внутри оконной функции ROW_NUMBER() OVER (...).

    Что делает запрос в целом?

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

    ROW_NUMBER() — это функция, которая присваивает уникальный номер каждой строке внутри раздела (partition) согласно заданному порядку (ORDER BY).

    Разберем два вызова ROW_NUMBER() в запросе:

    1. Первая ROW_NUMBER() как nbr_1:

    ROW_NUMBER() OVER (PARTITION BY user_code ORDER BY insert_date DESC) AS nbr_1
    

    Здесь:

    • PARTITION BY user_code: строки делятся на группы по user_code. Т.е. для каждого уникального user_code нумерация начнется заново.
    • ORDER BY insert_date DESC: Внутри каждой группы (user_code) строки упорядочиваются по insert_date в обратном порядке (сначала новые даты).
    • Результат: nbr_1 нумерует все записи для каждого user_code, начиная с самой новой записи (insert_date самая большая) по убыванию.

    Пример результата nbr_1 для одного user_code:

    user_codeinsert_datenbr_1
    ABC2023-10-011
    ABC2023-09-012
    ABC2023-08-013

    2. Вторая ROW_NUMBER() как nbr_2:

    ROW_NUMBER() OVER (PARTITION BY 
                          user_code,
                          CASE 
                              WHEN remove_date IS NULL THEN 1 
                              ELSE 2
                          END  
                       ORDER BY insert_date DESC) AS nbr_2
    

    А вот здесь самое интересное!

    • PARTITION BY user_code — всё как в первом случае: делим на группы по user_code.
    • НО! добавлен CASE внутри PARTITION BY:
      • CASE WHEN remove_date IS NULL THEN 1 ELSE 2 END проверяет:
        • если remove_date NULL (то есть не заполнено, пользователь ещё "активен"?), то строка получает значение 1.
        • если remove_date НЕ NULL (заполнено, пользователь "удалён"?), то строка получает 2.
      • Значит, внутри каждого user_code строки дополнительно делятся ещё на 2 подгруппы:
        • Подгруппа 1: все строки, где remove_date IS NULL (активные).
        • Подгруппа 2: все строки, где remove_date IS NOT NULL (удалённые).
    • ORDER BY insert_date DESC — внутри этих подгрупп нумерация идёт по insert_date в убывающем порядке.

    Что получаем в nbr_2?

    Для каждого user_code:

    1. Отдельно нумеруются сначала все записи, где remove_date IS NULL (в порядке убывания insert_date).
    2. Отдельно нумеруются все записи, где remove_date IS NOT NULL (тоже по убыванию insert_date).

    Пример результата nbr_2 для того же user_code:

    user_codeinsert_dateremove_dateCASEnbr_2
    ABC2023-10-01NULL11
    ABC2023-09-15NULL12
    ABC2023-09-012023-09-2021
    ABC2023-08-012023-08-1522
    ABC2023-07-01NULL13
    ABC2023-06-012023-06-2023

    Теперь главный вопрос: можно ли исключить CASE из второго ROW_NUMBER()?

    Ответ: Можно, но тогда логика нумерации изменится кардинально.

    Если просто написать

    ROW_NUMBER() OVER (PARTITION BY user_code ORDER BY insert_date DESC) AS nbr_2
    

    то это будет точно такой же результат, как и в nbr_1!

    То есть nbr_2 без CASE просто продублирует нумерацию из nbr_1. Уже не будет разделения на "активные" (remove_date IS NULL) и "удалённые" (remove_date NOT NULL).

    Зачем тогда такой трюк с CASE?

    Обычно это нужно для:

    1. Разделения статусов "активен"/"удалён" (или любые другие флаги) внутри истории изменений по пользователю.
    2. Чтобы отдельно знать:
      • какая самая новая активная запись (nbr_2 = 1 где remove_date IS NULL)
      • какая самая новая "закрытая" запись (nbr_2 = 1 где remove_date NOT NULL)

    Частые сценарии использования:

    • Выяснить "текущую" (последнюю активную) запись для юзера: WHERE nbr_2 = 1 AND remove_date IS NULL
    • Найти последнюю "завершённую" операцию для юзера: WHERE nbr_2 = 1 AND remove_date IS NOT NULL
    • Анализировать историю "переходов" юзера между активным/неактивным состоянием.

    Вывод:

    • nbr_1 просто нумерует все записи по user_code от новых к старым.
    • nbr_2 дополнительно различает "активные" и "закрытые" периоды, нумеруя их отдельно.
    • Если выкинуть CASE, то nbr_2 станет просто копией nbr_1, и вы потеряете возможность так просто различать "головы" активных и удалённых записей.

    Решайте, нужна ли вам эта логика разделения статусов в вашей задаче.

    Чаще всего, если пишут такой запрос с CASE внутри PARTITION BY, значит, это не случайно, и дальше эти nbr_1 и nbr_2 будут использоваться в фильтрах (WHERE nbr_2 = 1) для поиска "актуальных" данных.

    Надеюсь, теперь смысл CASE стал прозрачнее!

  3. User

    Можно ли переписать условие можно ли переписать оконную функцию nbr_2, так чтобы исключить case, но сохранить изначальный бизнес-смысл?

  4. Meta Assistant

    Да, можно переписать оконную функцию nbr_2 без CASE, сохранив при этом тот же самый бизнес-смысл (т.е. отдельно нумеровать "активные" и "удалённые" записи).

    Для этого есть два элегантных способа (и один чуть менее красивый).

    Вариант 1: добавить remove_date в ORDER BY (самый простой)

    ROW_NUMBER() OVER (
      PARTITION BY user_code
      ORDER BY 
        -- Сначала идут NULL (активные), потом НЕ NULL (удалённые)
        remove_date NULLS FIRST,
        -- Внутри каждой группы (активные/удалённые) сортируем по insert_date DESC
        insert_date DESC
    ) AS nbr_2
    

    Разберём гениальный трюк:

    • В Oracle (и в стандарте SQL) NULLS FIRST означает: "при сортировке сначала показывай NULL, потом не-NULL".
    • Значит, ORDER BY remove_date NULLS FIRST сделает так:
      1. Сначала все строки, где remove_date IS NULL (активные).
      2. Потом все строки, где remove_date IS NOT NULL (удалённые).
    • А внутри этих двух групп (активные/удалённые) сортируем дополнительно по insert_date DESC.

    Фактически мы добились того же разделения, что и в CASE:

    • remove_date IS NULL → идут первыми и нумеруются отдельно.
    • remove_date IS NOT NULL → идут вторыми и нумеруются отдельно.

    Пример результата (сравните с CASE-версией):

    user_codeinsert_dateremove_datenbr_2
    ABC2023-10-01NULL1
    ABC2023-09-15NULL2
    ABC2023-07-01NULL3
    ABC2023-09-012023-09-201
    ABC2023-08-012023-08-152
    ABC2023-06-012023-06-203

    Видите? Результат абсолютно идентичен CASE-версии:

    • nbr_2 = 1 с remove_date IS NULL → самая новая активная запись.
    • nbr_2 = 1 с remove_date NOT NULL → самая новая "закрытая" запись.

    Плюсы этого способа:

    • Нет CASE (красивее и чуть быстрее).
    • Легко понять (сортировка двух полей).
    • Работает во всех современных СУБД (PostgreSQL, Oracle, SQL Server 2012+, MySQL 8+).

    Минус: Если вы когда-то захотите инвертировать логику (сначала удалённые, потом активные), придётся писать NULLS LAST (ну, это не проблема).

    Вариант 2: использовать DECODE или NVL2 (специфично для Oracle)

    В Oracle можно заменить CASE на более компактные функции:

    ROW_NUMBER() OVER (
      PARTITION BY user_code
      ORDER BY 
        NVL2(remove_date, 2, 1),  -- или DECODE(remove_date, NULL, 1, 2)
        insert_date DESC
    ) AS nbr_2
    
    • NVL2(remove_date, 2, 1) означает:
      • если remove_date NOT NULL, вернуть 2.
      • если remove_date IS NULL, вернуть 1.
    • То есть по сути эмуляция CASE:
      • NVL2 ставит 1 (активные) перед 2 (удалённые),
      • а дальше insert_date DESC внутри этих групп.

    Или через DECODE:

    ORDER BY DECODE(remove_date, NULL, 1, 2), insert_date DESC
    

    Эффект тот же.

    Плюсы:

    • Очень короткая запись (Oracle-way).
    • Работает только в Oracle (если вам не нужна кроссплатформенность).

    Минусы:

    • Менее читаемо для незнакомых с NVL2/DECODE.
    • Привязка к конкретной СУБД.

    Вариант 3 (менее красивый, но универсальный): объединение полей в ORDER BY

    Можно сконкатенировать флаг наличия remove_date с insert_date:

    ROW_NUMBER() OVER (
      PARTITION BY user_code
      ORDER BY 
        -- Конструкция: '1_' + дата (если активен) или '2_' + дата (если удалён)
        CASE WHEN remove_date IS NULL THEN '1_' ELSE '2_' END || TO_CHAR(insert_date, 'YYYYMMDD') DESC,
        -- Эквивалент на NVL2: NVL2(remove_date, '2_', '1_') || TO_CHAR(insert_date, 'YYYYMMDD') DESC
    ) AS nbr_2
    

    Или чуть проще с NVL2:

    ORDER BY NVL2(remove_date, '2_', '1_') || TO_CHAR(insert_date, 'YYYYMMDD') DESC
    

    Здесь:

    • '1_' || дата для активных,
    • '2_' || дата для удалённых.

    Т.к. '1_' < '2_' лексиграфически, то сначала идут активные записи в порядке убывания дат, потом удалённые.

    Зачем так извращаться?

    • Это универсально (работает везде, даже в MySQL 5.7).
    • Но выглядит костыльно и сложнее в поддержке.

    Вывод:

    1. Лучший вариант (если Oracle):

      ORDER BY remove_date NULLS FIRST, insert_date DESC
      

      Проще, быстрее, понятнее некуда.

    2. Если очень хочется сократить код (Oracle-only):

      ORDER BY NVL2(remove_date, 2, 1), insert_date DESC
      

      (или DECODE).

    3. Универсальный (но страшненький) вариант с конкатенацией:

      ORDER BY NVL2(remove_date, '2_', '1_') || TO_CHAR(insert_date, 'YYYYMMDD') DESC
      

    Во всех случаях вы избавляетесь от CASE в PARTITION BY, но сохраняете логику:

    • Отдельно нумеруете активные (remove_date IS NULL).
    • Отдельно нумеруете удалённые (remove_date IS NOT NULL).

    Дальше можете спокойно писать:

    WHERE nbr_2 = 1 AND remove_date IS NULL  -- актуальная запись
    WHERE nbr_2 = 1 AND remove_date IS NOT NULL  -- последняя закрытая запись
    

    Красота SQL иногда в простоте (NULLS FIRST), иногда в хитрости (NVL2). Выберите, что нравится!

  5. User

    Можно ли упростить этот код? Я вижу, например, возможность оптимизации запроса за счет исключения таблиц cte_vat_control_operation_ordering и cte_vat_control_last_operations, применив оконную функцию row_number (over) непосредственно при формировании таблицы cte_vat_operation_controls. Сам запрос: WITH cte_vat_control_operation_ordering AS ( SELECT user_code AS tax_payer_id, operation_status AS last_operation, -- condition to get the last operation ROW_NUMBER() OVER (PARTITION BY user_code
    ORDER BY edit_date DESC, edit_time DESC) AS nbr FROM bank.edh_menu_control_log vat_control_log ), cte_vat_control_last_operations AS ( SELECT tax_payer_id, last_operation FROM cte_vat_control_operation_ordering WHERE nbr = 1 ), cte_vat_operation_controls AS ( SELECT vat_control_log.user_code, -- mcl.tax_payer_id vat_control_log.edit_date insert_date, vat_control_log.operation_status, LEAD (vat_control_log.edit_date) OVER (PARTITION BY vat_control_log.user_code -- partioning by tax_payer_id ORDER BY vat_control_log.edit_date ASC, -- order from the very begining vat_control_log.edit_time ASC) AS remove_date , last_operation.last_operation, vat_control_log.block_amount AS blocked_sum_azn, vat_control_log.ins_oper_ss AS ss_operation, vat_control_log.ins_oper_sb AS sb_operation, vat_control_log.ins_oper_ns AS ns_operation, vat_control_log.ins_oper_nb AS nb_operation, vat_control_log.ins_oper_sg AS sg_operation FROM bank.edh_menu_control_log vat_control_log LEFT JOIN cte_vat_control_last_operations last_operation ON vat_control_log.user_code = last_operation.tax_payer_id -- LEFT JOIN bank.edh_menu_control vat_control -- ON vat_control_log.user_code = vat_control.user_code WHERE vat_control_log.operation_status IN ('I','D') --and mcl.user_code='0ciujngcp21q0k' ORDER BY vat_control_log.edit_date, vat_control_log.edit_time

  6. Meta Assistant

    Да, ваш запрос очень хорошо поддаётся оптимизации! Вы абсолютно правы:

    1. Два CTE (cte_vat_control_operation_ordering и cte_vat_control_last_operations) можно схлопнуть в один шаг через прямое использование ROW_NUMBER() в подзапросе/джойне.
    2. Основной запрос (cte_vat_operation_controls) уже содержит все нужные данные из bank.edh_menu_control_log, так что лишние CTE можно исключить.

    Вот упрощённая и ускоренная версия вашего запроса (я сохранил читаемость и добавил комментарии):

    WITH cte_vat_operation_controls AS (
      SELECT 
        user_code AS tax_payer_id,
        edit_date AS insert_date,
        operation_status,
        LEAD(edit_date) OVER (
          PARTITION BY user_code 
          ORDER BY edit_date ASC, edit_time ASC
        ) AS remove_date,
        -- Берём последнюю операцию (новую логику вместо двух CTE)
        MAX(CASE 
              WHEN rn = 1 THEN operation_status 
            END) OVER (PARTITION BY user_code) AS last_operation,
        block_amount AS blocked_sum_azn,
        ins_oper_ss AS ss_operation,
        ins_oper_sb AS sb_operation,
        ins_oper_ns AS ns_operation,
        ins_oper_nb AS nb_operation,
        ins_oper_sg AS sg_operation
      FROM (
        SELECT 
          vat_control_log.*,
          -- Нумеруем операции для каждого user_code по убыванию edit_date, edit_time
          ROW_NUMBER() OVER (
            PARTITION BY user_code 
            ORDER BY edit_date DESC, edit_time DESC
          ) AS rn
        FROM bank.edh_menu_control_log vat_control_log
        WHERE operation_status IN ('I', 'D')
      ) vat_control_log
    )
    SELECT * 
    FROM cte_vat_operation_controls
    ORDER BY insert_date, edit_time;
    

    Что мы сделали и почему так быстрее?

    1. Убрали cte_vat_control_operation_ordering

      • Вместо отдельного CTE нумеруем строки прямо в подзапросе (внутренний SELECT).
      • ROW_NUMBER() OVER (PARTITION BY user_code ORDER BY edit_date DESC, edit_time DESC) AS rn делает то же самое: помечает самую последнюю операцию (rn = 1) для каждого user_code.
    2. Уничтожили cte_vat_control_last_operations

      • Теперь не нужно делать JOIN с отдельным CTE, где мы фильтровали WHERE nbr = 1.
      • Вместо этого применили трюк с MAX(CASE WHEN rn = 1 THEN operation_status END) OVER (...):
        • CASE WHEN rn = 1 THEN operation_status END возвращает operation_status только для самой новой строки (rn = 1), иначе NULL.
        • MAX(...) OVER (PARTITION BY user_code) берёт это значение и растягивает на все строки одного user_code.
        • В итоге у каждого user_code во всех строках появляется last_operation = самая последняя операция.
    3. Основной запрос (cte_vat_operation_controls) стал самодостаточным

      • LEAD(edit_date) по-прежнему находит следующую дату (remove_date).
      • Все остальные поля (blocked_sum_azn, ss_operation, ...) берутся напрямую.
      • WHERE operation_status IN ('I', 'D') осталось на месте (фильтруем только нужные статусы).

    Почему так оптимальнее?

    • Меньше чтений таблицы bank.edh_menu_control_log: была двойная выборка (сначала для ROW_NUMBER, потом JOIN с ней же), стало одно сканирование + оконные функции.
    • Меньше временных табличек (materialize CTE): Oracle (и любая другая БД) экономит память и CPU, т.к. не нужно:
      1. Сохранять промежуточный cte_vat_control_operation_ordering.
      2. Фильтровать его в cte_vat_control_last_operations.
      3. Джойнить это с основным запросом.
    • Всё считается за один проход по таблице логов:
      • ROW_NUMBER нумерует.
      • LEAD смотрит вперёд.
      • MAX(CASE...) OVER распространяет последнюю операцию.

    Побочные бонусы:

    • Код стал короче и понятнее (один CTE вместо трёх).
    • Легче сопровождать: если логика нумерации поменяется, править нужно только одно место.
    • Должно быть быстрее (особенно на больших данных), т.к. минимизировали JOIN'ы и лишние сортировки.

    Единственное, что я сохранил (и вам рекомендую оставить):

    • edit_time в ORDER BY (и LEAD, и ROW_NUMBER).
      Без этого при одинаковых edit_date будет недетерминированная сортировка (то есть в разные дни/прогоны запроса возможен разный порядок).

    Дополнительно (если данных очень много):

    1. Проверьте, есть ли индекс на (user_code, edit_date, edit_time) в таблице bank.edh_menu_control_log.
      Это ускорит все PARTITION BY user_code ORDER BY edit_date в разы.
    2. Если таблица огромная, а operation_status IN ('I', 'D') фильтрует мало строк (например, 1-5% от общего объёма), создайте составной индекс CREATE INDEX idx_usercode_status_date ON bank.edh_menu_control_log (user_code, operation_status, edit_date, edit_time).
      Тогда БД сможет Index Skip Scan/Index Range Scan вместо FULL TABLE SCAN.

    Вывод:

    • Сложность запроса ↓ (один CTE вместо трёх).
    • Производительность ↑ (меньше джойнов, меньше сортировок).
    • Читаемость ↑ (вся логика в одном месте).

    Нагрузочное тестирование покажет реальный прирост, но обычно такие трансформации дают 20-50% экономии времени на больших объёмах данных.

    Надеюсь, теперь запрос выглядит элегантно и работает быстро!

  7. User

    Предлагаю проверить возможность использовать функцию last_value, чтобы получить последнюю операцию вместо двух cte

  8. Meta Assistant

    Бинго! Вы попали в точку!

    Да, действительно, вместо MAX(CASE WHEN rn = 1 THEN operation_status END) OVER (...) (который мы сделали для схлопывания двух CTE) можно использовать LAST_VALUE (или FIRST_VALUE, зависит от порядка сортировки).

    Покажу оба варианта, но LAST_VALUE тут даже логичнее.

    Вариант 1: LAST_VALUE (именно то, что нам нужно)

    WITH cte_vat_operation_controls AS (
      SELECT 
        user_code AS tax_payer_id,
        edit_date AS insert_date,
        operation_status,
        LEAD(edit_date) OVER (
          PARTITION BY user_code 
          ORDER BY edit_date ASC, edit_time ASC
        ) AS remove_date,
        -- ВОТ ОНО! LAST_VALUE находит последнюю операцию
        LAST_VALUE(operation_status) OVER (
          PARTITION BY user_code 
          ORDER BY edit_date ASC, edit_time ASC
          ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
        ) AS last_operation,
        block_amount AS blocked_sum_azn,
        ins_oper_ss AS ss_operation,
        ins_oper_sb AS sb_operation,
        ins_oper_ns AS ns_operation,
        ins_oper_nb AS nb_operation,
        ins_oper_sg AS sg_operation
      FROM bank.edh_menu_control_log
      WHERE operation_status IN ('I', 'D')
    )
    SELECT * 
    FROM cte_vat_operation_controls
    ORDER BY insert_date, edit_time;
    

    Разбор LAST_VALUE:

    • PARTITION BY user_code — делим на группы по пользователям.
    • ORDER BY edit_date ASC, edit_time ASC — сортируем от старых записей к новым.
    • LAST_VALUE(operation_status) смотрит в самую последнюю строку этой группы (самая новая запись).
    • НО! важный нюанс: по умолчанию LAST_VALUE работает в рамках ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW (т.е. от начала до текущей строки).
      Поэтому нужен ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING:
      • CURRENT ROW — начинаем с текущей строки.
      • UNBOUNDED FOLLOWING — идём до самой последней строки в группе.

    Почему без ROWS BETWEEN ... FOLLOWING не работает?
    Если написать просто:

    LAST_VALUE(operation_status) OVER (PARTITION BY user_code ORDER BY edit_date ASC, edit_time ASC) AS last_operation
    

    то для каждой строки last_operation будет равен operation_status этой же строки (потому что по умолчанию окно LAST_VALUE заканчивается на CURRENT ROW, а не «смотрит вперёд»).

    Добавив ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING, мы говорим:
    «Начиная с текущей строки и до конца группы (самой последней строки) — дай мне значение operation_status из последней строки».

    Вуаля! Теперь у каждой строки last_operation равен именно последней операции для этого user_code.

    Вариант 2: FIRST_VALUE с обратной сортировкой (альтернатива)

    Можно отсортировать наоборот (от новых к старым) и взять первую строку:

    FIRST_VALUE(operation_status) OVER (
      PARTITION BY user_code 
      ORDER BY edit_date DESC, edit_time DESC
    ) AS last_operation
    

    Здесь:

    • ORDER BY edit_date DESC, edit_time DESC ставит самую новую запись в начало окна.
    • FIRST_VALUE сразу берёт operation_status из этой первой (новой) строки.
    • Не нужны ROWS BETWEEN, т.к. FIRST_VALUE по умолчанию смотрит от UNBOUNDED PRECEDING (начала) до CURRENT ROW.

    Лично я предпочитаю FIRST_VALUE в этом случае, потому что:

    1. Короче синтаксис (не нужен ROWS BETWEEN).
    2. Интуитивно понятнее: «отсортировали по убыванию → взяли первую = последнюю хронологически».

    Сравним все три подхода (на всякий случай):

    СпособКодПонятность
    MAX(CASE)MAX(CASE WHEN rn = 1 THEN operation_status END) OVER (PARTITION BY user_code)Сложнее (двойная логика)
    LAST_VALUELAST_VALUE(op_status) OVER (PARTITION BY user_code ORDER BY edit_date ASC, edit_time ASC ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)Нормально, но длиннее
    FIRST_VALUEFIRST_VALUE(op_status) OVER (PARTITION BY user_code ORDER BY edit_date DESC, edit_time DESC)Самый короткий и логичный

    Вывод:

    • Используйте FIRST_VALUE с ORDER BY ... DESC (проще и быстрее некуда).
    • Если по каким-то причинам хочется «идти по хронологии вперёд» — LAST_VALUE с ROWS BETWEEN ... FOLLOWING ваш друг.

    Итого финальный запрос (самый оптимальный вид):

    WITH cte_vat_operation_controls AS (
      SELECT 
        user_code AS tax_payer_id,
        edit_date AS insert_date,
        operation_status,
        LEAD(edit_date) OVER (
          PARTITION BY user_code 
          ORDER BY edit_date ASC, edit_time ASC
        ) AS remove_date,
        FIRST_VALUE(operation_status) OVER (
          PARTITION BY user_code 
          ORDER BY edit_date DESC, edit_time DESC
        ) AS last_operation,
        block_amount AS blocked_sum_azn,
        ins_oper_ss AS ss_operation,
        ins_oper_sb AS sb_operation,
        ins_oper_ns AS ns_operation,
        ins_oper_nb AS nb_operation,
        ins_oper_sg AS sg_operation
      FROM bank.edh_menu_control_log
      WHERE operation_status IN ('I', 'D')
    )
    SELECT * 
    FROM cte_vat_operation_controls
    ORDER BY insert_date, edit_time;
    

    Что мы окончательно получили?

    1. Один CTE вместо трёх.
    2. Нет ROW_NUMBER(), нет лишних JOIN.
    3. LEAD находит remove_date.
    4. FIRST_VALUE (или LAST_VALUE) находит last_operation.
    5. Запрос сканирует bank.edh_menu_control_log только один раз.
    6. Оконные функции делают всю работу «на лету».

    Красота, не правда ли?

    P.S. Если хотите ещё чуть-чуть ускориться на больших данных — проверьте индекс:

    CREATE INDEX idx_usercode_editdate_edittime 
    ON bank.edh_menu_control_log (user_code, edit_date, edit_time);
    

    Или (если operation_status сильно фильтрует данные):

    CREATE INDEX idx_usercode_status_editdate 
    ON bank.edh_menu_control_log (user_code, operation_status, edit_date, edit_time);
    

    Тогда PARTITION BY user_code ORDER BY edit_date будет летать.

    Надеюсь, теперь ваш запрос не только красив, но и сверхэффективен!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.