Python и SQLite: Основы работы с базами данных

Введение в модуль sqlite3: подключение к базе данных и создание курсора

Добро пожаловать в курс «Python и SQLite: Основы работы с базами данных». Это первая статья нашего цикла, и мы начнем с самого фундамента. Прежде чем строить сложные архитектуры и писать запутанные запросы, нам нужно научиться простому действию: открывать дверь в хранилище данных.

В программировании данные — это всё. Переменные в оперативной памяти живут лишь до тех пор, пока работает ваша программа. Но что делать, если вы хотите сохранить список пользователей, историю заказов или результаты игры после перезагрузки компьютера? Здесь на сцену выходят базы данных.

Почему именно SQLite?

В мире существует множество систем управления базами данных (СУБД): PostgreSQL, MySQL, Oracle, Microsoft SQL Server. Они мощные, но требуют установки отдельного сервера, настройки прав доступа и администрирования.

SQLite стоит особняком. Это встраиваемая реляционная база данных. Слово «встраиваемая» означает, что движок базы данных не является отдельным процессом, с которым программа общается через сеть. Библиотека SQLite компонуется непосредственно с вашей программой.

Главные преимущества для Python-разработчика:

Отсутствие сервера. База данных — это просто файл на вашем диске (обычно с расширением .db или .sqlite).

Нулевая конфигурация. Не нужно ничего устанавливать или настраивать.

Входит в стандартную библиотеку. Python поставляется с модулем sqlite3 «из коробки». Вам не нужно делать pip install.

!Схема работы SQLite: программа на Python напрямую взаимодействует с файлом базы данных через встроенный модуль.

Начало работы: импорт модуля

Поскольку поддержка SQLite встроена в Python, первый шаг всегда одинаков и предельно прост. Нам нужно импортировать модуль sqlite3.

Запустив этот код, вы увидите версии установленного программного обеспечения. Это подтверждает, что ваша среда готова к работе.

Подключение к базе данных

Чтобы начать работу с базой данных, нужно создать объект соединения (Connection). Этот объект представляет собой канал связи между вашей программой и файлом базы данных.

Для этого используется функция connect().

Что происходит в этот момент?

Когда вы вызываете sqlite3.connect('my_database.db'), происходит одно из двух событий:

Если файл существует, Python открывает его и готовит к чтению или записи.

Если файла не существует, библиотека SQLite автоматически создает новый пустой файл с указанным именем в текущей директории.

Это очень удобно для начала новых проектов. Вам не нужно предварительно создавать файл вручную.

> Важно: Если вы хотите создать базу данных в конкретной папке, вы можете указать полный или относительный путь, например: sqlite3.connect('data/app_data.db').

База данных в оперативной памяти

Иногда вам не нужно сохранять данные на диск. Например, вы пишете тесты для своего приложения или хотите поэкспериментировать, не засоряя жесткий диск файлами. В таком случае можно создать базу данных прямо в оперативной памяти (RAM).

Для этого вместо имени файла используется специальное слово ':memory:'.

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

Курсор: ваш главный инструмент

Само по себе соединение (connection) не умеет выполнять SQL-запросы. Оно лишь держит канал связи открытым. Чтобы отдавать команды базе данных (создавать таблицы, добавлять данные, делать выборки), нам нужен курсор (Cursor).

Представьте, что база данных — это огромный склад. Объект соединения — это открытые ворота склада. А курсор — это кладовщик, который ходит по складу, находит нужные полки, кладет туда товары или забирает их по вашему списку.

Создается курсор методом cursor() объекта соединения:

Теперь у нас есть переменная cursor, через которую мы будем выполнять все SQL-команды.

Выполнение простейшего запроса

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

Для выполнения SQL-команд используется метод execute().

Разберем этот пример:

cursor.execute(...) — отправляет SQL-запрос в базу данных. В данном случае мы просим базу вернуть строку "Привет, SQLite!".

cursor.fetchone() — извлекает одну запись из результата запроса. Обратите внимание, что результат возвращается в виде кортежа (tuple).

Закрытие соединения

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

Поэтому золотое правило: поработал — убери за собой.

После закрытия соединения любые попытки обратиться к базе данных через объект connection или cursor вызовут ошибку ProgrammingError.

Безопасная работа: конструкция try-finally

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

Чтобы этого избежать, используют блок try-finally:

Использование контекстного менеджера (with)

