Напиши к моим запросам еще одно оптимизированное р...

Ниже приведены возможные переписанные варианты запросов (без использования CTE и стараясь не использовать GROUP BY и DISTINCT). Там, где в изначальном запросе уже не было ни CTE, ни GROUP BY/DISTINCT, я покажу альтернативу (часто через оконные функции или LEFT JOIN вместо NOT EXISTS), чтобы запрос отличался от исходного. Также учитываю совместимость с PostgreSQL и заменяю UNION на UNION ALL, если требуется.

---

41. Виды работ на будущую неделю, для которых не хватает расходных материалов

Изначальный запрос (с GROUP BY и HAVING):

sql
SELECT 
    ts.title
FROM types_of_services ts
JOIN orders o 
    ON o.id_types_of_services = ts.id_types_of_services
JOIN tools_and_materials_types_of_services tmts 
    ON tmts.id_types_of_services = ts.id_types_of_services
JOIN tools_and_materials tm 
    ON tm.id_item = tmts.id_item
WHERE 
    o.date BETWEEN CURRENT_DATE + INTERVAL '1 week' AND CURRENT_DATE + INTERVAL '2 week'
GROUP BY 
    ts.id_types_of_services, 
    tm.id_item
HAVING 
    tm.quantity < SUM(tmts.quantity);

Переписанный вариант (через оконные функции, без GROUP BY и без CTE):

sql
SELECT sub.title
FROM (
    SELECT 
        ts.id_types_of_services,
        ts.title,
        tm.id_item,
        tm.quantity,
        /* Подсчитываем суммарную потребность в материале по каждому (услуга, материал)
           в окне PARTITION BY. */
        SUM(tmts.quantity) OVER (PARTITION BY ts.id_types_of_services, tm.id_item) AS total_required,
        /* Чтобы вывести каждую услугу один раз на материал, используем нумерацию строк 
           и отбираем только первую */
        ROW_NUMBER() OVER (PARTITION BY ts.id_types_of_services, tm.id_item 
                           ORDER BY ts.id_types_of_services) AS rn
    FROM types_of_services ts
    JOIN orders o 
        ON o.id_types_of_services = ts.id_types_of_services
    JOIN tools_and_materials_types_of_services tmts 
        ON tmts.id_types_of_services = ts.id_types_of_services
    JOIN tools_and_materials tm 
        ON tm.id_item = tmts.id_item
    WHERE o.date BETWEEN CURRENT_DATE + INTERVAL '1 week' AND CURRENT_DATE + INTERVAL '2 week'
) AS sub
WHERE sub.rn = 1
  AND sub.quantity < sub.total_required;

---

42. Материалы с истекшим сроком годности, которых осталось 0.5 и более от общего количества

Изначальный запрос уже не содержит GROUP BY/CTE:

sql
SELECT 
    tm.title 
FROM tools_and_materials tm
WHERE 
    tm.end_date < CURRENT_DATE
    AND tm.quantity >= 0.5 * (
        SELECT SUM(quantity) 
        FROM tools_and_materials 
        WHERE id_item = tm.id_item
    );

Вариант через оконные функции (без вложенного SELECT SUM(...), без DISTINCT/GROUP BY):

sql
SELECT sub.title
FROM (
    SELECT
        t.id_item,
        t.title,
        t.end_date,
        t.quantity,
        -- Суммируем количество по тому же id_item:
        SUM(t.quantity) OVER (PARTITION BY t.id_item) AS total_quantity
    FROM tools_and_materials t
) AS sub
WHERE sub.end_date < CURRENT_DATE
  AND sub.quantity >= 0.5 * sub.total_quantity;

---

43. Для каждого поставщика вывести общее количество расходных материалов

Изначальный запрос:

sql
SELECT 
    s.title AS supplier_title, 
    SUM(tms.quantity) AS total_quantity
FROM supplier s
JOIN tools_and_materials_supplier tms 
    ON tms.id_supplier = s.id_supplier
GROUP BY 
    s.id_supplier
ORDER BY 
    total_quantity ASC, 
    s.title ASC;

Переписанный вариант (через оконные функции, без GROUP BY):

sql
SELECT sub.supplier_title,
       sub.total_quantity
