SQLAlchemy: ORM ilə verilənlər bazası

SQLAlchemy 2.0 üslubunda verilənlər bazası: Engine və tranzaksiyalar, Core və ORM, deklarativ modellər, Session ilə əlavə etmə, dəyişmə və silmə, `select()` ilə sorğular, relyasiyalar və N+1 problemi, Alembic ilə miqrasiyalar — SQLite nümunələri ilə.

  • İrəli
  • 22 dəq
  • 12 sual
  • 66 dərsdən 41-cisi

Bu dərsdə öyrənəcəksən

  • Engine yaratmaq, tranzaksiyada parametrli SQL icra etmək və Core ilə ORM-in fərqini izah etmək
  • Mapped və mapped_column ilə modellər yazmaq və Session ilə CRUD əməliyyatlarını yerinə yetirmək
  • select(), where, join, group_by ilə sorğular qurmaq və onların SQL-ini oxumaq
  • Relyasiyaları qurmaq, N+1 problemindən qaçmaq və miqrasiyaların nə üçün lazım olduğunu izah etmək

Məktəb tətbiqi şagirdləri, kursları və qiymətləri verilənlər bazasında saxlayır. Standart sqlite3 modulu ilə SQL-i sətir kimi özün yazırsan, sütun adlarını əl ilə köçürürsən və sətirləri obyektlərə özün çevirirsən; layihə SQLite-dan PostgreSQL-ə keçəndə isə SQL-in bir hissəsini dəyişmək lazım gəlir. SQLAlchemy Python üçün məşhur verilənlər bazası alətidir: cədvəlləri Python sinifləri kimi təsvir edirsən, obyektlərlə işləyirsən, o isə seçilmiş baza üçün düzgün SQL yaradır. Dərs müasir SQLAlchemy 2.0 üslubundadır.

ORM (obyekt-relyasiya xəritələməsi)Tərif

Sinif ↔ cədvəl, obyekt ↔ sətir, atribut ↔ sütun uyğunluğu. Student(first_name='Aysel') obyektini sessiyaya əlavə etmək INSERT sorğusuna, onun atributunu dəyişmək isə UPDATE sorğusuna çevrilir.

Sənin kodun: Student, Course obyektləriORM: Session və select()Core: SQL ifadələri, ConnectionEngine: bağlantı hovuzu + dialektVerilənlər bazası: SQLite, PostgreSQL…
ORM Core-un üzərində qurulub; dialekt eyni ifadəni konkret bazanın SQL dialektinə çevirir.

Engine, bağlantılar və Core

create_engine URL qəbul edir: sqlite:///school.db — fayl, sqlite:// — yaddaşda baza, postgresql+psycopg://user:password@host/db — PostgreSQL server. Engine «tənbəldir»: bazaya ilk sorğuda qoşulur və bağlantıları hovuzda saxlayır. engine.begin() tranzaksiya açır: blok uğurla bitəndə COMMIT, xəta olanda ROLLBACK. text() xam SQL-dir, :name isə parametrdir.

Python
from sqlalchemy import create_engine, text

engine = create_engine('sqlite://')
with engine.begin() as conn:
    conn.execute(text('CREATE TABLE students (first_name TEXT, age INTEGER)'))
    conn.execute(text('INSERT INTO students VALUES (:name, :age)'),
                 [{'name': 'Aysel', 'age': 15}, {'name': 'Murad', 'age': 16},
                  {'name': 'Leyla', 'age': 14}])

with engine.connect() as conn:
    result = conn.execute(text('SELECT first_name, age FROM students WHERE age >= :min_age'),
                          {'min_age': 15})
    for row in result:
        print(row.first_name, row.age)
print(engine.dialect.name, engine.url)

Gözlənilən nəticə

Aysel 15
Murad 16
sqlite sqlite://
Brauzerdə SQLAlchemy işləmir — bu dərsin Python kodunu öz kompüterində pip install sqlalchemy ilə işə sal. Parametrlər siyahısı ötürüləndə INSERT hər sətir üçün təkrarlanır; nəticə sətirlərinin sahələrinə adla müraciət olunur: row.first_name.

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

Deklarativ modellər

Model DeclarativeBase-dən törənən sinifdir. __tablename__ cədvəlin adını verir, Mapped[...] annotasiyası sütunun tipini və NULL-a icazəni təyin edir, mapped_column(...) isə əlavə parametrləri: ilkin açar, uzunluq, unikallıq. Modelləri ayrıca models.py faylında saxlamaq rahatdır:

