0,0
рейтинг
18 января в 12:32

Разработка → Заметки о SQL и реляционной алгебре



На Хабре и за его пределами часто обсуждают реляционную алгебру и SQL, но далеко не так часто акцентируют внимание на связи между этими формализмами. В данной статье мы отправимся к самым корням теории запросов: реляционному исчислению, реляционной алгебре и языку SQL. Мы разберем их на простых примерах, а также увидим, что бывает полезно переключаться между формализмами для анализа и написания запросов.

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

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

Содержание


Реляционная алгебра


Основные операторы


A — само отношение А (отношение здесь синонимично с таблицей и предикатом) является выражением реляционной алгебры, более того, так как это алгебра, любое выражение реляционной алгебры возвращает отношение (свойство замыкания операторов)

Selection (выборка; ограничение)


\sigma_\phi (A) — selection (выборка; ограничение), A — отношение (предикат, таблица), \phi – булева формула, по которой происходит отбор строк (кортежей, записей, etc)

Selection является по сути горизонтальным фильтром строк, т.е., можно представить, что мы идем по каждой строке и оставляем только те, что удовлетворяют условию \phi. Простой пример для наглядности:

Projection (проекция)


\Large \pi_{a,b,\dots}(A) — projection (проекция) на атрибуты A, B, …. Возвращает таблицу, в которой остаются только колонки (атрибуты) A, B, …. Простой пример ниже. По сути является фильтром по атрибутам т.е. это в некотором смысле вертикальный фильтр.

Переименование


\rho_{a,b} (A) — переименовывает колонку a в b в отношении A (атрибут, аргумент предиката, etc); два чая тому господину, который покажет, что алгебра строго более выразима с оператором переименования (нужно привести пример запроса, который не выразим без этого оператора, но выразим с \rho)

Декартово произведение


A \times B — Декартово произведение двух отношений, большое отношение из всевозможных сочетаний строк в A и B.

Операции над множествами


Реляционная алгебра является расширением классического набора операторов над множествами (отношение — это множество упорядоченных кортежей; заметьте, что это совсем не равно упорядоченному множеству кортежей). Пусть у нас есть таблица StudentMark(Name, Mark, Subject, Date) – тогда кортеж (Вася, 5, Информатика, 05.10.2010) является упорядоченным – сначала строка Name на первой (ок, или нулевой) позиции, целое число на второй, строка на третьей и дата на четвертой. При этом сами упорядоченные кортежи (Name, Mark, Subject, Date) не упорядочены «внутри» отношения.

Объединение


A \cup B — объединение всех строк в A и B, ограничение — одинаковые аттрибуты

Пересечение


A \cap B — пересечение строк, такое же ограничение

Разница множеств


B \backslash A — B минус A, все строки, что присутствуют в B, но не присутствуют в A, такое же ограничение

(B\A; A — слева, B — справа)

Вспомогательные операторы


A \bowtie_{\phi} B \equiv \sigma_{\phi} (A \times B) — join (соединение); join соединяет две записи таблиц A и B, при условии, что для этих двух записей выполнено условие φ.

Задачи для разогрева


Мы будем работать со следующей схемой

(Схема взята из книги: Elmasri, Navathe – Fundamentals of Database systems; на всякий: крайне НЕ рекомендую книгу; см подборку в конце)

Далее рассмотрим несколько простых задач на реляционную алгебру.

Задача первая. Вывести имена всех работников 5го департамента, которые работают более 10 часов в неделю над проектом Х.

(Промежуточные результаты можно «сохранять» в новых отношениях, но это не обязательно.)
Решение первой задачи. Реляционная алгебра


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


Задача третья потребует использования нового оператора — «агрегация». Рассмотрим его на примере:

Для каждого проекта вывести название и общее число часов в неделю, которое все работники тратят на этот проект.
Решение третьей задачи. Реляционная алгебра


Заметим, что запрос имеет вид a F b (A), где a, b — колонки, A — отношение, а – агрегационная функция (например, SUM, MIN, MAX, COUNT, etc). Читается следующим образом: для каждого значения в колонке а, посчитай b. То есть одному значению в колонке a может соотвестовать несколько строк, поместим значения колонки b из этого множества строк в функцию и создадим новый атрибут fun_b с соотвествующим значением.

