Bootcamp i backendutvikling med FastAPI · leksjon

Grunnleggende SQLAlchemy ORM

Kom i gang med SQLAlchemy sin Object Relational Mapper (ORM) for å definere databasemodeller og samhandle med databasen.

Leksjon 1 av 411 trinn

Grunnleggende SQLAlchemy ORM er en gratis leksjon i Bootcamp i backendutvikling med FastAPI på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med FastAPI, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.

Forbindelsen mellom kode og databaser

Velkommen til SQLAlchemy ORM! Du skal lære hvordan du kobler Python-koden din til en database på en kraftig og objektorientert måte.

En Object Relational Mapper (ORM) er et verktøy som hjelper deg med å samhandle med en database ved hjelp av objekter fra programmeringsspråket ditt, i stedet for å skrive SQL direkte.

Det kobler databasetabeller til Python-klasser.
Det kobler databaserekker til Python-objekter.
Det kobler databasekolonner til Python-attributter.

Dette gjør at databaseoperasjoner føles mer som arbeid med vanlige Python-objekter.

Møt SQLAlchemy: ORM-verktøyet ditt

SQLAlchemy er en omfattende og kraftig ORM for Python. Den tilbyr et komplett sett med velkjente persistensmønstre for effektiv databaseaksess med høy ytelse.

Vi fokuserer på ORM-funksjonene, som lar deg definere databasestrukturen, altså skjemaet, ved hjelp av Python-klasser og samhandle med data ved hjelp av instanser av disse klassene.

Den støtter mange databaser, blant annet SQLite, PostgreSQL og MySQL!

Grunnlaget: Declarative Base

For å begynne å definere databasemodellene våre trenger vi en spesiell basisklasse. SQLAlchemy sin Declarative Base danner dette grunnlaget.

Det er i praksis en fabrikk som genererer en basisklasse som ORM-modellene dine arver fra. Denne basisklassen kobler Python-klassene dine til de underliggende databasetabellene.

Slik henter du den:

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

Definere din første modell

Når du har Base, kan du definere databasetabellene som Python-klasser. Hver klasse representerer en tabell, og attributtene representerer kolonnene.

La oss opprette en enkel User-modell. Den skal ha en id og et 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))

Modellattributter: Kolonner

I User-modellen vår er id og name definert ved hjelp av Column-objekter. Med funksjonen Column kan du angi detaljer om hver databasekolonne:

Datatype: Integer for heltall og String for tekst. SQLAlchemy har mange flere!
Primærnøkkel: primary_key=True markerer en kolonne som den unike identifikatoren for hver rad.
Lengde: String(50) angir maksimal lengde for tekstfelt.
Nullable: Kolonner kan som standard ha nullverdi. Du kan angi nullable=False for å kreve en verdi.

Attributtet __tablename__ er avgjørende; det forteller SQLAlchemy det faktiske navnet på tabellen i databasen.

Konfigurere databasemotoren

Før vi kan opprette tabeller eller samhandle med databasen, må SQLAlchemy vite hvor den er! Det er her Engine kommer inn.

En Engine er utgangspunktet for enhver SQLAlchemy-applikasjon. Den kobler applikasjonen til en bestemt database ved hjelp av en tilkoblingsstreng.

For enkelhets skyld bruker vi en SQLite-database i minnet. Den egner seg godt til testing fordi den forsvinner når programmet avsluttes:

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

Opprette databasetabeller

Med Base, de definerte modellene og engine kan vi nå opprette de faktiske databasetabellene!

Metoden Base.metadata.create_all(engine) undersøker alle klasser som arver fra Base, og oppretter de tilhørende tabellene i databasen som er koblet til engine.

Hvis tabellene allerede finnes, prøver ikke SQLAlchemy å opprette dem på nytt, slik at feil unngås.

Fullstendig eksempel: Definere og opprette

La oss sette alt sammen! Kjør denne koden for å se hvordan du definerer en modell og oppretter tabellen i en SQLite-database i minnet.

Legg merke til hvordan vi importerer alt som trengs, definerer Base, oppretter User-modellen, konfigurerer engine og til slutt oppretter tabellene.

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

Senteret for databaseinteraksjon: Session

Å definere modeller og opprette tabeller er bare de første stegene. For faktisk å samhandle med dataene, altså legge til, spørre etter, oppdatere og slette data, trenger du en Session.

En Session er som et midlertidig arbeidsområde for databaseoperasjonene dine. Den inneholder alle objektene du har lastet inn eller opprettet, og holder oversikt over endringer.

Du oppretter en Session ved hjelp av sessionmaker og knytter den til 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()

Rask kontroll: Konfigurere modellen

Du har lært hvordan du setter opp det grunnleggende i SQLAlchemy ORM. La oss teste forståelsen din av kjer komponentene.

Besvar den i den interaktive leksjonen

Repetisjon: Grunnleggende om SQLAlchemy ORM

Godt jobbet! Du har tatt dine første steg inn i SQLAlchemy ORM-verdenen.

Her er det vi gikk gjennom:

Hva er en ORM: Kobler Python-objekter til databasetabeller.
SQLAlchemy: En kraftig ORM for Python.
Declarative Base: Grunnlaget (Base = declarative_base()) for modellene dine.
Definere modeller: Opprette Python-klasser (som User) som arver fra Base.
Kolonner: Bruke Column med datatyper (Integer, String) og attributter (primary_key).
Engine: Koble til databasen din (create_engine).
Opprette tabeller: Gjøre modellene tilgjengelige i databasen (Base.metadata.create_all(engine)).
Session: Arbeidsområdet ditt for interaksjoner med databasen (sessionmaker).

Deretter skal vi lære hvordan vi kan legge til, spørre etter, oppdatere og slette data ved hjelp av disse konseptene!

Gratis å komme i gang

Lær deg Bootcamp i backendutvikling med FastAPI med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 21
Leksjoner: 84

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Grunnleggende SQLAlchemy ORM» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Bootcamp i backendutvikling med FastAPI, inkludert «Grunnleggende SQLAlchemy ORM», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.

Hva lærer jeg i «Grunnleggende SQLAlchemy ORM»?

Kom i gang med SQLAlchemy sin Object Relational Mapper (ORM) for å definere databasemodeller og samhandle med databasen. Du øver på Bootcamp i backendutvikling med FastAPI med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med FastAPI?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med FastAPI på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Grunnleggende SQLAlchemy ORM»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med FastAPI-leksjonen?

Ja. Alle Bootcamp i backendutvikling med FastAPI-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Bootcamp i backendutvikling med FastAPI