Python предлагает еще более элегантный способ работы с ресурсами — контекстные менеджеры (оператор with). Однако с sqlite3 есть нюанс.

Оператор with sqlite3.connect(...) as conn: автоматически не закрывает соединение в конце блока (в старых версиях и по умолчанию). Он предназначен для управления транзакциями (автоматический commit или rollback), о чем мы поговорим в будущих уроках.

Тем не менее, начиная с Python 3.11 и новее, поведение становится более интуитивным, но для полной надежности и совместимости с любыми версиями Python, часто рекомендуется использовать явное закрытие или специальные обертки.

Для новичка самым надежным и понятным способом на данном этапе будет использование try...finally или явный вызов close() в конце простого скрипта.

Резюме

В этом уроке мы сделали первые шаги в мир баз данных с Python:

Узнали, что SQLite — это серверная база данных в одном файле, встроенная в Python.

Научились подключаться к базе с помощью sqlite3.connect(), создавая файл на диске или в оперативной памяти (:memory:).

Поняли роль курсора (cursor) как исполнителя команд.

Выполнили первый тестовый запрос с помощью execute() и получили данные через fetchone().

Усвоили важность закрытия соединения методом close().

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

Готовы двигаться дальше? Но сначала закрепим материал небольшими заданиями.

Создание структуры базы данных: типы данных SQLite и SQL-запрос CREATE TABLE

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

В реляционных базах данных, к которым относится SQLite, данные хранятся в таблицах. Сегодня мы научимся проектировать эти таблицы, разбираться в типах данных и писать свой первый SQL-запрос для создания структуры базы.

Что такое таблица в базе данных?

Таблица — это структура, состоящая из строк и столбцов. Это очень похоже на обычный лист Excel.

* Столбец (поле) определяет тип информации (например, «Имя», «Возраст», «Email»). У каждого столбца есть строгое название и тип данных. * Строка (запись) содержит конкретные данные об одном объекте (например, информация об одном пользователе).

!Структура таблицы базы данных: пересечение строк и столбцов.

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

Типы данных в SQLite

SQLite отличается от большинства других баз данных (таких как PostgreSQL или MySQL) своим подходом к типам данных. В больших серверных базах используется статическая типизация: если вы сказали, что в столбце хранятся целые числа, база данных выдаст ошибку, если вы попытаетесь записать туда текст.

SQLite использует систему динамической типизации. Это означает, что тип данных привязан к самому значению, а не к столбцу, в котором оно хранится. Тем не менее, при создании таблицы мы всё равно указываем типы, чтобы помочь SQLite оптимизировать хранение и сортировку.

В SQLite существует всего 5 основных классов хранения:

NULL. Специальное значение, обозначающее «пустоту» или отсутствие данных.

INTEGER. Целое число со знаком. В зависимости от величины числа, оно может занимать 1, 2, 3, 4, 6 или 8 байт.

REAL. Число с плавающей точкой (дробное число). Хранится как 8-байтовое число IEEE с плавающей точкой.

TEXT. Строка текста. Хранится в кодировке базы данных (обычно UTF-8).

BLOB (Binary Large Object). Данные хранятся «как есть», байт в байт. Используется для хранения изображений, аудиофайлов или других бинарных данных.

А где же Boolean и Date?

Вы могли заметить, что в списке нет привычных типов для логических значений (True/False) или дат. Это особенность SQLite:

* Boolean: Логические значения хранятся как целые числа (INTEGER). 0 — это False, 1 — это True. * Date/Time: В SQLite нет отдельного типа для дат. Даты обычно хранят как TEXT (в формате "YYYY-MM-DD HH:MM:SS"), как REAL (число дней) или как INTEGER (Unix Time — количество секунд с 1970 года).

Язык SQL: Команда CREATE TABLE

Для создания таблицы используется SQL-команда CREATE TABLE. Это декларативная команда: мы просто описываем, что хотим получить, а СУБД сама решает, как это сделать физически.

Общий синтаксис выглядит так:

Ключевые ограничения (Constraints)

Помимо типа данных, мы можем задать правила для каждого столбца:

PRIMARY KEY (Первичный ключ). Это уникальный идентификатор строки. Обычно это числовой id. В таблице может быть только один первичный ключ. Значения в этом столбце не могут повторяться.

NOT NULL. Запрещает оставлять поле пустым. Если вы попытаетесь добавить запись без значения в этом поле, возникнет ошибка.

UNIQUE. Гарантирует, что все значения в столбце уникальны (например, email или номер телефона).

