Что такое CRUD-операции?

Операции CRUD лежат в основе почти каждого приложения, с которым вы взаимодействуете. Как разработчик, вы обычно хотите создавать данные, читать или извлекать данные, обновлять и удалять данные. Независимо от того, обращаетесь ли вы к базе данных или взаимодействуете с REST API, только при наличии всех четырех операций вы сможете выполнить полный цикл обработки данных в своем приложении.

Создание, чтение, обновление и удаление настолько важны в разработке программного обеспечения, что эти методы широко называются CRUD. Понимание CRUD даст вам действенный план при создании приложений и поможет вам понять, как используемые вами приложения работают «за кулисами». Итак, что именно означает CRUD?

Вкратце: CRUD означает создание, чтение, обновление и удаление.

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

• Создать: речь идет о добавлении новых записей в базу данных. Но это также применимо и к другим типам постоянного хранилища, таким как файлы или сетевые службы. Выполняя операцию создания, вы начинаете поиск нового фрагмента данных в своей системе.
• Чтение. При чтении вы извлекаете или просматриваете существующие записи базы данных. Эта операция так же проста, как проверка электронной почты или перезагрузка веб-сайта. Каждая часть информации, которую вы получаете, была получена из базы данных благодаря операции чтения.
• Обновление. Обновление позволяет изменять сведения о данных, уже находящихся в базе данных. Например, когда вы обновляете изображение профиля или редактируете сообщение чата. Каждый раз выполняется операция обновления, гарантирующая сохранение новых данных в базе данных.
• Удалить. При удалении из базы данных удаляются существующие записи. Независимо от того, закрываете ли вы учетную запись или удаляете сообщение, операции удаления гарантируют, что нежелательные или ненужные данные могут быть удалены должным образом.

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

Почему операции CRUD необходимы?

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

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

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

Хорошей практикой является реализация каждой операции CRUD в ваших приложениях отдельно. Например, когда вы извлекаете элементы, вам не следует обновлять их одновременно.

Хотя CRUD описывает концепцию, независимую от конкретных языков программирования, можно утверждать, что операции CRUD тесно связаны с командами SQL и методами HTTP.

Что такое CRUD-операции в SQL?

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

Create

ВСТАВИТЬ

Read

ВЫБРАТЬ

Update

ОБНОВЛЕНИЕ

Delete

УДАЛИТЬ

Когда вы создаете данные, вы используете команду INSERT для добавления новых записей в таблицу. После создания вы можете читать данные с помощью SELECT. С помощью запроса SELECT вы просите базу данных получить конкретные фрагменты необходимой вам информации, будь то одно значение, набор записей или сложные связи между точками данных.

Операция обновление соответствует команде UPDATE в SQL, которая позволяет изменять данные. Он позволяет редактировать или изменять существующий элемент.

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

Написание CRUD-операций на Raw SQL

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

В примерах ниже вы будете использовать встроенный пакет Python sqlite3. SQLite — это удобная библиотека SQL для тестирования, поскольку вы будете работать с одним файлом базы данных SQLite.

Вы назовете базу данных birds.db. Как следует из названия, вы будете использовать базу данных для хранения названий понравившихся вам птиц. Чтобы пример был небольшим, вы будете отслеживать только названия птиц и присваивать им идентификатор в качестве уникального идентификатора.

Запустите новый файл Python с именем crud_sql.py, используя приведенный ниже код:

import sqlite3

def connect_to_db(db_path):
    return sqlite3.connect(db_path)

if __name__ == "__main__":
    with connect_to_db("birds.db") as connection:
        connection.execute("""
          CREATE TABLE IF NOT EXISTS bird (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL
          );
        """)

После импорта sqlite3 в строке 1 вы определяете функцию с именем connect_to_db() в строке 3. Как следует из названия, вы будете использовать эту функцию для подключения к базе данных. , который вы передаете в качестве аргумента. Если sqlite3.connect() в строке 4 не может найти базу данных по заданному пути, база данных будет создана.

