Bootcamp backendontwikkeling met FastAPI · Les

De basis van SQLAlchemy ORM

Ga aan de slag met SQLAlchemy's Object Relational Mapper (ORM) om databasemodellen te definiëren en met uw database te werken.

Les 1 van 411 stappen

De basis van SQLAlchemy ORM is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.

Code en databases verbinden

Welkom bij SQLAlchemy ORM! Je leert hoe je je Python-code op een krachtige, objectgeoriënteerde manier met een database verbindt.

Een Object-Relational Mapper (ORM) is een hulpmiddel waarmee je met objecten uit je programmeertaal met een database werkt, in plaats van onbewerkte SQL te schrijven.

Het koppelt databasetabellen aan Python-klassen.
Het koppelt databaseregels aan Python-objecten.
Het koppelt databasekolommen aan Python-attributen.

Daardoor voelen databasebewerkingen meer aan als werken met gewone Python-objecten.

Maak kennis met SQLAlchemy: je ORM-hulpmiddel

SQLAlchemy is een uitgebreide en krachtige ORM voor Python. Het biedt een volledige verzameling bekende persistentiepatronen voor efficiënte en goed presterende databasetoegang.

We richten ons op de ORM-mogelijkheden, waarmee je de structuur van je database (schema) kunt definiëren met Python-klassen en met instanties van die klassen met gegevens kunt werken.

Het ondersteunt veel databases, waaronder SQLite, PostgreSQL, MySQL en meer!

De basis: Declarative Base

Om onze databasemodellen te definiëren, hebben we eerst een speciale basisklasse nodig. SQLAlchemy's Declarative Base biedt deze basis.

Het is in feite een factory die een basisklasse genereert waarvan je ORM-modellen overerven. Deze basisklasse verbindt je Python-klassen met de onderliggende databasetabellen.

Zo haal je die op:

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

Je eerste model definiëren

Zodra je Base hebt, kun je je databasetabellen definiëren als Python-klassen. Elke klasse stelt een tabel voor en de attributen ervan stellen de kolommen voor.

We maken een eenvoudig User-model. Dit model krijgt een id en een 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))

Modelattributen: kolommen

In ons User-model worden id en name gedefinieerd met Column-objecten. Met de functie Column kun je details van elke databasekolom opgeven:

Gegevenstype: Integer voor gehele getallen en String voor tekst. SQLAlchemy heeft er nog veel meer!
Primaire sleutel: primary_key=True markeert een kolom als de unieke identificatie van elke regel.
Lengte: String(50) stelt een maximale lengte in voor tekstvelden.
Nullable: standaard kunnen kolommen de waarde null bevatten. Met nullable=False kun je een waarde verplicht stellen.

Het attribuut __tablename__ is essentieel: het vertelt SQLAlchemy de werkelijke naam van de tabel in je database.

De database-engine instellen

Voordat we tabellen kunnen maken of met de database kunnen werken, moet SQLAlchemy weten waar die zich bevindt! Daarvoor gebruiken we de Engine.

Een Engine is het startpunt van elke SQLAlchemy-toepassing. Deze verbindt je toepassing via een verbindingsreeks met een specifieke database.

Voor de eenvoud gebruiken we een SQLite-database in het geheugen. Die is handig voor tests, omdat hij verdwijnt zodra het programma eindigt:

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')

Databasetabellen maken

Met onze Base, gedefinieerde modellen en engine kunnen we nu de daadwerkelijke databasetabellen maken!

De methode Base.metadata.create_all(engine) controleert alle klassen die van Base overerven en maakt de bijbehorende tabellen in de database die via de engine is verbonden.

Als de tabellen al bestaan, probeert SQLAlchemy ze niet opnieuw te maken, waardoor fouten worden voorkomen.

Volledig voorbeeld: definiëren en maken

We voegen alles samen! Voer deze code uit om te zien hoe je een model definieert en de bijbehorende tabel maakt in een SQLite-database in het geheugen.

Let erop hoe we alles importeren wat nodig is, Base definiëren, ons User-model maken, de engine instellen en ten slotte de tabellen maken.

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.")

Je centrale plek voor database-interactie: de Session

Modellen definiëren en tabellen maken zijn pas de eerste stappen. Om daadwerkelijk met de gegevens te werken (toevoegen, opvragen, bijwerken en verwijderen), heb je een Session nodig.

Een Session is een tijdelijke werkruimte voor je databasebewerkingen. Deze bevat alle objecten die je hebt geladen of gemaakt en houdt wijzigingen bij.

Je maakt een Session met sessionmaker en koppelt die aan je 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()

Korte controle: model instellen

Je hebt geleerd hoe je de basis van SQLAlchemy ORM instelt. Laten we testen of je de belangrijkste onderdelen begrijpt.

Beantwoord dit in de interactieve les

Terugblik: de basis van SQLAlchemy ORM

Goed gedaan! Je hebt je eerste stappen gezet in de wereld van SQLAlchemy ORM.

Dit hebben we behandeld:

Wat is een ORM: koppelt Python-objecten aan databasetabellen.
SQLAlchemy: een krachtige Python-ORM.
Declarative Base: de basis (Base = declarative_base()) voor je modellen.
Modellen definiëren: Python-klassen maken (zoals User) die overerven van Base.
Kolommen: Column gebruiken met gegevenstypen (Integer, String) en kenmerken (primary_key).
Engine: verbinding maken met je database (create_engine).
Tabellen maken: modellen tot leven brengen in de database (Base.metadata.create_all(engine)).
Sessie: je werkruimte voor interacties met de database (sessionmaker).

Vervolgens leer je hoe je met deze concepten gegevens toevoegt, opvraagt, bijwerkt en verwijdert!

Gratis beginnen

Leer Bootcamp backendontwikkeling met FastAPI met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 21
Lessen: 84

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “De basis van SQLAlchemy ORM” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “De basis van SQLAlchemy ORM”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.

Wat leer ik in “De basis van SQLAlchemy ORM”?

Ga aan de slag met SQLAlchemy's Object Relational Mapper (ORM) om databasemodellen te definiëren en met uw database te werken. Je oefent met Bootcamp backendontwikkeling met FastAPI door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Bootcamp backendontwikkeling met FastAPI te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “De basis van SQLAlchemy ORM”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met FastAPI?

Ja. Elke les over Bootcamp backendontwikkeling met FastAPI bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Bootcamp backendontwikkeling met FastAPI