FROM (
    SELECT 
        s.id_supplier,
        s.title AS supplier_title,
        /* Считаем сумму по поставщику через окно */
        SUM(tms.quantity) OVER (PARTITION BY s.id_supplier) AS total_quantity,
        /* Чтобы вывести 1 строку на поставщика, используем нумерацию */
        ROW_NUMBER() OVER (PARTITION BY s.id_supplier ORDER BY s.id_supplier) AS rn
    FROM supplier s
    JOIN tools_and_materials_supplier tms 
        ON tms.id_supplier = s.id_supplier
) AS sub
WHERE sub.rn = 1
ORDER BY sub.total_quantity, sub.supplier_title;

---

44. Акции, для которых ещё не определён набор услуг

Изначальный запрос (через NOT EXISTS):

sql
SELECT *
FROM action a
WHERE NOT EXISTS (
    SELECT 1
    FROM types_of_services_action tsa
    WHERE tsa.id_action = a.id_action
);

Он уже не содержит CTE/GROUP BY/DISTINCT.
Альтернативный вариант – через LEFT JOIN:

sql
SELECT a.*
FROM action a
LEFT JOIN types_of_services_action tsa 
       ON tsa.id_action = a.id_action
WHERE tsa.id_action IS NULL;

---

45. Названия видов работ, которые в этом году заказываются чаще всех, но в прошлом году – не более 3 заказов

Изначальный код содержит подзапросы и GROUP BY.
Ниже – вариант без CTE и без явного GROUP BY, используя оконные функции и левое соединение для данных прошлого года.

sql
SELECT service_title
FROM (
    SELECT
        ts.title AS service_title,
        /* Подсчитываем количество заказов за ТЕКУЩИЙ год в окне PARTITION BY */
        COUNT(o_current.id_order) 
          OVER (PARTITION BY ts.id_types_of_services) AS current_year_count,
        /* Определяем максимальное количество заказов по всем видам работ (окном без PARTITION) */
        MAX(COUNT(o_current.id_order) 
          OVER (PARTITION BY ts.id_types_of_services)) 
          OVER () AS max_current_year_count,
        
        COALESCE(o_last_year.order_count_last_year, 0) AS order_count_last_year,
        
        /* Чтобы выдать по одному разу на каждый вид работ */
        ROW_NUMBER() OVER (PARTITION BY ts.id_types_of_services ORDER BY ts.id_types_of_services) AS rn
    FROM types_of_services ts
    JOIN orders o_current
         ON ts.id_types_of_services = o_current.id_types_of_services
    /* "Подтягиваем" данные за прошлый год через LEFT JOIN (агрегаты внутри подзапроса) */
    LEFT JOIN (
        SELECT id_types_of_services, COUNT(*) AS order_count_last_year
        FROM orders
        WHERE date BETWEEN 
              (DATE_TRUNC('year', CURRENT_DATE) - INTERVAL '1 year')
              AND (DATE_TRUNC('year', CURRENT_DATE) - INTERVAL '1 day')
        GROUP BY id_types_of_services
    ) AS o_last_year
    ON ts.id_types_of_services = o_last_year.id_types_of_services
    
    WHERE EXTRACT(YEAR FROM o_current.date) = EXTRACT(YEAR FROM CURRENT_DATE)
) AS sub
WHERE sub.rn = 1
  AND sub.current_year_count = sub.max_current_year_count
  AND sub.order_count_last_year <= 3;

---

46. Самое редкое и самое частое имя (среди клиентов и мастеров)

Изначально был вариант с двумя CTE (name_counts, min_max).
Вот решение в одну «таблицу» (подзапрос) с оконными функциями и без GROUP BY/CTE/DISTINCT:

sql
SELECT name,
       frequency,
       CASE
         WHEN frequency = min_freq THEN 'РЕДКОЕ'
         WHEN frequency = max_freq THEN 'ЧАСТОЕ'
       END AS type