Данный запрос не выразим в «классической» реляционной алгебре (без оператора агрегации F). То есть, нельзя написать единственный запрос, который бы для любой базы данных, удовлетворяющей схеме, выдавал бы правильный ответ.

Откуда в точности следует данные результат мы разберем позднее, сейчас можно лишь отметить, что запросы с агрегацией принадлежат более высокому классу вычислительной сложности.

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

SQL


В данной части мы поговорим о SQL (Structured Query Language) и покажем, как SQL соответствует реляционной алгебре на простых примерах.

Рассмотрим самую первую задачу еще раз:

Задача первая. Вывести имена всех работников 5го департамента, которые работают более 10 часов в неделю над проектом Х.

Классическое решение выглядит следующим образом:
Классическое решение.



Альтернативно можно написать вот так:
Немного альтернативно.




Или совсем альтернативно:
С подзапросом



(далее решения не убраны под спойлеры)

Проводим аналогию между SQL и реляционной алгеброй



На втором решении мы видим отчетливую аналогию c реляционной алгеброй:

Теперь используем равенство для join и увидим аналогию между SQL и реляционной алгеброй в первом решении

Как бы это не было иронично, но SELECT в SQL — это project (π; проекция) в реляционной алгебре.

Теперь рассмотрим задачу с агрегацией и сравним её с решением на реляционной алгебре:

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

Реляционное исчисление


Внимательный читатель сейчас мог бы воскликнуть: для чего козе баян? Нам тут что не хватает двух формализмов для написания запросов, к чему третий?

Реляционное исчисление — это адаптация логики первого порядка (FOL: first order logic) для написания запросов. FOL является одним из самых хорошо изученных формализмов математики и даёт возможность использовать уже созданный теоретический аппарат и классические результаты для анализа и написания запросов.

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

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

Пусть φ(Х) — формула первого порядка, а X — это свободные переменные, т.е., они не квантифицированы (∀ – квантор всеобщности, ∃ – квантор существования), тогда запрос в реляционном исчислении задает множество:

{ X | φ(Х) }

Рассмотрим простые примеры, на которых и разберем формализм:

Пусть R – отношение с тремя атрибутами a,b,c; тогда перепишем следующий запрос реляционной алгебры:

\sigma_{a=b}(R(a,b,c)) в реляционном исчислении как:

{ r.a, r.b, r.c | R and r.a = r.c }

Переводя на простой язык r — это кортеж в R (то есть строка с атрибутами, значения которых можно получить через точку по имени, i.e., r.a — атрибут а кортежа r (строки) в отношении R (таблице)). Как мы видим никаких кванторов здесь нет, так как r — на выходе запроса и должен быть свободным кортежем.

Рассмотрим еще один простой пример: R(a,b,c) ∗ S(c,d,e), где * — это natural join, т.е. join по имени – в качестве условия объединения берут атрибуты с одинаковым именем.

{ r.A, r.B, r.C, s.D, s.E | R and S(s) and r.C = s.C}

Если бы s.D и S.e не было среди выходных параметров, запрос бы имел следующий вид:

{ r.A, r.B, r.C | R and ∃s: S(s) and r.C = s.C}

Мы были бы обязаны поставить квантор существования, так как S содержится только в «теле» запроса.

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

{ r.A | R and ∀s: S(s) and r.C = s.C and s.E = «банан»}

То, данный запрос всегда будет возвращать пустое множество, так как для того, чтобы условия запроса было выполнено необходимо, чтобы каждый кортеж в мире длины три принадлежал S и имел в качестве значения последнего атрибута «банан».

Обычно вместе с квантором всеобщности используют импликацию «=>», мы можем переписать запрос следующим образом:

{ r.A | R and ∀s: (S(s) and r.C = s.C) => s.E = «банан»}

Если s принадлежит S и значения C совпадает с C в R, тогда последний атрибут должен иметь значение «банан».

Здесь можно найти краткую подборку задач на реляционное исчисление с решениями.

Равенство формализмов (теорема Кодда)


Говоря простым языком, теорема Кодда звучит так: все три формализма SQL, реляционная алгебра и реляционное исчисление равны. Вот тут много теории для заинтересовавшихся

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

Conjunctive Queries (CQ)


Запросы, которые состоят из select(σ)-project(π)-join(⋈) сегмента реляционной алгебры называют conjunctive queries (ок, я опустил переименование, считаем его неявно присутствующим).