DEFAULT. Задает значение по умолчанию, если при добавлении записи оно не было указано.

Практика: Создаем таблицу пользователей

Давайте перейдем к Python и создадим таблицу users для хранения информации о пользователях. Наша таблица будет иметь следующую структуру:

* id: целое число, первичный ключ. * name: текст, обязательное поле. * age: целое число, необязательное поле. * email: текст, должен быть уникальным.

Шаг 1: Подготовка SQL-запроса

Хорошей практикой является использование многострочных строк (тройные кавычки) для написания SQL-запросов в Python. Это делает код читаемым.

Обратите внимание на фразу IF NOT EXISTS (если не существует). Это очень полезная конструкция. Она говорит базе данных: «Создай эту таблицу только в том случае, если её еще нет». Без этой фразы повторный запуск скрипта приведет к ошибке OperationalError: table users already exists.

Также мы добавили ключевое слово AUTOINCREMENT к первичному ключу. Это означает, что SQLite будет сама назначать уникальный номер каждой новой записи (1, 2, 3...), и нам не нужно следить за этим вручную.

Шаг 2: Выполнение запроса через Python

Теперь объединим знания из прошлого урока и текущую задачу.

Как проверить, что таблица создалась?

После выполнения скрипта файл my_database.db может остаться прежнего размера (или незначительно увеличиться), так как таблица пока пуста. Как убедиться, что структура создана верно?

В SQLite есть служебная таблица sqlite_master, где хранится схема всей базы данных. Мы можем сделать запрос к ней.

Добавьте этот код перед закрытием соединения:

Если всё прошло успешно, вы увидите: Список таблиц в базе: [('users',)].

Важные нюансы работы с типами в Python и SQLite

Модуль sqlite3 автоматически преобразует типы данных Python в типы SQLite и обратно. Вот таблица соответствия:

| Тип Python | Тип SQLite | | :--- | :--- | | None | NULL | | int | INTEGER | | float | REAL | | str | TEXT | | bytes | BLOB |

Это работает прозрачно для вас. Когда вы будете сохранять число 42 из Python, оно станет INTEGER в базе. Когда вы будете читать TEXT из базы, он вернется в программу как строка str.

Резюме

В этой статье мы заложили фундамент нашего приложения:

Разобрали 5 основных типов данных SQLite: NULL, INTEGER, REAL, TEXT, BLOB.

Узнали, что логические значения и даты хранятся как числа или строки.

Изучили синтаксис CREATE TABLE и важность ограничений (Constraints) вроде PRIMARY KEY и NOT NULL.

Написали Python-скрипт, который создает структуру таблицы, используя безопасную конструкцию IF NOT EXISTS.

Теперь у нас есть надежное хранилище с готовыми полками. В следующей статье мы начнем заполнять эти полки: научимся добавлять новые данные с помощью команды INSERT.

Манипуляции с данными: добавление записей и выполнение выборок методами fetch

В предыдущих статьях мы проделали большую подготовительную работу. Мы научились подключаться к SQLite, создали файл базы данных и спроектировали структуру нашей первой таблицы users. Но пока наш «цифровой склад» стоит пустым. В нём есть полки (таблицы) и ячейки (столбцы), но нет самого главного — товаров (данных).

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

Добавление данных: команда INSERT

На языке SQL добавление новой записи осуществляется командой INSERT INTO. Если бы мы писали чистый SQL, запрос выглядел бы так:

В Python мы используем уже знакомый метод cursor.execute(), чтобы передать эту команду движку базы данных. Однако здесь есть критически важный нюанс, касающийся безопасности.

Безопасная передача данных: Параметризованные запросы

Представьте, что данные для вставки приходят от пользователя (например, через форму на сайте). Новичок может поддаться искушению использовать f-строки или конкатенацию строк для формирования запроса.

Никогда так не делайте:

Почему это плохо? Если злоумышленник введет в поле имени строку Alex'); DROP TABLE users; --, то итоговый запрос удалит вашу таблицу. Это называется SQL-инъекция.

Правильный способ — использовать заполнители (placeholders). В SQLite заполнителем служит знак вопроса ?. Вы пишете запрос с вопросительными знаками, а сами данные передаете вторым аргументом в виде кортежа.

Библиотека sqlite3 сама позаботится о правильном экранировании кавычек и спецсимволов. Это на 100% защищает от инъекций.

!Схема работы параметризованных запросов: данные отделены от SQL-кода до момента выполнения.