Python
from sqlalchemy import ForeignKey, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship


class Base(DeclarativeBase):
    pass


class Student(Base):
    __tablename__ = 'students'
    id: Mapped[int] = mapped_column(primary_key=True)
    first_name: Mapped[str] = mapped_column(String(50))
    city: Mapped[str]
    email: Mapped[str | None]
    enrollments: Mapped[list['Enrollment']] = relationship(back_populates='student')

    def __repr__(self):
        return f'Student({self.first_name!r}, {self.city!r})'
models.py, 1-ci hissə. relationship sətrini relyasiyalar bölməsində izah edəcəyik.
Python-daSQL sütunu
Mapped[int]INTEGER NOT NULL
Mapped[str]VARCHAR NOT NULL
Mapped[str | None]VARCHAR (NULL olar)
mapped_column(String(50))VARCHAR(50)
mapped_column(primary_key=True)PRIMARY KEY
mapped_column(ForeignKey('students.id'))REFERENCES students (id)
Python
from sqlalchemy import create_engine
from sqlalchemy.schema import CreateTable
from models import Base, Student

engine = create_engine('sqlite:///school.db')
print(str(CreateTable(Student.__table__).compile(engine)).strip())
Base.metadata.create_all(engine)
print(sorted(Base.metadata.tables))

Gözlənilən nəticə

CREATE TABLE students (
	id INTEGER NOT NULL, 
	first_name VARCHAR(50) NOT NULL, 
	city VARCHAR NOT NULL, 
	email VARCHAR, 
	PRIMARY KEY (id)
)
['courses', 'enrollments', 'students']
CreateTable modelin yaradacağı SQL-i göstərir. create_all bütün modellərin cədvəllərini yaradır, artıq mövcud olanları isə toxunmadan saxlayır.

Session: əlavə etmək, dəyişmək, silmək

Session (iş vahidi)Tərif

Obyektlərin dəyişikliklərini toplayan və commit() zamanı onları bir tranzaksiyada bazaya yazan obyekt. Eyni sətir sessiyada bir obyektə uyğun gəlir: session.get(Student, 2) iki dəfə çağırılsa da, eyni obyekt qaytarılır.

  1. Transient (keçici)

    Student(...) yaradılıb, amma sessiyada deyil; id hələ None-dur.

  2. Pending (gözləyən)

    session.add(obj) — obyekt növbəyə düşür, INSERT hələ göndərilməyib.

  3. Persistent (daimi)

    commit() (və ya flush()) INSERT-i göndərir, obyekt id alır; atributların dəyişməsi növbəti commit()-də UPDATE olur.

  4. Detached (ayrılmış)

    Sessiya bağlanandan sonra obyekt qalır, amma bazadan yeni məlumat yükləyə bilmir.

Python
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
from models import Base, Student

engine = create_engine('sqlite://')
Base.metadata.create_all(engine)

with Session(engine) as session:
    aysel = Student(first_name='Aysel', city='Bakı', email='aysel@example.com')
    session.add(aysel)
    session.add_all([Student(first_name='Murad', city='Gəncə'),
                     Student(first_name='Leyla', city='Bakı')])
    print(aysel.id)
    session.commit()
    print(aysel.id)

    murad = session.get(Student, 2)
    murad.city = 'Sumqayıt'
    session.delete(session.get(Student, 3))
    session.commit()
    print(session.get(Student, 2), session.get(Student, 3))

Gözlənilən nəticə

None
1
Student('Murad', 'Sumqayıt') None
commit()-dən əvvəl aysel.id None-dur, sonra 1. murad.city-ni dəyişmək və session.delete(...) ikinci commit()-də UPDATE və DELETE sorğularına çevrilir; silinmiş şagird üçün get None qaytarır.

select() ilə sorğular

select(Student) hələ sorğu deyil, onun təsviridir: print(stmt) yaradılacaq SQL-i göstərir. session.scalars(stmt) obyektlər, session.execute(stmt) isə sətirlər (kortejlər) qaytarır; sonra .all(), .first() və ya .one() çağırılır. Şərtlər adi Python operatorları ilə yazılır: Student.city == 'Bakı' True/False deyil, SQL ifadəsidir.

Python
from sqlalchemy import create_engine, func, select
from sqlalchemy.orm import Session
from models import Base, Student