Если вы дочитали до этой строки попробуйте решить следующую задачу используя только эти три оператора (ну и отношения конечно же):

Задача. Выведите имена всех работников, которые работают над каждым проектом.

Решение
Это невозможно. Почему читаем далее.

Подумайте какому сегменту SQL и реляционного исчисления относится данный класс реляционной алгебры.

Вычислительная сложность


Существует несколько различных способов измерить вычислительную сложность выполнения запроса, между ними часто путаются поэтому выпишем определения и их названия:

Пусть Q — запрос, D — база данных, и нужно вычислить Q(D)
  • Если Q — фиксировано, то сложность вычисления f(D) называется сложностью по данным (data complexity)
  • Если D — фиксировано, то сложность вычисления f(Q) называется сложностью запроса (query complexity)
  • Если ничего не фиксировано, то сложность f(Q,D) называют комбинированной сложностью (combined complexity)

Важные факты: сложность SQL по данным (и всех остальных) принадлежит классу AC0 – это очень хороший класс сложности, т.е., запросы можно вычислять очень эффективно.

С теоретической точки зрения можно взглянуть на вот эту картинку:


AC0 лежит внутри NL (точнее даже внутри одного из «слоёв» NC внутри NL).

Рассмотрим следующий интересный вопрос, связанный с вычислительной сложностью: пусть f – функция выполнимости формулы, то есть для каждого запроса она говорит, существует ли база данных такая, что Q(D) истинно. Из теоремы Кодда мы знаем, что реляционная алгебра и SQL эквиваленты реляционному исчислению. А значит, вычисление f – эквивалентно проблеме останова (SAT для логики первого порядка невычислим). Отсюда: не существуют алгоритма, который бы для произвольного SQL запроса мог определить его непротиворечивость.

Для заинтересовавшихся также рекомендую: теорема Трахтенброта

Сложность Conjunctive Queries


CQ являются одним из самых изученных классов запросов так как они составляют всю основную массу запросов к базам данных (я видел на одной презентации цифру в 90%, но не могу сейчас найти источник). Поэтому рассмотрим подробнее их сложность и докажем, что на самом деле их комбинированная сложность равна NP, т.е. задача является NP полной. (Про NP полному можно почитать вот тут и тут.)

Для этого запишем произвольный CQ запрос в реляционном исчислении в виде:

{X | [∃X0:] p0(X0) and [∃X1:] p1(X1) and [∃X1:] p(X2) … }

Где [.] – опциональность квантора. Почему такое представление всегда допустимо? Потому что project здесь всегда может быть выражен через X т.е. X 
\subseteq \cup_i X_i, join выражен через равенство переменных в X_i, а select через условия на X_i в теле запроса.

Чтобы показать, что задача принадлежит классу NP-полных, нужно сделать две вещи
  • Показать, что задача внутри NP класса
  • Показать, что NP полная задача сводится к данной

Первое условие выполняется тривиально: так как значения отношений конечны (т.е. множество всевозможных значений), то мы можем недетерминированно «угадать» функцию \alpha такую, что делает истинными каждое отношение под кванторами существования.

Покажем, что задача о раскраске графа сводится к задаче выполнимости CQ запроса.

Пусть D состоит из одного отношения edge = {(red,green),(green,red), (blue, red), (green,blue) … } — всех возможных правильных раскрасок графа, таких что никакие две вершины не имеют одинакового цвета.

Пусть исходный граф задан в виде множества ребер \textit{edge}=\{(v_i,v_j)\}

Тогда, запишем следующий запрос

{ () | ∃X0… ∃XN: edge(V1,V2) and … edge(V_i, V_j)… }

То есть каждой дуге в исходном графе в запросе будет соответствовать отношение edge с соответствующими аргументами. Если запрос вернул пустой кортеж, то значит, что существует такая функция \alpha, которая отображает V_i \mapsto \{red,green,blue\}, причем никакие две вершины не будут иметь одинаковую расцветку (следует из определения D). Ч.Т.Д.

Вопрос со звёздочкой: из сегмента select-project-join выкидываем project, как изменится вычислительная сложность?

Транзитивное замыкание