Фиксация изменений: метод commit()

Если вы выполните код выше и сразу закроете программу, то, открыв базу данных снова, вы обнаружите, что она пуста. Почему?

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

Для этого используется метод объекта соединения (не курсора!):

> Запомните: execute() готовит изменения, commit() сохраняет их. Без коммита данные потеряются после закрытия соединения.

Массовая вставка: метод executemany()

Что делать, если нам нужно добавить не одного пользователя, а сразу тысячу? Можно запустить cursor.execute() в цикле for, но это неэффективно. Каждый вызов execute — это отдельное обращение к движку базы данных.

Для массовой вставки существует специальный метод executemany(). Он принимает SQL-запрос и список кортежей с данными.

Этот метод работает значительно быстрее цикла, так как оптимизирует внутренние операции ввода-вывода.

Извлечение данных: команда SELECT

Теперь, когда в нашей базе есть данные, давайте научимся их читать. Для этого используется SQL-команда SELECT.

Базовый процесс выглядит так:

Мы формируем запрос SELECT.

Выполняем его через cursor.execute().

Используем методы fetch... для получения результатов.

После выполнения этой строки данные не попадают в переменную Python автоматически. Они находятся в буфере базы данных, а курсор встает в начало этого списка, готовый выдавать их по требованию.

Методы получения данных (Fetch methods)

В модуле sqlite3 есть три основных метода для чтения результатов запроса.

#### 1. fetchone() — Получить одну запись

Этот метод извлекает следующую строку из результата запроса. Он возвращает кортеж (tuple) значений или None, если данные закончились.

Обратите внимание: курсор помнит свою позицию. Каждый вызов fetchone() сдвигает его на одну строку вниз.

#### 2. fetchall() — Получить все записи

Этот метод считывает все оставшиеся строки результата и возвращает их в виде списка кортежей.

Важное предупреждение: Будьте осторожны с fetchall() на больших таблицах. Если в таблице миллион строк, Python попытается загрузить их все в оперативную память, что может привести к зависанию программы. Для больших объемов данных лучше использовать итерацию по курсору или fetchmany.

#### 3. fetchmany(size) — Получить заданное количество записей

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

Курсор как итератор

В Python объект курсора сам по себе является итератором. Это значит, что вы можете перебирать результаты запроса напрямую в цикле for, не вызывая методы fetch явно. Это самый эффективный способ по памяти.

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

Давайте объединим все полученные знания в одном скрипте. Мы создадим таблицу, наполним её данными и выведем отфильтрованный список.

Разбор нюансов примера

with sqlite3.connect(...): Мы использовали контекстный менеджер. Он автоматически закроет соединение в конце блока. Также он автоматически делает commit, если блок завершился без ошибок, и rollback (отмену изменений), если произошла ошибка. Это очень удобно.

:memory:: Мы создали базу в оперативной памяти для теста.

(25,): Обратите внимание на запятую. При передаче одного параметра в execute мы обязаны передать кортеж. Конструкция (25) — это просто число в скобках, а (25,) — это кортеж из одного элемента.

Резюме

Сегодня мы оживили нашу базу данных. Мы научились:

* Использовать INSERT для добавления данных. * Применять параметризованные запросы (?) для защиты от SQL-инъекций. * Использовать executemany() для быстрой вставки массивов данных. * Фиксировать транзакции методом commit(). * Извлекать данные методами fetchone(), fetchall() и fetchmany().

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

Обновление и удаление данных: управление транзакциями commit и rollback

Добро пожаловать обратно в курс «Python и SQLite: Основы работы с базами данных». В предыдущих уроках мы научились создавать таблицы, наполнять их информацией и извлекать данные. Наш цифровой склад уже функционирует: мы умеем строить полки и ставить на них коробки.

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

Сегодня мы освоим две критически важные операции языка SQL — UPDATE (обновление) и DELETE (удаление). Но что еще важнее, мы разберем механизм транзакций. Вы узнаете, как гарантировать целостность данных, чтобы при сбое программы деньги не списались со счета отправителя, не дойдя до получателя.

Изменение данных: команда UPDATE

Когда вам нужно изменить уже существующую запись (или несколько записей), используется команда UPDATE. Она позволяет обновить значения в одном или нескольких столбцах.

Базовый синтаксис выглядит так:

Важность условия WHERE