FROM (
    SELECT
        all_names.name,
        /* Подсчитываем сколько раз встречается name (окном по имени) */
        COUNT(*) OVER (PARTITION BY all_names.name) AS frequency,
        
        /* Находим минимальную и максимальную встречаемость среди всех */
        MIN(COUNT(*)) OVER () AS min_freq,
        MAX(COUNT(*)) OVER () AS max_freq,
        
        /* Чтобы имя не дублировалось много раз, берем одну строку на каждое имя */
        ROW_NUMBER() OVER (PARTITION BY all_names.name ORDER BY all_names.name) AS rn
    FROM (
        /* Вместо UNION используем UNION ALL, как просили */
        SELECT name FROM client
        UNION ALL
        SELECT name FROM employee
    ) AS all_names
) AS sub
WHERE sub.rn = 1
  AND (frequency = min_freq OR frequency = max_freq);

---

47. Клиент, заказавший наибольшее количество услуг за последний месяц

Изначальный запрос:

sql
SELECT 
    c.surname, 
    c.name, 
    c.patronymic
FROM client c
JOIN orders o 
    ON o.personnel_data = c.personnel_data
WHERE 
    o.date >= CURRENT_DATE - INTERVAL '1 month'
GROUP BY 
    c.surname, c.name, c.patronymic, c.personnel_data
ORDER BY 
    COUNT(o.id_order) DESC
LIMIT 1;

Переписанный вариант (через оконные функции, без GROUP BY):

sql
SELECT sub.surname, sub.name, sub.patronymic
FROM (
    SELECT
        c.surname,
        c.name,
        c.patronymic,
        /* Считаем общее число заказов за последний месяц 
           (окно PARTITION BY конкретному клиенту) */
        COUNT(o.id_order) OVER (PARTITION BY c.personnel_data) AS total_orders,
        
        /* Присваиваем глобальный ранг по убыванию числа заказов */
        RANK() OVER (ORDER BY COUNT(o.id_order) 
                           OVER (PARTITION BY c.personnel_data) DESC) AS rank_order
    FROM client c
    JOIN orders o 
        ON o.personnel_data = c.personnel_data
    WHERE o.date >= CURRENT_DATE - INTERVAL '1 month'
) AS sub
/* Берем того, кто на 1-м месте по числу заказов */
WHERE sub.rank_order = 1
LIMIT 1;

---

48. Вывести в одном столбце фамилии мастеров и клиентов, во втором — «мастер» для мастеров

Изначальный запрос уже использует UNION ALL и не содержит CTE/GROUP BY:

sql
SELECT 
    e.surname, 
    'мастер' AS role
FROM employee e
UNION ALL
SELECT 
    c.surname, 
    NULL AS role
FROM client c;

Этот запрос уже удовлетворяет: нет CTE, нет DISTINCT/GROUP BY, используется UNION ALL.
Можно оставить как есть.

---

49. Клиенты, которые не посещали салон более двух лет

Изначальный запрос:

sql
SELECT 
    c.personnel_data, 
    c.surname, 
    c.name, 
    c.patronymic
FROM client c
WHERE NOT EXISTS (
    SELECT 1
    FROM orders o
    WHERE o.personnel_data = c.personnel_data
      AND o.date >= CURRENT_DATE - INTERVAL '2 year'
);

Он тоже не содержит CTE/GROUP BY/DISTINCT.
Альтернатива (через LEFT JOIN):

sql
SELECT c.personnel_data, c.surname, c.name, c.patronymic
FROM client c
LEFT JOIN orders o
       ON o.personnel_data = c.personnel_data
          AND o.date >= CURRENT_DATE - INTERVAL '2 year'
WHERE o.id_order IS NULL;

---

50. Виды работ, которые не заказывались последний год

Изначальный запрос:

sql
SELECT 
    ts.title
FROM types_of_services ts
WHERE NOT EXISTS (
    SELECT 1
    FROM orders o
    WHERE o.id_types_of_services = ts.id_types_of_services
      AND o.date >= CURRENT_DATE - INTERVAL '1 year'
);

Нет CTE/GROUP BY/DISTINCT.
Альтернатива (через LEFT JOIN):

sql
SELECT ts.title
FROM types_of_services ts
LEFT JOIN orders o
       ON o.id_types_of_services = ts.id_types_of_services
          AND o.date >= CURRENT_DATE - INTERVAL '1 year'
WHERE o.id_order IS NULL;

---

51. Клиент, который «каждый месяц заказывает только один вид работ»