Определения сложности по данными и по запросу также проливают свет на один известный результат — в классическом SQL (без with) транзитивное замыкание невыразимо при фиксированном запросе т.е. нельзя написать один запрос такой, что для любой базы данных он вычислял бы замыкание предиката. То есть, если у нас есть граф сохраненный в виде отношения edge, то нельзя написать один фиксированный запрос, который бы для произвольного графа вычислял отношение достижимости. Хотя интуитивно кажется, что такой запрос явно должен лежать в классе СQ.

Это можно заметить либо из вычислительной сложности «по данным», либо гораздо более конструктивно и интересно это следует из теоремы о компактности и теоремы Кодда (SQL = First Order Logic).

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

Гёдель: логика первого порядка компактна.
Кодд: SQL — логика первого порядка

Доказательство от противного, пусть T(a,b) — есть путь из а в б. P_n(a,b) — это путь из а в b длины n. Тогда ~P_n(a,b) — из а нет пути в b длины n.

Возьмем следующее конечное множество {T(a,b), ~P_1(a,b), ~P_2(a,b)… ~P_k(a,b)} — оно выполнимо, так как возьмем путь длины k+1 и T(a,b) выполнено и все ~P_1… ~P_k тоже выполнены. Более того любое конечное множество такого вида выполнимо, а значит по теореме о компактности и их бесконечное объединение должно быть выполнимо.

Однако, ~P_k — должно быть верно для ЛЮБОГО k, то есть не должно существовать пути никакой длины из а в b, а для выполнения T(a,b) такой путь должен существовать. Противоречие. Q.E.D.



Если запрос не фиксирован, то задача становится тривиально разрешимой. Пусть у меня всего k ребер в базе данных, значит самый большой путь не более k, значит можно в явном виде записать запрос, как объединение путей длины 1, 2,… k и таким образом получить запрос вычисляющий достижимость в графе.

Свойства и анализ запросов


Теперь вернемся к задаче предложенной ранее:

Выведите имена всех работников, которые работают над каждым проектом.

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

Определение, запрос Q называется монотонным, тогда и только тогда когда, для любых двух баз данных D_1 \subseteq D_2 верно, что Q(D_1) \subseteq Q(D_2). То есть увеличение базы данных может только увеличить количество кортежей на выходе или останется прежним.

Наблюдение: CQ — класс монотонно возрастающих запросов. Представим произвольный CQ запрос Q — он состоит из select-project-join. Покажем, что каждый из них является монотонным оператором:

Пусть мы добавили еще одну запись в D
  • select — фильтрует записи по вертикали, если новая запись удовлетворяет запросу, то множество ответов увеличивается, если нет остается прежним.
  • project — не влияет на дополнительный кортеж
  • join — если соответствующая запись имеется и во втором множестве, то ответное множество расширится, иначе останется прежним.

Суперпозиция монотонных операторов монотонна => CQ — класс монотонных запросов.

Вопрос: является ли исходная задача монотонной? На самом деле нет. Пусть у нас только один работник Петя, который работает над двумя проектами А и Б, и всего у нас 2 проекта А и Б, значит Петя должен быть в выдаче запроса. Пусть мы добавили третий проект C => теперь Пети нет в ответе и ответное множество пусто, а значит запрос не монотонен.

Отсюда логически следует следующий вопрос: что нужно добавить к select-project-join, чтобы задача решалась? Это что-то должно быть немонотонным!

Как конечно же читатель догадался — разница множеств. Его несимметричность как бы подсказывала нам и выделяла его с самого начала.

Однако прежде, чем писать решение сделаем еще одно наблюдение: если контр-примера к утверждению не существуют, то это утверждение всегда верно. Формально:

\forall x: p(x) \equiv \lnot \exists x: \lnot p(x) — не существует х, такой что p(x) неверен.

В задаче мы видим в явном виде квантор «для всех» и мы можем его эмулировать используя двойное отрицание, то есть перефразируем запрос следующим образом: вывести имена всех сотрудников для которых не существуют проекта, над которым они бы не работали

Этот же запрос выглядит невероятно просто, если бы у нас был \forall (а он есть в реляционном исчислении):

{ e.fname, e.lname | EMP(e) and \forall p: PRJ(p) \implies  \exists w: WORKS_ON(w) and w.Pno = p.Pnumber and e.Ssn = w.Essn}

Пример использования RA для оптимизации запросов