engine = create_engine('sqlite://')
Base.metadata.create_all(engine)
with Session(engine) as session:
    data = [('Aysel', 'Bakı'), ('Murad', 'Gəncə'), ('Leyla', 'Bakı'),
            ('Elvin', 'Sumqayıt'), ('Rəşad', 'Bakı')]
    session.add_all([Student(first_name=n, city=c) for n, c in data])
    session.commit()

    stmt = select(Student).where(Student.city == 'Bakı').order_by(Student.first_name)
    print(stmt)
    print(session.scalars(stmt).all())
    first = session.scalars(select(Student.first_name).where(Student.first_name.like('E%'))).all()
    print(first)
    count = func.count(Student.id)
    stmt = select(Student.city, count).group_by(Student.city).order_by(count.desc(), Student.city)
    print(session.execute(stmt).all())

Gözlənilən nəticə

SELECT students.id, students.first_name, students.city, students.email 
FROM students 
WHERE students.city = :city_1 ORDER BY students.first_name
[Student('Aysel', 'Bakı'), Student('Leyla', 'Bakı'), Student('Rəşad', 'Bakı')]
['Elvin']
[('Bakı', 3), ('Gəncə', 1), ('Sumqayıt', 1)]
:city_1 bağlı parametrdir — qiymət SQL mətninə yapışdırılmır. func.count SQL-in COUNT funksiyasıdır; bərabər saylarda şəhərlər əlifba ilə düzülür.
SQLSQLAlchemy
WHERE city = 'Bakı'.where(Student.city == 'Bakı')
WHERE first_name LIKE 'E%'.where(Student.first_name.like('E%'))
WHERE city IN ('Bakı', 'Quba').where(Student.city.in_(['Bakı', 'Quba']))
WHERE email IS NULL.where(Student.email.is_(None))
ORDER BY first_name DESC LIMIT 3.order_by(Student.first_name.desc()).limit(3)
SELECT city, COUNT(id) … GROUP BY cityselect(Student.city, func.count(Student.id)).group_by(Student.city)

Eyni sorğu xalis SQL-də saytın nümunə bazasında işləyir (orada 12 şagird var, ona görə sətirlər çoxdur):

SQL
SELECT first_name, city
FROM students
WHERE city = 'Bakı'
ORDER BY first_name;
Gözlənilən nəticə
first_name | city
Aysel | Bakı
Kamran | Bakı
Leyla | Bakı
Rəşad | Bakı

Nümunə: Python-dan SQL-ə

Məsələ

print(stmt) nə göstərəcək? 1) select(Student.first_name).where(Student.city == 'Gəncə'); 2) select(func.count()).select_from(Student); 3) select(Student).where(Student.email.is_(None)).

Həllini göstərHəllini gizlət

Həll

1) SELECT students.first_name FROM students WHERE students.city = :city_1 — qiymət parametr kimi gedir.
2) SELECT count(*) AS count_1 FROM students — select_from cədvəli göstərir.
3) SELECT students.id, students.first_name, students.city, students.email FROM students WHERE students.email IS NULL — == None yox, .is_(None).

Relyasiyalar və miqrasiyalar

Şagird bir neçə kursa yazılır, kursda isə bir neçə şagird oxuyur — bu, «çoxun çoxa» əlaqəsidir. Qiymət (score) də saxlanmalı olduğundan aralıq Enrollment modeli yaradırıq: hər yazılışın bir şagirdi və bir kursu var. ForeignKey bazadakı əlaqədir, relationship isə Python tərəfi: aysel.enrollments siyahısı, enrollment.course obyekti. back_populates iki tərəfi sinxron saxlayır.

Python
class Course(Base):
    __tablename__ = 'courses'
    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str] = mapped_column(unique=True)
    enrollments: Mapped[list['Enrollment']] = relationship(back_populates='course')


class Enrollment(Base):
    __tablename__ = 'enrollments'
    id: Mapped[int] = mapped_column(primary_key=True)
    student_id: Mapped[int] = mapped_column(ForeignKey('students.id'))
    course_id: Mapped[int] = mapped_column(ForeignKey('courses.id'))
    score: Mapped[int]
    student: Mapped[Student] = relationship(back_populates='enrollments')
    course: Mapped[Course] = relationship(back_populates='enrollments')
models.py, 2-ci hissə (1-ci hissənin davamı).
Python
from sqlalchemy import create_engine, func, select
from sqlalchemy.orm import Session, selectinload
from models import Base, Course, Enrollment, Student

