0Pricing
FastAPI Backend Development Bootcamp · Lekcja

Podstawy ORM SQLAlchemy

Rozpoczną Państwo pracę z mechanizmem Object Relational Mapper (ORM) biblioteki SQLAlchemy, aby definiować modele baz danych i korzystać z bazy danych.

Podstawy ORM SQLAlchemy to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Bridging Code and Databases

Welcome to SQLAlchemy ORM! You'll learn how to connect your Python code to a database in a powerful, object-oriented way.

An Object Relational Mapper (ORM) is a tool that helps you interact with a database using objects from your programming language, instead of writing raw SQL.

  • It maps database tables to Python classes.
  • It maps database rows to Python objects.
  • It maps database columns to Python attributes.

This makes database operations feel more like working with regular Python objects.

Meet SQLAlchemy: Your ORM Tool

SQLAlchemy is a comprehensive and powerful ORM for Python. It provides a full suite of well-known persistence patterns for efficient and high-performing database access.

We'll focus on its ORM capabilities, which allow you to define your database structure (schema) using Python classes and interact with data using instances of those classes.

It supports many databases, including SQLite, PostgreSQL, MySQL, and more!

The Foundation: Declarative Base

To start defining our database models, we need a special base class. SQLAlchemy's Declarative Base provides this foundation.

It's essentially a factory that generates a base class which your ORM models will inherit from. This base class connects your Python classes to the underlying database tables.

Here's how you get it:

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

Defining Your First Model

Once you have your Base, you can define your database tables as Python classes. Each class will represent a table, and its attributes will represent the columns.

Let's create a simple User model. It will have an id and a name.

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))

Model Attributes: Columns

In our User model, id and name are defined using Column objects. The Column function lets you specify details about each database column:

  • Data Type: Integer for whole numbers, String for text. SQLAlchemy has many more!
  • Primary Key: primary_key=True marks a column as the unique identifier for each row.
  • Length: String(50) sets a maximum length for text fields.
  • Nullable: By default, columns are nullable. You can set nullable=False to require a value.

The __tablename__ attribute is crucial; it tells SQLAlchemy the actual name of the table in your database.

Setting Up the Database Engine

Before we can create tables or interact with the database, SQLAlchemy needs to know where it is! This is where the Engine comes in.

An Engine is the starting point for any SQLAlchemy application. It connects your application to a specific database using a connection string.

For simplicity, we'll use an in-memory SQLite database, which is great for testing as it disappears when the program ends:

from sqlalchemy import create_engine

# Connect to an in-memory SQLite database
engine = create_engine('sqlite:///:memory:')

# For a file-based SQLite database:
# engine = create_engine('sqlite:///./test.db')

Creating Database Tables

With our Base, defined models, and engine, we can now create the actual database tables!

The Base.metadata.create_all(engine) method inspects all classes that inherit from Base and creates the corresponding tables in the database connected by the engine.

If the tables already exist, SQLAlchemy won't try to recreate them, preventing errors.

Full Example: Define & Create

Let's put it all together! Run this code to see how to define a model and create its table in an in-memory SQLite database.

Notice how we import everything needed, define Base, create our User model, set up the engine, and finally, create the tables.

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

# 1. Define the Base for ORM models
Base = declarative_base()

# 2. Define a Model (e.g., User table)
class User(Base):
    __tablename__ = 'users' # The actual table name in the database
    id = Column(Integer, primary_key=True) # Unique ID, automatically managed
    name = Column(String(50), nullable=False) # User's name, max 50 chars, required

    # A helpful representation for printing User objects
    def __repr__(self):
        return f"<User(id={self.id}, name='{self.name}')>"

# 3. Create a database engine
# Using an in-memory SQLite database for simplicity
engine = create_engine('sqlite:///:memory:')

# 4. Create all tables defined in Base
Base.metadata.create_all(engine)

print("Database tables created successfully!")
print("The 'users' table is now ready for data.")

Your Database Interaction Hub: The Session

Defining models and creating tables are just the first steps. To actually interact with the data (add, query, update, delete), you need a Session.

A Session is like a temporary workspace for your database operations. It holds all the objects you've loaded or created and keeps track of changes.

You create a Session using sessionmaker and bind it to your engine:

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

# (Assume 'engine' is already created as shown before)
engine = create_engine('sqlite:///:memory:')

# Create a Session factory
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# To get a session:
# db = SessionLocal()
# try:
#     # Perform operations with db
#     pass
# finally:
#     db.close()

Quick Check: Model Setup

You've learned how to set up the basics of SQLAlchemy ORM. Let's test your understanding of the core components.

Recap: SQLAlchemy ORM Basics

Great job! You've taken your first steps into the world of SQLAlchemy ORM.

Here's what we covered:

  • What is an ORM: Maps Python objects to database tables.
  • SQLAlchemy: A powerful Python ORM.
  • Declarative Base: The foundation (Base = declarative_base()) for your models.
  • Defining Models: Creating Python classes (like User) that inherit from Base.
  • Columns: Using Column with data types (Integer, String) and attributes (primary_key).
  • Engine: Connecting to your database (create_engine).
  • Table Creation: Bringing models to life in the database (Base.metadata.create_all(engine)).
  • Session: Your workspace for database interactions (sessionmaker).

Next, we'll learn how to add, query, update, and delete data using these concepts!

Często zadawane pytania

Czy lekcja „Podstawy ORM SQLAlchemy” jest bezpłatna?

Tak — pełny tekst „Podstawy ORM SQLAlchemy” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy ORM SQLAlchemy”?

Rozpoczną Państwo pracę z mechanizmem Object Relational Mapper (ORM) biblioteki SQLAlchemy, aby definiować modele baz danych i korzystać z bazy danych. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?

Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Podstawy ORM SQLAlchemy”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?

Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy ORM SQLAlchemy
  2. Łączenie FastAPI z PostgreSQL
  3. Operacje CRUD z SQLAlchemy
  4. Migracje bazy danych za pomocą Alembic
← Powrót do FastAPI Backend Development Bootcamp