Аналитика FM
20 постов
Если вы хоть немного следите за развитием искусственного интеллекта, то наверняка замечали: терминов становится всё больше.
И происходит путаница, подмена понятий. И вообще не понятно "что было первым: курица или яйцо"
В моем канале Аналитика FM выпуски про бизнесовые метрики в разных бизнесах, про особенности SQL запросов и работы аналитика.
Канал я веду с нуля подписчиков, рассказываю про аналитику и разбираю различные кейсы на реальных примерах.
И серия постов про путь до ai агентов.
Подписывайся, если интересно как устроен мир аналитика!
Какие термины этого направления окружают нас:
- Машинное обучение
- Нейросети
- Deep Learning
- Generative AI
- Foundation Models
- LLM
- AI-ассистенты
- AI-агенты
- Multi-Agent Systems
- Agentic Systems
Иногда возникает ощущение, что все это - просто разные названия одного и того же.
Но это не так.
Проблема в том, что эти термины описывают разные уровни технологий.
Одни говорят о том, как система обучается.
Другие - о том, какая модель используется.
Третьи - о том, какой продукт построен вокруг модели.
А четвёртые - уже о том, как система самостоятельно выполняет задачи и взаимодействует с другими системами.
Если сильно упростить историю, путь можно представить как движение от:
Научить компьютер находить закономерности
к:
Научить компьютер самостоятельно решать сложные задачи
Сначала компьютеры просто выполняли инструкции, которые заранее написал человек.
Потом появились методы машинного обучения, где система могла находить закономерности в данных.
Затем развивались модели, способные работать с гораздо более сложными типами информации: изображениями, текстом, речью, видео.
С развитием глубоких нейронных сетей появились современные генеративные модели, которые научились не только классифицировать или прогнозировать, но и создавать новый контент.
Дальше появились большие универсальные модели, которые можно использовать как основу для множества разных задач.
И наконец вокруг моделей начали строить полноценные приложения и системы: с памятью, инструментами, базами данных, API и возможностью выполнять действия.
Так постепенно мы пришли к тому, что сегодня называют AI-агентами.
Представим обычную языковую модель.
Мы пишем:
Проанализируй эти данные и найди закономерности
Модель анализирует то, что ей дали, и возвращает ответ.
Теперь представим другую систему.
Мы говорим:
Каждое утро проверяй продажи. Если найдёшь аномалию - выясни причину и подготовь отчёт
Такая система уже может:
получить данные
обратиться к базе
выполнить запрос
проанализировать результат
понять, что делать дальше
использовать дополнительные инструменты
проверить результат
сформировать отчёт
отправить его человеку
То есть между "моделью, которая отвечает" и "системой, которая выполняет задачу" появляется целый набор дополнительных компонентов.
И именно этот переход сейчас особенно интересен.
Когда мы говорим "искусственный интеллект", мы часто представляем что-то единое.
На практике это скорее большая экосистема.
Внутри неё находятся:
методы обучения
алгоритмы
модели
нейронные сети
генеративные модели
большие языковые и мультимодальные модели
приложения
ассистенты
инструменты
агенты
системы из нескольких агентов
И всё это может работать вместе.
Например, современный AI-агент может использовать языковую модель, обращаться к базе данных, вызывать API, читать документы, хранить состояние задачи и передавать результат другому агенту.
Поэтому, когда говорят:
Компания внедряет AI
это ещё почти ничего не говорит о том, что именно они внедряют.
Это может быть обычная ML-модель для прогнозирования.
Может быть генеративная модель.
Может быть чат-ассистент.
А может быть целая агентная система, которая выполняет бизнес-процесс.
Чем дальше мы двигаемся от модели к агентной системе, тем меньше AI выглядит как отдельный инструмент и тем больше - как участник рабочего процесса.
Модель:
отвечает.
Ассистент:
помогает.
Агент:
действует.
Агентная система:
может организовывать выполнение целого процесса.
Именно поэтому сейчас так много разговоров об AI-агентах.
Но чтобы действительно понимать, что они собой представляют, полезно сначала разобраться, из каких уровней вообще состоит эта технология.
Я как раз решил разобрать этот путь последовательно - от самых фундаментальных понятий до современных агентных систем.
Не одним огромным постом на 20 экранов, а серией коротких разборов, где каждый следующий уровень будет опираться на предыдущий.
📌 От машинного обучения и понятия модели - к нейросетям, генеративному AI, LLM, AI-приложениям, ассистентам, агентам и в итоге к Agentic Systems.
Подписывайся на мой телеграмм канала Аналитика FM!
Будем разбираться вместе!
Плюс там различные нюансы и особенности работы аналитика.
Если вы работаете с базой данных и начали заглядывать не только в обычные SELECT, рано или поздно встретите два слова: функция и процедура.
На первый взгляд они практически близнецы.
И там, и там можно объявить переменные, поставить условия, сделать запрос к таблице, организовать циклы и вообще спрятать довольно большую часть логики внутри одного объекта.
Тогда возникает вполне логичный вопрос:
а зачем вообще два разных объекта, если они умеют примерно одно и то же?
А в моем канале Аналитика FM выпуски про бизнесовые метрики в разных бизнесах, про особенности SQLзапросов и работы аналитика.
Канал я веду с нуля подписчиков, рассказываю про аналитику и разбираю различные кейсы на реальных примерах.
Подписывайся, если интересно как устроен мир аналитика!
Разница на самом деле довольно простая.
Функция нужна тогда, когда мы хотим что-то получить в результате.
Процедура - когда нам нужно что-то сделать.
Например, представим, что в базе есть таблица клиентов, а нам нужно определить, является ли клиент активным.
Можно сделать функцию:
CREATE OR REPLACE FUNCTION is_active_client( p_client_id NUMBER )
RETURN NUMBER IS v_status VARCHAR2(20);
BEGIN SELECT status
INTO v_status
FROM clients
WHERE client_id = p_client_id;
IF v_status = 'ACTIVE' THEN RETURN 1;
ELSE RETURN 0;
END IF;
END;
Здесь функция получает client_id, что-то делает внутри и обязательно возвращает результат.
Поэтому её можно использовать непосредственно в SQL:
SELECT client_id, is_active_client(client_id) AS is_active FROM clients;
Получается довольно естественная конструкция:
«Вот тебе клиент. Скажи, активный он или нет».
Функция ответила — 1 или 0.
А теперь представим совершенно другую задачу.
Нам нужно массово обновить статус клиентов, записать информацию об операции в журнал и, возможно, выполнить ещё несколько действий.
Для этого больше подходит процедура:
CREATE OR REPLACE PROCEDURE update_client_status(
p_client_id NUMBER,
p_status VARCHAR2 )
IS BEGIN
UPDATE clients
SET status = p_status
WHERE client_id = p_client_id;
INSERT INTO client_log(client_id, action_date)
VALUES (p_client_id, SYSDATE);
END;
Здесь нам не нужно спрашивать у процедуры:
«Какой результат ты мне вернёшь?»
Мы говорим:
«Возьми этого клиента, измени ему статус и запиши информацию об изменении».
То есть процедура выполняет действие.
И вот здесь появляется важное отличие.
У функции есть RETURN.
Например:
RETURN NUMBER
Она может вернуть:
число;
строку;
дату;
другой тип данных;
иногда даже сложный объект.
Поэтому функция хорошо подходит для вычислений и получения какого-то значения.
Например:
SELECT calculate_revenue(client_id) FROM clients;
или:
SELECT order_id, calculate_discount(order_id) AS discount FROM orders;
Процедура может:
INSERT
UPDATE
DELETE
вызывать другие процедуры и функции, работать с переменными, условиями, циклами и выполнять достаточно сложную бизнес-логику.
Вызов процедуры выглядит иначе:
BEGIN
update_client_status(123, 'ACTIVE');
END;
Мы не используем её как обычное значение внутри SELECT.
Мы просто запускаем действие.
И здесь есть интересный нюанс.
Процедура тоже может что-то вернуть через OUT-параметры.
Поэтому говорить:
"процедура ничего не возвращает"
не совсем корректно.
Она может передать вызывающему коду результаты своей работы.
Но концептуально разница остаётся:
функция отвечает на вопрос "что получилось?"
процедура отвечает на вопрос "что нужно сделать?"
Вот здесь начинается самое интересное.
Представьте, что правило расчёта скидки используется в десяти разных местах системы.
Можно десять раз написать/запустить один и тот же SQL запрос.
Но тогда однажды бизнес скажет:
"Теперь скидка считается по новым правилам".
И начинается веселье.
Нужно найти все десять мест и исправить логику.
Вместо этого можно вынести правило в функцию:
calculate_discount(...)
И теперь разные запросы используют одну и ту же логику.
Изменили функцию - изменилось правило расчёта в одном месте.
С процедурами похожая история.
Если в компании есть сложная последовательность действий, её можно спрятать за одной процедурой.
Например:
создать договор → записать клиента → создать связанные записи → записать информацию в журнал → изменить статус
Вместо того чтобы каждый разработчик реализовывал всё это самостоятельно, можно вызвать одну процедуру, которая уже знает, как именно компания должна выполнить эту операцию.
И вот поэтому функции и процедуры в Oracle - это не просто "два разных вида".
Это способ собрать бизнес-логику внутри базы и переиспользовать её.
При этом аналитику не обязательно каждый день создавать процедуры и функции.
Но понимать их очень полезно.
Если вам интересны именно такие нюансы - не только синтаксис, но и то, как всё это устроено в реальной работе аналитика, - я разбираю их в своём Telegram-канале "Аналитика FM". Там как раз про SQL, данные и те самые моменты, на которых чаще всего приходится останавливаться и разбираться.
Когда мы разрабатываем систему, чаще всего тестируем её на небольшом объёме данных: несколько десятков или сотен записей. Но в реальной эксплуатации база может содержать миллионы строк, а одновременно системой могут пользоваться тысячи пользователей.
Именно поэтому перед вводом системы в эксплуатацию проводят нагрузочное тестирование.
В канале Аналитика FM я публикую реальные запросы SQL с разбором логики. Обсуждаем продуктовые метрики и как правильно строить аналитику данных.
Канал веду с нуля подписчиков.
Подписывайся, если тоже хочешь вникнуть в прекрасный мир аналитики.
Нагрузочное тестирование - это проверка работы системы под нагрузкой, максимально приближенной к реальной.
Его цель - ответить на вопросы:
Сколько пользователей одновременно выдержит система?
Как быстро будут выполняться запросы?
Как изменится производительность при увеличении объёма данных?
Не начнёт ли база данных работать значительно медленнее?
Не возникнут ли ошибки из-за нехватки памяти, места во временном табличном пространстве или перегрузки процессора?
Например, запрос, который за 0,1 секунды обрабатывает 100 строк, может выполняться несколько минут при таблице в 100 миллионов записей.
Поэтому проверять производительность необходимо именно на объёмах, близких к реальным.
Проверяется работа системы при обычной ожидаемой нагрузке.
Например:
одновременно работают 500 пользователей;
таблица содержит 10 миллионов записей.
На систему специально подают нагрузку выше расчётной.
Цель - определить предел её возможностей и понять, как она поведёт себя при перегрузке.
Проверяется влияние количества данных на производительность.
Например:
запрос работает с таблицей из 100 тыс. строк;
затем с 10 млн;
затем со 100 млн.
Система работает под постоянной нагрузкой несколько часов или даже суток.
Проверяют, не возникает ли утечек памяти и деградации производительности.
Самый простой способ - сгенерировать тестовые записи прямо средствами Oracle.
Например:
SELECT 'ООО Ромашка ' || LEVEL AS name,
7700000000 + LEVEL AS inn,
1027700000000 + LEVEL AS ogrn
FROM dual
CONNECT BY LEVEL <= 1000000;
Этот запрос создаст 1 миллион строк без использования каких-либо таблиц.
И так вы сможете подготовить базу с наполненными данными для тестирования нагрузки.
Иногда такого подхода не хватает, и данные должны быть консистентными, иметь логическую зависимость от других параметров. Но это уже более глубокая семантика нагрузочного тестирования.
А мы с вами начинаем познавать увлекательный мир аналитики и данных.
Разбор скрипта проведем в канале Аналитика FM.
Подписывайся, чтобы узнавать техническую сторону работы аналитика.
Представьте дерево. У него есть корень, от него отходят ветки, от больших веток - более мелкие, а затем листья.
Примерно так же устроены иерархические справочники в информационных системах.
И как же можно понять: что есть ветка, а что есть лист в этом иерархическом справочнике?
В канале Аналитика FM я часто разбираю такие ситуации - когда задача вроде решаема, но без нормальной структуры превращается в кашу.
Например:
📁 Транспорт
├── Легковой транспорт
│ ├── Седаны
│ └── Кроссоверы
└── Грузовой транспорт
├── Малотоннажный
└── Тягачи
Или:
📁 Товары
├── Электроника
│ ├── Телефоны
│ └── Ноутбуки
└── Бытовая техника
├── Холодильники
└── Стиральные машины
На самом деле всё гораздо проще, чем кажется.
Обычно таблица справочника выглядит примерно так:
| id | name | parent_id |
| --- | ----------------------------------- | --------------- |
| 1 | Транспорт | NULL |
| 2 | Легковой транспорт | 1 |
| 3 | Грузовой транспорт | 1 |
| 4 | Седаны | 2 |
| 5 | Кроссоверы | 2 |
| 6 | Тягачи | 3 |
Структурно это выглядит так:
1 Транспорт
├── 2 Легковой транспорт
│ ├── 4 Седаны
│ └── 5 Кроссоверы
└── 3 Грузовой транспорт
└── 6 Тягачи
Каждая запись имеет:
id - собственный идентификатор;
parent_id - идентификатор родительского элемента.
Например:
id = 4
name = Седаны
parent_id = 2
Это означает:
Седаны → Легковой транспорт → Транспорт
Именно благодаря полю parent_id база понимает, что "Седаны" и "Кроссоверы" относятся к одной ветке дерева.
Если подниматься по родителям вверх, то рано или поздно мы придём к общему узлу - корню ветки.
Получается, что вся иерархия строится буквально на одном поле: parent_id
Они позволяют хранить данные не просто списком, а показывать связи между объектами.
Благодаря этому можно:
✅ группировать данные;
✅ строить отчёты по категориям;
✅ наследовать свойства от родительских узлов;
✅ задавать правила сразу для целой ветки;
✅ быстро находить все дочерние элементы.
Например, если правило применяется ко всей категории "Легковой транспорт", то оно автоматически действует и для седанов, и для кроссоверов, и для любых новых подкатегорий, которые появятся позже.
📌 MDM-системы (Master Data Management);
📌 каталоги товаров интернет-магазинов;
📌 банковские и страховые системы;
📌 ERP и CRM;
📌 классификаторы услуг и продуктов;
📌 организационная структура компании;
📌 государственные классификаторы и справочники.
✔ Гибкость. Можно добавлять новые ветки без изменения структуры данных.
✔ Удобная аналитика. Легко получить данные как по конкретному элементу, так и по всей категории.
✔ Наследование правил. Одно правило может применяться сразу к тысячам объектов.
✔ Масштабируемость. Структура может содержать десятки и сотни уровней вложенности.
❌ Сложность запросов. Иногда, чтобы найти всех потомков или родителей, приходится строить рекурсивные запросы.
❌ Производительность. Глубокие иерархии могут существенно замедлять выполнение запросов.
❌ Риск циклических ссылок. Если по ошибке сделать узел потомком самого себя, можно получить бесконечный цикл.
❌ Сложность сопровождения. Изменение структуры верхних уровней может затронуть большое количество дочерних элементов.
При работе с иерархическими справочниками чаще всего приходится решать четыре задачи:
🔹 найти всех потомков узла;
🔹 найти всех родителей элемента;
🔹 определить, принадлежит ли элемент определённой ветке;
🔹 определить, к какому верхнему узлу относится конкретный элемент.
В Oracle для этого используются специальные иерархические запросы:
START WITH ...
CONNECT BY ...
Именно они позволяют "обходить дерево" вверх или вниз по веткам.
В канале Аналитика FM (клик :-) ) уже готов пост про конструкцию START WITH и CONNECT BY.
Подписывайся, если интересно разбираться в особенностях работы аналитика.
Иерархический справочник - это не просто список значений. Это способ описать реальные взаимосвязи между объектами и сделать систему более гибкой и управляемой.
А одна маленькая колонка parent_id превращает обычную таблицу в целое дерево данных.
Если ты когда-нибудь писал длинный SQL-запрос и в какой-то момент ловил себя на мысли:
"Я уже сам не понимаю, что здесь происходит" - поздравляю, ты подошёл к моменту, где появляются временные таблицы.
В канале Аналитика FM я часто разбираю такие ситуации - когда задача вроде решаема, но без нормальной структуры превращается в кашу.
Это обычная таблица…
только с одним отличием:
👉 она живёт временно и потом исчезает
Ты создаёшь её:
чтобы сохранить промежуточный результат
поработать с ним
и не засорять основную базу
Тебе нужно:
взять заказы
отфильтровать только оплаченные
посчитать выручку
добавить сегментацию пользователей
ещё пару условий сверху
Можно написать один огромный запрос.
А можно сделать по-другому:
Сначала собрать "чистые заказы"
Потом на их основе считать метрики
Потом добавлять бизнес-логику
И вот тут временные таблицы начинают играть.
Как это выглядит
CREATE TEMP TABLE temp_orders AS
SELECT *
FROM orders
WHERE status = 'paid';
Создаем промежуточный слой данных.
А потом работаем уже с ним.
SELECT user_id, SUM(amount)
FROM temp_orders
GROUP BY user_id;
Вместо одного "монстра":
ты разбиваешь задачу на шаги
каждый шаг понятен
легче дебажить
Если один и тот же кусок данных нужен несколько раз:
не нужно каждый раз пересчитывать
можно сохранить и использовать
Иногда:
тяжёлый JOIN
сложная фильтрация
👉 выгодно посчитать один раз и сохранить результат
Если ты создашь обычную таблицу:
она останется
её надо потом удалять
она может мешать другим
Временная таблица:
живёт в рамках сессии
автоматически исчезает
сложные аналитические расчёты
многоступенчатые преобразования данных
работа с "грязными" данными
отладка логики
Временные таблицы - это не единственный инструмент.
Есть ещё:
CTE (WITH)
подзапросы
Но:
👉 CTE - это "логика в одном запросе"
👉 временные таблицы - это "разбивка на реальные шаги"
Иногда CTE читается тяжело.
А временные таблицы дают ощущение "пайплайна".
создают временные таблицы без необходимости
забывают, что они завязаны на сессию
используют их там, где проще CTE
То есть это инструмент - не серебряная пуля.
Самая простая мысль
Временная таблица - это способ остановиться посередине запроса и зафиксировать результат
И иногда именно это спасает:
читаемость
производительность
и твои нервы
В канале Аналитика FM (клик :-) )я рассказываю про продуктовые метрики в разных бизнесах. В чем особенности и нюансы. Серия постов про средний чек уже готова.
Подписывайся, если интересно интересно разбираться в особенностях работы аналитика.
Представь обычную ситуацию:
Есть клиент, сегодня он живет в Москве
| user_id | city |
| ----------- | ------------- |
| 1 | Москва |
Проходит время, он переезжает в Санкт-Петербург
Ты обновляешь данные
| user_id | city |
| ----------- | ---------------------------- |
| 1 | Санкт-Петербург|
И вроде всё ок.
Но потом приходит задача:
👉 А посчитай выручку по городам за прошлый год
И тут начинается самое интересное.
А в моем канале Аналитика FM выпуски про расчет Cohort Retention в разных бизнесах.
Канал я веду с нуля подписчиков, рассказываю про аналитику и разбираю различные кейсы на реальных примерах.
Подписывайся, если интересно как устроен мир аналитика!
Если ты просто возьмешь текущие данные, то все заказы пользователя "уедут " в Санкт-Петербург. Даже те, которые он делал, когда жил в Москве.
И аналитика начнёт врать.
Не потому что ты ошибся.
А потому что данные потеряли свою историю.
SCD (Slowly Changing Dimension) - это способ хранить изменения так,
чтобы ты мог ответить не только на вопрос:
👉 Как сейчас?
но и на более важный:
👉 Как было в момент события?
Как будет выглядеть: вместо одной строки в таблице будет:
| user_id | city | start_date | end_date |
| ------------ | --------------------------- | ----------------- | -------------------- |
| 1 | Москва | 2024-01-01 | 2025-01-01 |
| 1 | Санкт-Петербург| 2025-01-01 | NULL |
Теперь у нас есть не просто данные,
а контекст во времени.
Потому что почти всё в бизнесе меняется:
клиенты переходят между сегментами
продукты меняют категории
условия договоров обновляются
статусы живут своей жизнью
И если ты смотришь только на "сейчас" - ты теряешь половину смысла.
SCD - это не про таблицы.
Это про мышление.
Когда ты начинаешь задавать вопросы так:
А на момент события это было актуально?
А не поменялось ли это потом?
- ты переходишь на другой уровень понимания данных.
Берут текущие данные
и применяют их к прошлым событиям.
И получается:
красивые отчёты
аккуратные цифры
полностью неверные выводы
Данные без времени - это половина правды
SCD - это как раз про то, чтобы эту вторую половину не потерять.
И если тебе интересно разбираться в таких вещах глубже -
не просто "как написать SELECT", а как думать про данные,
в Аналитика FM я как раз про это и пишу.
Или превращение длинной таблицы в широкую
В канале Аналитика FM я часто про это пишу - потому что аналитика заканчивается не на запросе, а на том, как ты показал результат.
Подписывайся!
Представь, у тебя есть данные:
| user_id | metric | value |
| ----------- | ------------- | -------- |
| 1 | revenue | 100 |
| 1 | orders | 2 |
Это длинная таблица.
Она удобна для хранения:
гибкая
легко добавлять новые метрики
хорошо ложится в модели данных
Но попробуй быстро понять:
кто сколько потратил
у кого сколько заказов
и сравнить это между собой
Неудобно.
А теперь та же информация:
| user_id | revenue | orders |
| ------------ | ------------- | ---------- |
| 1 | 100 | 2 |
Это широкая таблица.
И вот тут уже:
метрики рядом
сравнение - в одну секунду
можно считать новые показатели
Это значит:
взять значения из строк и разложить их по колонкам
То есть:
metric → становится названиями колонок
value → становится значениями в этих колонках
Ты буквально "разворачиваешь" данные.
На самом деле, это и есть pivot.
Слово pivot - это "поворот".
Ты поворачиваешь таблицу так, чтобы:
строки стали колонками
данные стали наглядными
Если ты работал в Excel - ты это уже делал:
сводная таблица = pivot table.
В SQL это можно реализовать так:
SELECT
user_id,
SUM(CASE WHEN metric = 'revenue' THEN value END) AS revenue,
SUM(CASE WHEN metric = 'orders' THEN value END) AS orders
FROM table
GROUP BY user_id;
Потому что аналитика - это не про "достать данные".
Это про сделать их понятными.
Широкая таблица нужна, когда ты:
строишь отчёт
показываешь результат бизнесу
считаешь метрики между собой
Длинная таблица - когда:
хранишь данные
работаешь с событиями
строишь модели
Самая частая ошибка - пытаться всё делать в широком формате.
Это ломает гибкость:
добавилась новая метрика → переписывай запрос
данные перестают масштабироваться
Правильный подход:
храним - в длинном виде
показываем - в широком
Длинная таблица - это про хранение
Широкая таблица - это про понимание
И pivot - это просто инструмент, который помогает перейти от одного к другому.
И если ты хочешь не просто писать SQL, а реально чувствовать данные и понимать, как их правильно показывать,
в Аналитика FM я как раз разбираю такие вещи - простым языком, но с реальным смыслом.
Если ты только начинаешь разбираться в данных, то очень быстро сталкиваешься с кучей аббревиатур.
DDL, DML, ещё что-то… И кажется, что это какие-то сложные термины из учебника.
Но на самом деле всё гораздо проще.
И в канале Аналитика FM я как раз стараюсь разбирать такие вещи без заумных формулировок - через логику и реальные сценарии.
есть стены
есть комнаты
есть мебель
И есть вещи, которые ты туда кладёшь.
Так вот:
👉 DDL - это про квартиру
👉 DML - это про вещи внутри неё
DDL (Data Definition Language) - это команды, которые создают и изменяют структуру базы.
То есть всё, что связано с "построить" или "переделать".
CREATE TABLE users (...);
ALTER TABLE users ADD COLUMN age INT;
DROP TABLE users;
CREATE - ты создал новую "комнату"
ALTER - передвинул стену или добавил полку
DROP - снёс всё к чертям
📌 Важно:
DDL не трогает сами данные.
Он создаёт условия, где эти данные будут жить.
DML (Data Manipulation Language) - это уже про работу с данными.
SELECT * FROM users;
INSERT INTO users VALUES (...);
UPDATE users SET age = 30;
DELETE FROM users WHERE id = 1;
Это то, что делает аналитик каждый день:
посмотрел данные (SELECT)
добавил (INSERT)
изменил (UPDATE)
удалил (DELETE)
📌 Здесь ты уже работаешь не с "комнатой", а с тем, что внутри неё.
Не в терминах, а в сути:
DDL отвечает на вопрос: Как устроены данные?
DML отвечает на вопрос: Что происходит с данными?
Тебе нужно посчитать метрику.
Но:
нет нужной таблицы
не хватает колонок
данные лежат неудобно
👉 Тогда сначала приходит DDL:
создают таблицу, добавляют поля, настраивают структуру.
И только потом приходит DML:
ты пишешь SELECT, считаешь, анализируешь.
DDL и DML - это не просто разные команды.
Это разные уровни ответственности.
DDL чаще делают разработчики, инженеры, архитекторы
DML - это зона аналитиков
Но хороший аналитик всё равно должен понимать DDL.
Иначе он не понимает, почему данные лежат именно так.
DDL обычно:
применяется сразу
сложнее откатывается
DML:
можно обернуть в транзакцию
можно отменить
Это важно, когда ты начинаешь работать не только с SELECT, но и с изменением данных.
DDL - это "построить систему"
DML - это "жить внутри неё и работать с данными"
Если ты хочешь начать действительно понимать данные, а не просто писать запросы -
такие базовые вещи дают фундамент.В канале Аналитика FM я как раз разбираю такие темы:
без усложнений, но с пониманием того, как это работает в реальной работе аналитика.Разбор метрик Retention и Revenue в разных сферах бизнеса уже в канале.
Подписывайся!