engine = create_engine('sqlite://')
Base.metadata.create_all(engine)
with Session(engine) as session:
    algebra, python = Course(title='Algebra'), Course(title='Python Basics')
    aysel = Student(first_name='Aysel', city='Bakı')
    murad = Student(first_name='Murad', city='Gəncə')
    session.add_all([Enrollment(student=aysel, course=algebra, score=92),
                     Enrollment(student=aysel, course=python, score=88),
                     Enrollment(student=murad, course=algebra, score=75)])
    session.commit()

    for e in aysel.enrollments:
        print(e.course.title, e.score)
    stmt = (select(Course.title, func.avg(Enrollment.score))
            .join(Course.enrollments).group_by(Course.id).order_by(Course.title))
    print(session.execute(stmt).all())
    stmt = select(Student).options(selectinload(Student.enrollments))
    print([(s.first_name, len(s.enrollments)) for s in session.scalars(stmt)])

Gözlənilən nəticə

Algebra 92
Python Basics 88
[('Algebra', 83.5), ('Python Basics', 88.0)]
[('Aysel', 2), ('Murad', 1)]
Enrollment əlavə olunanda onunla bağlı şagird və kurs da avtomatik sessiyaya düşür. join(Course.enrollments) JOIN şərtini ForeignKey-dən özü tapır; Algebra-nın ortası (92 + 75) / 2 = 83,5.

create_all yalnız olmayan cədvəlləri yaradır: modelə yeni sütun əlavə etsən, mövcud cədvəl dəyişməyəcək. Real layihədə sxem miqrasiyalarla dəyişdirilir — SQLAlchemy-nin müəllifinin yazdığı Alembic modellərlə bazanı müqayisə edir və ALTER TABLE skriptlərini versiyalar şəklində yaradır (env.py-də target_metadata = Base.metadata göstərilməlidir):

Terminal
pip install alembic
alembic init migrations
alembic revision --autogenerate -m "add birth_date to students"
alembic upgrade head
alembic downgrade -1

Tapşırıq

Bu ORM sorğusunu SQL-ə çevir və nümunə bazasında işə sal: select(Course.title, func.count(Enrollment.id), func.max(Enrollment.score)).join(Course.enrollments).group_by(Course.id).order_by(Course.title). Sütunları title, students və best adlandır.

Tapşırıq · SQL
SELECT courses.title AS title
FROM courses
ORDER BY courses.title;
Gözlənilən nəticə
title | students | best
Algebra | 4 | 97
English B1 | 2 | 90
Geometry | 3 | 95
Mechanics | 4 | 94
Organic Chemistry | 2 | 72
Python Basics | 3 | 99
World History | 2 | 93

Tapşırıq

ORM-in daxilində olanı təkrarla: insert_sql(table, row) funksiyası lüğətdən parametrli INSERT sorğusu və qiymətlər kortejini qaytarsın. Kod sonuncu SQL-i və cədvəlin məzmununu çap edir; apostroflu O'Neil adı problemsiz yazılmalıdır.

Tapşırıq · Python
import sqlite3

def insert_sql(table, row):
    # build 'INSERT INTO table (col1, col2) VALUES (?, ?)' and the tuple of values
    return '', ()

conn = sqlite3.connect(':memory:')
conn.execute('CREATE TABLE students (id INTEGER PRIMARY KEY, first_name TEXT, city TEXT)')
for row in [{'first_name': 'Aysel', 'city': 'Bakı'}, {'first_name': "O'Neil", 'city': 'London'}]:
    sql, params = insert_sql('students', row)
    conn.execute(sql, params)
print(sql)
print(conn.execute('SELECT * FROM students').fetchall())
Gözlənilən nəticə
INSERT INTO students (first_name, city) VALUES (?, ?)
[(1, 'Aysel', 'Bakı'), (2, "O'Neil", 'London')]

Yadda saxla

  • create_engine(url) bazaya giriş nöqtəsidir; engine.begin() tranzaksiyadır, text() sorğularında qiymətlər :name parametrləri ilə ötürülür.
  • Model: DeclarativeBase-dən sinif, __tablename__, Mapped[...] və mapped_column(...); | None NULL-a icazə verir; cədvəlləri Base.metadata.create_all yaradır.
  • Session iş vahididir: add, delete və atribut dəyişiklikləri commit()-də INSERT, DELETE, UPDATE olur; get obyekti ilkin açara görə tapır.
  • select(...) sorğunu təsvir edir; scalars obyektlər, execute sətirlər qaytarır; print(stmt) və echo=True SQL-i göstərir.
  • ForeignKey + relationship(back_populates=...) əlaqələri qurur; N+1-dən selectinload qoruyur; sxem dəyişiklikləri Alembic miqrasiyaları ilə edilir.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. engine = create_engine('sqlite:///school.db') sətri nə edir?