Также трансформация SQL в реляционную алгебру позволяет оптимизировать выполнение запроса. Рассмотрим простой пример:

Задача
Вывести все номера проектов, в которых бы работал сотрудник с фамилией Шмидт в качестве менеджера департамента, управляющего этим проектом.
оригинальная формулировка
List all project numbers for projects that involve an employee whose last name is Smith as a manager of the department that controls the project


Простое решение выглядит следующим образом:


Которое можно переписать в реляционную алгебру следующим образом:

Первая оптимизация — нужно использовать select как можно раньше, тогда Декартово произведение получит на вход отношения меньшего размера:


Select c равенством константе сильное ограничение, поэтому его нужно вычислять и соединять как можно раньше:


Сворачиваем Декартово произведение и select в join (который реализован эффективно с индексами и специализированными структурами данных)


Опускаем project как можно ниже, чтобы только необходимая информация была передана наверх по дереву


Минутка саморекламы
Есть интересные задачи по data science, big data, machine learning, data mining — пишите.


Литература, материалы и слайды


Stanford online course — Jennifer Widom – отличный курс, рекомендую

Alice’s book — Serge Abiteboul — классика жанра

Мартин Грабер — SQL — довольно простые и детальные объяснения работы алгоритмов и синтаксиса SQL

Хабра-статьи про P-NP — ознакомительный материал часть первая и вторая

Мои слайды по теме (исключительно полезно из-за примеров решений задач в разных формализмах — местами смесь голландского и английского)

Неплохие слайды по теории (нетривиальный теоретический материал)
Сергей Парамонов @varagian
карма
259,2
рейтинг 0,0
Data Scientist
Реклама помогает поддерживать и развивать наши сервисы

Подробнее
Спецпроект

Самое читаемое Разработка

Комментарии (8)

  • +2
    Материал по Реляционной Алгебре в виде простой вики страницы/студенческой шпаргалке http://iu5bmstu.ru/index.php/%D0%A2%D0%9E%D0%A0%D0%90_%289%29_-_%D0%A1%D0%B5%D0%BC%D0%B8%D0%BD%D0%B0%D1%80_%E2%84%961_-_%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8_%D1%80%D0%B5%D0%BB%D1%8F%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B9_%D0%B0%D0%BB%D0%B3%D0%B5%D0%B1%D1%80%D1%8B
  • +2
    А как в формальную логику принято транслировать outer join конструкции? Например LEFT JOIN?
    • +2
      Подвох в том, что нужно добавлять специальный элемент: «null value» ω.

      В реляционной алгебре, например вот так:
      en.wikipedia.org/wiki/Relational_algebra#Outer_joins

      В случае, если мы добавили специальный элемент ω, то можно эмулировать left outer join. Например вот так, пусть P(x,z) и Q(z,y) предикаты тогда запрос выражает left outer join (возможно, можно проще)

      { p.X p.Z, q.Y | P(p) and ( (Q(q) and q.Z = p.Z) or (not Q(q) and q.Y = ω and ~∃s: Q(s) and s.Z = p.Z) ) }

      Либо, всё хорошо и мы добавили p.X, p.Z., q.Y (существует соответствующие p.Z и q.Z), либо положи вместо q.Y null (такого Z для Q не существует).
  • +1
    два чая тому господину, который покажет, что алгебра строго более выразима с оператором переименования (нужно привести пример запроса, который не выразим без этого оператора, но выразим с )


    Зачем пример, достаточно
    ограничение — одинаковые аттрибуты


    А если брать обычный SQL, то прежде всего переименование столбцов необходимо в подзапросах для избежания совпадения имён из разных таблиц.
    • 0
      Ну ок, это ответ на один чай из двух, потому что всегда можно было бы сказать: это неправильная схема, дадим разные имена колонкам в разных таблицах и проблема решена. Но оказывается, даже это не спасает в определенных случаях (достаточно приглядеться к первой таблице внимательно, чтобы понять в каких)
  • +1
    У вас 9 раз встречается слово «картеж» и 3 раза — «кортеж». Вы уж определитесь :)

    В русском языке принято второй вариант использовать:

    https://ru.wikipedia.org/wiki/Кортеж_(информатика)
    • 0
      Спасибо, поправил :-)

Только зарегистрированные пользователи могут оставлять комментарии. Войдите, пожалуйста.