В исходном запросе использовался рекурсивный CTE, проверка пропущенных месяцев и т. д.
Полностью без GROUP BY/CTE подобную логику очень сложно повторить «одним махом». Ниже — пример с оконными функциями (трюк с MAX(...) OVER = MIN(...) OVER позволяет проверить, что в месяце один и тот же id_types_of_services). При этом для проверки «каждый месяц без пропусков» часто используют generate_series(...), но это тоже обычно оформляют или во вложенном запросе, или через CTE.

Ниже упрощённый пример: мы проверяем, что в каждом месяце у клиента максимальный id_types_of_services равен минимальному (значит, ровно один тип услуг). Затем дополнительно убеждаемся, что количество месяцев заказов соответствует количеству календарных месяцев между первой и последней датой. Это, однако, может отличаться от вашей исходной логики, где учитывался «каждый месяц с момента первого визита до текущего». Тем не менее иллюстрирует подход без CTE.

sql
SELECT c.surname, c.name, c.patronymic, c.phone
FROM client c
WHERE NOT EXISTS (
    SELECT 1
    FROM (
        SELECT 
            DATE_TRUNC('month', o.date) AS month_val,
            -- Если в месяце более одного вида работ, то min != max
            MIN(o.id_types_of_services) OVER (PARTITION BY c.personnel_data, DATE_TRUNC('month', o.date)) AS min_service,
            MAX(o.id_types_of_services) OVER (PARTITION BY c.personnel_data, DATE_TRUNC('month', o.date)) AS max_service
        FROM orders o
        WHERE o.personnel_data = c.personnel_data
          AND o.date < DATE_TRUNC('month', CURRENT_DATE)
    ) AS m
    WHERE m.min_service <> m.max_service
);

Чтобы же строго проверить «нет пропусков ни одного месяца», обычно действительно нужно генерировать все месяцы (через generate_series) и делать LEFT JOIN с заказами. Но это либо делается подзапросом, либо CTE. Без CTE это становится очень громоздко. Если всё же допустимо подзапросом использовать generate_series, то можно так (примерно):

sql
SELECT c.surname, c.name, c.patronymic, c.phone
FROM client c
WHERE NOT EXISTS (
    SELECT 1
    FROM (
        /* Генерируем все месяцы с даты первого заказа по предыдущий месяц */
        SELECT gs::date AS month_start
        FROM generate_series(
            (SELECT DATE_TRUNC('month', MIN(o1.date))
             FROM orders o1
             WHERE o1.personnel_data = c.personnel_data),
            DATE_TRUNC('month', CURRENT_DATE) - INTERVAL '1 month',
            '1 month'::interval
        ) gs
    ) AS months
    LEFT JOIN (
        /* Считаем, заказал ли клиент ровно один вид работ в конкретном месяце */
        SELECT DATE_TRUNC('month', o2.date) AS mth,
               /* Трюк min= max для проверки ровно одного вида */
               MIN(o2.id_types_of_services) AS min_t,
               MAX(o2.id_types_of_services) AS max_t
        FROM orders o2
        WHERE o2.personnel_data = c.personnel_data
        GROUP BY DATE_TRUNC('month', o2.date)
    ) AS check_one
        ON check_one.mth = months.month_start
    WHERE 
          -- Пропуск месяца (нет строки в check_one) или в месяце более одного вида
          check_one.mth IS NULL
          OR check_one.min_t <> check_one.max_t
);

Так или иначе, полностью «красивого» решения без CTE и без GROUP BY на такую задачу бывает очень тяжело добиться. Приведённый код — лишь демонстрация идеи.

---

52. Даты прошлого месяца, когда не оказывалась услуга X

Исходный запрос – рекурсивный CTE:

sql
WITH RECURSIVE last_month_dates AS (
    SELECT DATE_TRUNC('month', CURRENT_DATE) - INTERVAL '1 month' AS missing_date
    UNION ALL
    SELECT missing_date + INTERVAL '1 day'
    FROM last_month_dates
    WHERE missing_date + INTERVAL '1 day' < DATE_TRUNC('month', CURRENT_DATE)
)
SELECT lmd.missing_date
FROM last_month_dates lmd
WHERE NOT EXISTS (
    SELECT 1
    FROM orders o
    WHERE o.id_types_of_services = 1
      AND o.date = lmd.missing_date
);

Переписанный вариант через generate_series() (без CTE):