Обратите внимание на последнюю строку WHERE условие. Это ваш предохранитель. Если вы забудете указать условие, СУБД послушно обновит все строки в таблице.

Представьте, что вы хотите сменить пароль одному пользователю, но забыли WHERE. В итоге у всех тысяч пользователей вашего сервиса станет одинаковый пароль. Это катастрофа.

Реализация в Python

Давайте вернемся к нашей таблице users из прошлых уроков и попробуем изменить возраст пользователя по имени «Анна».

Обратите внимание на атрибут cursor.rowcount. После выполнения команд UPDATE или DELETE он показывает количество строк, которые были изменены. Это отличный способ проверить, сработал ли ваш запрос так, как вы ожидали.

Удаление данных: команда DELETE

Удаление записей происходит с помощью команды DELETE. Она работает по схожему принципу с UPDATE.

Синтаксис:

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

Пример удаления в Python

Удалим пользователя с определенным id.

Что такое транзакция?

Мы подошли к самой интересной части урока. Вы, вероятно, заметили, что после каждой операции изменения данных (INSERT, UPDATE, DELETE) мы вызываем метод connection.commit(). Зачем?

В базах данных существует понятие транзакции. Транзакция — это последовательность операций, которая воспринимается базой данных как единое целое.

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

!Визуализация принципа работы транзакции: изменения находятся во временном буфере до подтверждения.

Классический пример: Банковский перевод

Представьте, что вы переводите 1000 рублей со счета Алисы на счет Боба. С точки зрения базы данных это две разные операции:

UPDATE: Вычесть 1000 рублей у Алисы.

UPDATE: Прибавить 1000 рублей Бобу.

Что произойдет, если электричество отключится ровно между первой и второй операцией?

* У Алисы деньги списались. * Бобу деньги не пришли. * 1000 рублей просто исчезли в никуда.

Это недопустимо. Именно здесь нас спасают транзакции.

Управление транзакциями: commit и rollback

В SQLite (и в стандарте DB-API 2.0 для Python) управление транзакциями осуществляется двумя основными методами объекта соединения:

connection.commit() — Подтверждение. Сохраняет все изменения, сделанные с момента начала транзакции, на диск. После этого отменить их уже нельзя.

connection.rollback() — Откат. Отменяет все изменения, сделанные в текущей транзакции. База данных возвращается в состояние, в котором она была до начала этих изменений.

Как это работает в Python

По умолчанию модуль sqlite3 открывает транзакцию автоматически, когда вы выполняете первый запрос на изменение данных. Ваша задача — явно завершить её.

Давайте реализуем безопасный банковский перевод:

Разбор логики

Мы оборачиваем операции в блок try...except.

Внутри try мы выполняем все необходимые SQL-запросы.

В самом конце блока try мы вызываем commit(). Это точка невозврата.

Если на любой строке внутри try возникает ошибка (Python exception), выполнение мгновенно переходит в блок except.

В блоке except мы вызываем rollback(). Это аннулирует списание денег у Алисы, даже если эта команда уже успела выполниться.

Использование контекстного менеджера

Python позволяет упростить этот код, используя объект соединения как контекстный менеджер (в блоке with).

Важно: Контекстный менеджер with connection: управляет именно транзакцией (делает commit или rollback), но не закрывает соединение. Закрывать соединение (connection.close()) все равно нужно вручную или в блоке finally.

Резюме

В этом уроке мы перешли от простого хранения данных к управлению их жизненным циклом:

UPDATE позволяет изменять данные. Всегда используйте WHERE, чтобы не затереть лишнее.

DELETE удаляет строки. Без WHERE удаляет всё содержимое таблицы.

Транзакции гарантируют целостность данных. Это принцип «всё или ничего».

commit() фиксирует изменения, делая их постоянными.

rollback() отменяет незафиксированные изменения, спасая базу данных от частичных обновлений при сбоях.

Теперь вы владеете полным набором инструментов CRUD (Create, Read, Update, Delete). В следующей статье мы углубимся в искусство извлечения данных: научимся сортировать, группировать и объединять таблицы.

Безопасность и лучшие практики: защита от SQL-инъекций и использование контекстных менеджеров

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

Базы данных — это сердце любого приложения. Если злоумышленник получит к ним доступ, он может украсть конфиденциальную информацию, уничтожить данные или даже получить контроль над сервером. В этой статье мы разберем самую распространенную уязвимость в мире баз данных — SQL-инъекцию, научимся защищаться от неё, а также рассмотрим лучшие практики написания чистого и надежного кода на Python.