В строке 6 вы используете идиому name-main для подключения к birds.db и создания таблицы bird в базе данных при выполнении crud_sql.py. напрямую. В строке 8 вы выполняете необработанную команду SQL, которую вы определили в строках с 9 по 11. Поскольку вы используете диспетчер контекста, вам не нужно беспокоиться о закрытии базы данных.

Определенная вами команда SQL условно выполняет две вещи. Если таблица bird не существует в базе данных, вы создаете ее с двумя столбцами:

1. id для уникальной идентификации записей базы данных
2. name для хранения имени птицы

Таблицу базы данных bird можно рассматривать как электронную таблицу. Столбцы id и name являются заголовками таблицы. Позже вы добавите в таблицу строки, которые будут записями вашей базы данных.

Откройте окно терминала в том же рабочем каталоге, что и crud_sql.py, и запустите скрипт Python:

$ python crud_sql.py

При первом выполнении crud_sql.py создается birds.db с таблицей bird. Затем запустите новый REPL Python для выполнения операций CRUD с необработанным SQL:

>>> from crud_sql import connect_to_db
>>> connection = connect_to_db("birds.db")
>>> cursor = connection.cursor()
>>> CREATE_BIRDS_SQL = """
... INSERT INTO
...   bird (name)
... VALUES
...   ('Humming Bird'),
...   ('Sugar Glider');
... """
>>> cursor.execute(CREATE_BIRDS_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()

Сначала вы устанавливаете соединение с базой данных birds.db и создаете Cursor. Затем вы готовите команду SQL для вставки двух летающих животных в таблицу bird. Как и раньше, вы используете .execute() для выполнения операции. Однако на этот раз вы открываете транзакцию базы данных, потому что используете команду INSERT.

На этом этапе вы можете связать другие запросы со стеком транзакций. Для выполнения операции необходимо использовать .commit(). На данный момент вы будете использовать открытое соединение для выполнения других операций CRUD. Вы закроете соединение в конце раздела.

После создания записей базы данных пришло время убедиться, что они присутствуют в базе данных. Для этого вы используете операцию извлечения CRUD:

>>> READ_BIRDS_SQL = "SELECT * from bird"
>>> cursor.execute(READ_BIRDS_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> cursor.fetchall()
[(1, 'Humming Bird'), (2, 'Sugar Glider')]

Используя SELECT, за которым следует звездочка (*), вы настраиваете запрос READ_BIRDS_SQL для получения всех записей базы данных bird таблица. Если бы ваша база данных была больше, это была бы большая транзакция. Для вашей небольшой базы данных, содержащей всего два маленьких животных, эта операция CRUD подойдет.

Метод .fetchall() возвращает список кортежей. Элементы списка являются элементами базы данных. Содержимое кортежа — это значения строк id и name.

На этом этапе вы, возможно, заметили неправильное написание записи «Колибри». Правильное написание этой крошечной птички – «Колибри». Какая прекрасная возможность использовать еще одну операцию CRUD!

Продолжайте и используйте операцию обновления CRUD для записи «Humming Bird», ссылаясь на ее id:

>>> UPDATE_HUMMINGBIRD_SQL = """
... UPDATE
...   bird
... SET
...   name = "Hummingbird"
... WHERE
...   id = 1
... """
>>> cursor.execute(UPDATE_HUMMINGBIRD_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()

При выполнении команды UPDATE вы должны предоставить новый контент, которым вы хотите перезаписать старый. Здесь вы меняете имя маленькой птички на «Колибри».

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

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

Испытание операции удаления в SQL дает вам возможность исправить еще один недостаток в одной из записей вашей базы данных. Сахарный планер — милое летающее животное. Однако сахарный планер — не птица.

В какой-то момент в будущем вы можете разнообразить свою базу данных, чтобы она стала местом обитания любого милого животного. А сейчас пришло время удалить сахарный планер из birds.db:

>>> DELETE_SUGAR_GLIDER_SQL = "DELETE FROM bird WHERE id = 2"
>>> cursor.execute(DELETE_SUGAR_GLIDER_SQL)
<sqlite3.Cursor object at 0x105027bc0>

>>> connection.commit()
>>> connection.close()

С помощью DELETE вы не записываете новые данные. Вот почему достаточно указать id, чтобы база данных знала, какую запись вы хотите удалить.

Опять же, не пропустите предложение WHERE. В противном случае вы удалите все записи таблицы bird. Если вы хотите узнать больше о командах SQL, которые можно использовать с SQLite, вы можете ознакомиться с обзором SQL в понимании SQLite.

Теперь, когда вы завершили все операции SQL CRUD, вы также вызываете .close(), чтобы закрыть соединение с базой данных.

Перевод концепций CRUD в SQL помогает вам создавать запросы для управления данными в вашей базе данных. Как вы видели в приведенных выше примерах, операции CRUD тесно связаны с командами SQL. Однако написание чистого SQL может оказаться затруднительным. Именно здесь в игру вступает такой пакет, как SQLAlchemy, который поможет вам более удобно выполнять операции CRUD.

Выполнение операций CRUD с помощью SQLAlchemy

SQLAlchemy — популярный объектно-реляционный преобразователь (ORM) для Python. ORM позволяет вам взаимодействовать с базой данных, используя объекты Python, вместо написания необработанных SQL-запросов, как вы это делали в предыдущем разделе. Это делает написание кода более удобным для вас как разработчика Python.

Еще одно удобство использования ORM заключается в том, что вам не нужно беспокоиться о точной реализации SQL:

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

С помощью ORM, такого как SQLAlchemy, вы можете переключать библиотеку SQL в фоновом режиме и сохранять запросы к базе данных неизменными.

SQLAlchemy — это внешний пакет Python, который можно найти в индексе пакетов Python (PyPI).

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

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

Первый фрагмент кода следует использовать в Windows, а второй фрагмент кода — для Linux + macOS:

PS> python -m venv venv
PS> .\venv\Scripts\activate
(venv) PS>

$ python -m venv venv
$ source venv/bin/activate
(venv) $

С помощью команд, показанных выше, вы создаете и активируете виртуальную среду с именем venv, используя встроенный модуль Python venv. Заключенный в скобки (venv) перед приглашением означает, что вы успешно активировали виртуальную среду.

После того, как вы создали и активировали свою виртуальную среду, вы можете приступить к установке SQLAlchemy:

(venv) $ python -m pip install SQLAlchemy

Теперь, когда вы установили SQLAlchemy, вы можете продолжить изучение операций CRUD с помощью ORM SQLAlchemy.

В предыдущем разделе вы выполняли операции CRUD с использованием чистого SQL. Даже при использовании ORM, такого как SQLAlchemy, концепция использования операций CRUD остается верной.

Опять же, начните с создания файла Python, который поможет вам подключиться к базе данных birds.db:

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import DeclarativeBase, sessionmaker

class Base(DeclarativeBase):
    pass

class Bird(Base):
    __tablename__ = "bird"
    id = Column(Integer, primary_key=True)
    name = Column(String)

    def __repr__(self):
        return f"Bird(id={self.id}, name={self.name!r})"

engine = create_engine("sqlite:///birds.db")
Session = sessionmaker(bind=engine)

def init_db():
    Base.metadata.create_all(engine)

Одним из важных преимуществ использования SQLAlchemy является возможность объявления моделей. В строке 7 вы создаете класс Bird, который описывает как таблицу базы данных bird, так и объектную модель Python, которая позже будет взаимодействовать с элементами таблицы.

С помощью init_db() в строке 18 вы либо создаете базу данных birds.db, если она не существует, либо подключаетесь к ней, если она присутствует. Это означает, что вы можете продолжить работу с существующей базой данных birds.db из предыдущего раздела, чтобы исследовать операции CRUD с помощью SQLAlchemy.

Запустите еще один сеанс Python REPL из той же папки, в которой вы сохранили crud_sql_alchemy.py. Затем выполните свои первые операции CRUD с помощью SQLAlchemy:

>>> from crud_sql_alchemy import Session, Bird, init_db
>>> init_db()
>>> session = Session()
>>> new_bird = Bird(name="Test Bird")
>>> session.add(new_bird)
>>> session.commit()

С помощью SQLAlchemy вы можете создавать новые записи базы данных, используя метод .add() Session. В приведенном выше примере вы создаете новую запись с именем «Test Bird».

Чтобы проверить, присутствует ли «Test Bird» в базе данных, вы можете запросить базу данных:

>>> from sqlalchemy import select
>>> query = select(Bird).where(Bird.name == "Test Bird")
>>> bird = session.execute(query).scalar_one()
>>> bird
<Bird(id=3, name='Test Bird')>

Чтобы получить записи базы данных с помощью SQLAlchemy, вы используете select() в сочетании с методом .where(). Запрос напоминает необработанный оператор SQL, но код Python выглядит, пожалуй, более знакомым. Здесь вы хотите выбрать все объекты Bird, имена которых равны "Test Bird".

Взамен вы получаете объект Select, который сохраняете в переменной query.

Когда вы передаете query в .execute(), вы выполняете запрос. Хотя в вашей базе данных есть только одна «Test Bird», соответствующая вашему запросу, вам необходимо использовать .scalar_one(), чтобы сохранить именно эту запись в базе данных как bird.

Теперь, когда вы поймали «Тестовую птицу» и сохранили объект в переменной bird, вы можете продолжить и обновить ее имя:

>>> bird.name = "Example Bird"
>>> session.commit()
>>> session.execute(select(Bird)).scalars().all()
[<Bird(id=1, name='Hummingbird')>, <Bird(id=3, name='Example Bird')>]

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

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

Пока вы остаетесь в сеансе, вы можете продолжать работать с bird:

>>> session.delete(bird)
>>> session.commit()
>>> session.close()

Вы можете подготовиться к удалению записи базы данных с помощью SQLAlchemy, вызвав метод .delete() сеанса. Опять же, вам нужно вызвать .commit() для выполнения операции удаления CRUD.

Наконец, хорошей практикой является сброс сеанса. Вы можете думать о session.close() как об уборке за вами.

Использование SQLAlchemy может снизить сложность написания чистого SQL за счет добавления уровня абстракции для выполнения операций CRUD. При работе с веб-приложениями при выполнении операций CRUD может возникнуть еще один уровень абстракции.

Далее вы изучите роль операций CRUD в Интернете, а затем перейдете к созданию собственного REST API на базе CRUD, который использует методы HTTP-запросов и SQLAlchemy для взаимодействия с вашей базой данных.

Что такое CRUD-операции в методах HTTP-запросов?

Когда вы просматриваете веб-страницы, вы постоянно выполняете операции CRUD в форме методов HTTP-запроса. Прежде чем продолжить изучение HTTP-запросов, посмотрите, как операции CRUD соответствуют методам HTTP-запросов:

Create

ПОСТ

Read

ПОЛУЧИТЬ

Update

PUT или PATCH

Delete

УДАЛИТЬ

На сегодняшний день наиболее распространенным методом HTTP-запроса является метод запроса GET. Когда вы посещаете веб-сайт, вы получаете данные с сервера. Другими словами, вы выполняете операцию чтения CRUD с каждым запросом.

Чтобы изучить, как все четыре операции CRUD взаимодействуют в контексте методов HTTP-запроса, представьте себе веб-сайт, на котором у вас есть учетная запись пользователя.

При регистрации вы создали новую учетную запись с помощью метода HTTP-запроса POST. Когда вы посещаете свой профиль, вы отправляете на сервер запрос GET с просьбой получить ваши данные. Другими словами, вы читаете данные с сервера.

Если вы обновили свое имя пользователя, то, вероятно, вы используете метод HTTP-запроса PATCH. Если вы замените изображение аватара, возможно, вы используете HTTP-метод PUT. Другими словами, PUT заменяет всю запись базы данных новым содержимым, а PATCH обновляет только отдельные поля.

Чтобы удалить публикацию, которую вы разместили в своей ленте, вы можете вызвать HTTP-метод DELETE. Когда вы работаете с DELETE, важно действительно удалить целевой ресурс. После операции DELETE GET на удаленном ресурсе должен вернуть код ответа 404.

Какой именно метод HTTP-запроса вы выполняете, зависит от того, как был построен веб-интерфейс. Если вы взаимодействуете с REST API, методы HTTP более заметны. А какой лучший способ изучить, как методы HTTP и операции CRUD работают в REST API, чем создать REST API самостоятельно?

Выполнение операций CRUD с помощью REST API

REST — это аббревиатура от Передача репрезентативного состояния. С помощью REST API вы определяете набор путей и правил для методов HTTP-запросов для взаимодействия с вашим веб-сервисом.

Операции CRUD в REST API — это в первую очередь HTTP-методы. Подобно взаимодействию с веб-сайтами в вашем браузере, вызовы REST API могут запускать операции CRUD базы данных на серверной стороне.

В следующем разделе вы создадите свой собственный REST API с FastAPI, чтобы лучше понять, как REST API, методы HTTP-запросов и базы данных работают вместе с использованием операций CRUD.

Выполнение операций CRUD с помощью FastAPI

FastAPI — это веб-фреймворк для создания API с помощью Python. Установите FastAPI в ту же виртуальную среду, которую вы создали ранее, и установили SQLAlchemy:

(venv) $ python -m pip install fastapi "uvicorn[standard]"

Помимо FastAPI, вы также устанавливаете Uvicorn с помощью приведенной выше команды. Uvicorn будет сервером, на котором вы запустите FastAPI.

Кроме того, FastAPI устанавливает Pydantic в качестве своей зависимости. Pydantic поможет вам смоделировать ваши данные. Если вы хотите узнать больше о Pydantic, вы можете прочитать руководство по упрощению проверки данных в Python.

Вы будете использовать FastAPI для создания конечных точек, которым вы будете отправлять HTTP-запросы. Как только конечная точка получает запрос, вы выполняете операцию CRUD в своей базе данных birds.db. Чтобы упростить процесс, вы воспользуетесь предыдущим файлом crud_sql_alchemy.py.

Если вы еще не ознакомились с руководством, вы можете загрузить скрипты Python, щелкнув ссылку ниже:

Создайте новый файл с именем crud_fastapi.py рядом с crud_sql_alchemy.py и начните с приведенного ниже кода:

from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy import select
from sqlalchemy.orm import Session
from pydantic import BaseModel, ConfigDict

from crud_sql_alchemy import Bird, init_db
from crud_sql_alchemy import Session as SessionLocal

app = FastAPI()
init_db()

class BirdCreate(BaseModel):
    name: str

class BirdUpdate(BaseModel):
    name: str

class BirdResponse(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    name: str

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Сначала вы импортируете FastAPI для создания веб-приложения и HTTPException для обработки потенциальных ошибок. Вы используете BaseModel Pydantic для проверки данных и управления настройками.

Прежде чем вы сможете опробовать свой API, вам необходимо определить конечные точки для ваших операций CRUD. Продолжайте редактировать crud_fastapi.py и добавьте приведенный ниже код, чтобы определить свою первую конечную точку:

# ...

@app.post("/birds/", response_model=BirdResponse)
def create_bird(bird: BirdCreate, db: Session = Depends(get_db)):
    new_bird = Bird(name=bird.name)
    db.add(new_bird)
    db.commit()
    db.refresh(new_bird)
    return new_bird

Вы используете функцию create_bird(), чтобы создать новую птицу в таблице bird. Эта функция отвечает на запросы POST в конечной точке /birds/. Поскольку вы работаете с SQLAlchemy, код очень похож на пример в предыдущем разделе.

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

# ...

@app.get("/birds/", response_model=list[BirdResponse])
def read_birds(db: Session = Depends(get_db)):
    birds = db.execute(select(Bird)).scalars().all()
    return birds

Функция read_birds() возвращает всех птиц, хранящихся в таблице bird вашей базы данных. Эта конечная точка отвечает на запросы GET, позволяя вам получить список всех птиц.

Если вы хотите получить только конкретную птицу, вам нужно сообщить API, какую птицу вы хотите получить в ответе. Для этого добавьте еще одну конечную точку, которая принимает id птицы в качестве параметра:

# ...

@app.get("/birds/{bird_id}", response_model=BirdResponse)
def read_bird(bird_id: int, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    return found_bird

Когда вы передаете bird_id как часть URL-адреса конечной точки вашего запроса GET, функция read_bird() пытается вернуть птицу с данный идентификатор.

Приведенный выше код SQLAlchemy похож на шаги, которые вы выполняли ранее в Python REPL. Единственное небольшое отличие состоит в том, что здесь рассматривается ситуация, когда птица с данным идентификатором не найдена. В этом случае вы вызываете HTTPException, чтобы сообщить пользователю API, что птица не найдена.

Вы будете использовать аналогичный шаблон для операции update CRUD. Вы продолжаете менять имя птицы только в том случае, если птица с запрошенным идентификатором существует:

# ...

@app.put("/birds/{bird_id}", response_model=BirdResponse)
def update_bird(bird_id: int, bird: BirdUpdate, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    found_bird.name = bird.name
    db.commit()
    db.refresh(found_bird)
    return found_bird

Функция update_bird() заменяет существующие сведения о птице предоставленным новым именем. Как и раньше, операция delete CRUD очень похожа на ту, которую вы используете для обновления записи базы данных. Вместо переименования птицы на этот раз вы вызываете метод .delete():

# ...

@app.delete("/birds/{bird_id}", response_model=dict)
def delete_bird(bird_id: int, db: Session = Depends(get_db)):
    query = select(Bird).where(Bird.id == bird_id)
    found_bird = db.execute(query).scalar_one()
    if found_bird is None:
        raise HTTPException(status_code=404, detail="Bird not found")
    db.delete(found_bird)
    db.commit()
    return {"message": "Bird deleted successfully"}

Теперь, когда все ваши конечные точки CRUD API присутствуют, пришло время опробовать ваш API! Запустите сервер Uvicorn, выполнив команду uvicorn. В качестве аргумента вам необходимо указать имя файла без расширения .py, за которым следует двоеточие (:) и имя приложения FastAPI:

(venv) $ uvicorn crud_fastapi:app
INFO:     Will watch for changes in these directories: [...]
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [29889] using WatchFiles
INFO:     Started server process [29891]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Одна из замечательных особенностей FastAPI заключается в том, что он поставляется с интерактивной документацией по API «из коробки». Это означает, что вы можете протестировать конечные точки REST API прямо в браузере. Посетите http://127.0.0.1:8000/docs и выполните некоторые операции CRUD в вашем REST API:

Операции CRUD в REST API предоставляют стандартизированную структуру для создания веб-сервисов, которые могут создавать, читать, обновлять и удалять ресурсы через Интернет.

FastAPI — отличный пакет для соединения операций CRUD с методами HTTP-запросов. Используя конечные точки, вы сопоставили операции CRUD с функциями, которые взаимодействуют с вашей базой данных. Опять же, SQLAlchemy — отличный помощник для интуитивного выполнения операций CRUD в вашей базе данных.

Заключение

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

В этом руководстве вы изучили операции CRUD в базах данных и API REST. Написав операции CRUD на чистом SQL, вы использовали SQLAlchemy для более интуитивного способа взаимодействия с базой данных. Затем вы использовали FastAPI для создания REST API, который поможет вам понять, как операции CRUD связаны с методами HTTP-запросов.

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