sql
SELECT gen_date AS missing_date
FROM generate_series(
       (DATE_TRUNC('month', CURRENT_DATE) - INTERVAL '1 month')::date,
       (DATE_TRUNC('month', CURRENT_DATE)::date - 1),
       '1 day'
     ) AS gen_date
WHERE NOT EXISTS (
    SELECT 1
    FROM orders o
    WHERE o.id_types_of_services = 1
      AND o.date::date = gen_date
);

(Здесь o.date::date на случай, если o.date — тип timestamp; если date в таблице уже имеет тип date, то кастовать не нужно.)

---

53. Название салона, число оказанных услуг в прошлом году, и процент от общего числа

Изначальный запрос снова рекурсивный и с дополнительными CTE:

sql
WITH RECURSIVE year_months AS (...),
     salon_services AS (...),
     total_services AS (...)
SELECT ...
FROM salon_services ss, total_services ts;

Ниже два варианта решения без CTE:

Вариант 1: подзапрос для «общего количества» и подзапрос для «количества по салону»

sql
SELECT bs.title AS salon_name,
       svc_count.services_count,
       ROUND(
         svc_count.services_count * 100.0 
         / (SELECT SUM(svc_count2.services_count)
            FROM (
                SELECT bs2.id_salon, COUNT(o2.id_order) AS services_count
                FROM beauty_salon bs2
                JOIN orders o2 
                  ON bs2.id_salon = o2.id_salon
                WHERE o2.date >= DATE_TRUNC('year', CURRENT_DATE) - INTERVAL '1 year'
                  AND o2.date <  DATE_TRUNC('year', CURRENT_DATE)
                GROUP BY bs2.id_salon
            ) AS svc_count2
           ),
         2
       ) AS percentage
FROM beauty_salon bs
JOIN (
    SELECT bs1.id_salon, COUNT(o1.id_order) AS services_count
    FROM beauty_salon bs1
    JOIN orders o1 
      ON bs1.id_salon = o1.id_salon
    WHERE o1.date >= DATE_TRUNC('year', CURRENT_DATE) - INTERVAL '1 year'
      AND o1.date <  DATE_TRUNC('year', CURRENT_DATE)
    GROUP BY bs1.id_salon
) AS svc_count
  ON svc_count.id_salon = bs.id_salon;

Вариант 2: использование оконных функций (без GROUP BY и без CTE)

Однако придётся «отсеивать» повторяющиеся строки. Можно сделать так:

sql
SELECT salon_name,
       services_count,
       ROUND(100.0 * services_count / total_all, 2) AS percentage
FROM (
    SELECT 
        bs.title AS salon_name,
        -- Считаем число оказанных услуг по каждому салону
        COUNT(o.id_order) OVER (PARTITION BY bs.id_salon) AS services_count,
        
        -- Общее число по всем салонам:
        SUM(COUNT(o.id_order)) OVER () AS total_all,
        
        -- Чтобы вывести лишь 1 строку на каждый салон
        ROW_NUMBER() OVER (PARTITION BY bs.id_salon ORDER BY bs.id_salon) AS rn
    FROM beauty_salon bs
    JOIN orders o 
      ON bs.id_salon = o.id_salon
    WHERE o.date >= DATE_TRUNC('year', CURRENT_DATE) - INTERVAL '1 year'
      AND o.date <  DATE_TRUNC('year', CURRENT_DATE)
) AS sub
WHERE sub.rn = 1;

Тут:

• COUNT(o.id_order) OVER (PARTITION BY bs.id_salon) даёт нам «число услуг по конкретному салону».
• SUM(COUNT(o.id_order)) OVER () в оконной агрегации даёт сумму «число услуг по салонам» без отдельного GROUP BY.
• ROW_NUMBER() OVER (PARTITION BY ...) = 1 оставляет одну строку на салон.

---

Резюме

Все представленные запросы:

• Избегают явного использования WITH ... (CTE).
• По возможности не используют GROUP BY и DISTINCT, заменяя их на оконные функции (OVER (PARTITION BY ...)) и приём с ROW_NUMBER() = 1 или RANK().
• Там, где изначально не было CTE/GROUP BY, приведены альтернативы (например, через LEFT JOIN вместо NOT EXISTS или через generate_series вместо рекурсивного CTE).

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