Что такое SQL-инъекция?

SQL-инъекция (SQL Injection) — это вид атаки, при котором злоумышленник вмешивается в SQL-запрос, который ваше приложение отправляет к базе данных. Это происходит, когда данные, полученные от пользователя (например, из формы входа или поиска), подставляются в запрос напрямую, без надлежащей обработки.

Анатомия уязвимости

Представьте, что вы пишете функцию для поиска пользователя по имени. Новичок часто делает это с помощью форматирования строк (f-строк).

Внимание: Пример ниже содержит критическую уязвимость! Никогда не используйте этот код в реальных проектах.

Если пользователь введет обычное имя, например Alice, запрос будет выглядеть нормально:

Но что, если злоумышленник введет следующую строку?

Alice' OR '1'='1

В этом случае итоговый SQL-запрос превратится в:

Почему это опасно?

Разберем, что произошло:

Одинарная кавычка ' после Alice закрыла строковый литерал, который ожидал SQL.

Ключевое слово OR добавило новое условие.

Условие '1'='1' всегда истинно.

В результате база данных вернет все записи из таблицы users, так как условие WHERE стало истинным для каждой строки. Если это была форма входа, хакер только что вошел в систему под первым попавшимся пользователем (часто это администратор), даже не зная пароля.

Еще более страшный сценарий — деструктивная инъекция. Если злоумышленник введет:

Alice'; DROP TABLE users; --

Запрос превратится в:

Здесь точка с запятой ; завершает первый запрос и начинает новый. Команда DROP TABLE users полностью удаляет таблицу с пользователями. Символы -- (комментарий в SQL) отбрасывают оставшуюся часть оригинального запроса, чтобы избежать синтаксической ошибки.

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

Защита: Параметризованные запросы

Единственный надежный способ защиты от SQL-инъекций в Python — использование параметризованных запросов (bind variables).

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

В SQLite заполнителем служит знак вопроса ?.

Правильный способ выполнения запросов

В этом случае SQLite будет искать пользователя, у которого имя буквально совпадает со строкой Alice' OR '1'='1. Разумеется, такого пользователя не существует, и атака провалится. База данных четко понимает: «Вот это — команда, а вот это — данные».

> Важно: Никогда не используйте f-строки или конкатенацию (+) для сборки SQL-запросов, если в них участвуют внешние данные.

Управление ресурсами: Контекстные менеджеры

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

Python предлагает более элегантное решение — контекстные менеджеры (оператор with).

Автоматическое управление транзакциями

Объект соединения sqlite3 может работать как контекстный менеджер. Это позволяет автоматически управлять транзакциями.

Как это работает:

При входе в блок with connection: начинается транзакция.

Если код внутри блока выполняется успешно, автоматически вызывается commit().

Если внутри блока возникает исключение, автоматически вызывается rollback().

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

Нюанс: Закрытие соединения

Обратите внимание, что оператор with connection: не закрывает само соединение с базой данных, он управляет только транзакцией. Метод connection.close() все равно нужно вызывать явно (обычно в блоке finally или за пределами with).

Если вы хотите, чтобы соединение закрывалось автоматически, можно использовать функцию closing из модуля contextlib:

Удобство работы: Row Factory

По умолчанию sqlite3 возвращает результаты запросов в виде кортежей (tuples).

Это неудобно, когда столбцов много. Приходится помнить, что email — это индекс 1, а age — индекс 5. Если вы измените порядок столбцов в запросе, весь код сломается.

Лучшая практика — использовать sqlite3.Row. Это позволяет обращаться к полям по имени, как в словаре.

Это делает код намного более читаемым и устойчивым к изменениям структуры запросов.

Резюме лучших практик

Подводя итог этому и предыдущим урокам, сформулируем золотые правила работы с SQLite в Python:

Всегда используйте заполнители (?). Никогда не формируйте SQL-запросы склеиванием строк, если в них участвуют данные от пользователя. Это защита от SQL-инъекций.

Используйте контекстные менеджеры. Блок with connection: гарантирует, что транзакция будет завершена корректно (commit при успехе, rollback при ошибке).

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

Используйте sqlite3.Row. Обращение к колонкам по именам (row['id']) делает код понятным и легким для поддержки.

Храните базу данных в надежном месте. Помните, что SQLite — это просто файл. Убедитесь, что права доступа к этому файлу настроены правильно, если ваше приложение работает на сервере.

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