Bootcamp i backendutveckling med FastAPI · Lektion

Grunderna i SQLAlchemy ORM

Kom igång med SQLAlchemy:s Object Relational Mapper (ORM) för att definiera databasmodeller och interagera med databasen.

Lektion 1 av 411 steg

Grunderna i SQLAlchemy ORM är en gratis lektion i Bootcamp i backendutveckling med FastAPI på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med FastAPI, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

Överbrygga kod och databaser

Välkommen till SQLAlchemy ORM! Du kommer att lära dig hur du ansluter Python-kod till en databas på ett kraftfullt, objektorienterat sätt.

En Object Relational Mapper (ORM) är ett verktyg som hjälper dig att interagera med en databas genom att använda objekt från ditt programmeringsspråk i stället för att skriva rå SQL.

Den mappar databastabeller till Python-klasser.
Den mappar databasrader till Python-objekt.
Den mappar databaskolumner till Python-attribut.

Detta gör att databasoperationer känns mer som att arbeta med vanliga Python-objekt.

Möt SQLAlchemy: ditt ORM-verktyg

SQLAlchemy är ett omfattande och kraftfullt ORM för Python. Det tillhandahåller en komplett uppsättning välkända persistensmönster för effektiv och högpresterande databasåtkomst.

Vi fokuserar på ORM-funktionerna, som låter dig definiera databasens struktur, alltså schemat, med Python-klasser och arbeta med data genom instanser av dessa klasser.

Det stöder många databaser, bland annat SQLite, PostgreSQL och MySQL!

Grunden: Declarative Base

För att börja definiera våra databasmodeller behöver vi en särskild basklass. SQLAlchemys Declarative Base utgör denna grund.

Det är i praktiken en fabrik som genererar en basklass som dina ORM-modeller ärver från. Denna basklass kopplar dina Python-klasser till de underliggande databastabellerna.

Så här hämtar du den:

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

Definiera din första modell

När du har din Base kan du definiera dina databastabeller som Python-klasser. Varje klass representerar en tabell och dess attribut representerar kolumnerna.

Vi skapar en enkel User-modell. Den ska ha ett id och ett 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))

Modellattribut: kolumner

I vår User-modell definieras id och name med Column-objekt. Funktionen Column låter dig ange information om varje databaskolumn:

Datatyp: Integer för heltal och String för text. SQLAlchemy har många fler!
Primärnyckel: primary_key=True markerar en kolumn som unik identifierare för varje rad.
Längd: String(50) anger en maximal längd för textfält.
Nullable: Kolumner är som standard nullable. Du kan ange nullable=False för att kräva ett värde.

Attributet __tablename__ är avgörande. Det anger det faktiska namnet på tabellen i din databas.

Konfigurera databasmotorn

Innan vi kan skapa tabeller eller interagera med databasen måste SQLAlchemy veta var den finns! Det är här Engine kommer in.

En Engine är utgångspunkten för alla SQLAlchemy-applikationer. Den ansluter applikationen till en specifik databas med hjälp av en anslutningssträng.

För enkelhetens skull använder vi en SQLite-databas i minnet. Den passar bra för testning eftersom den försvinner när programmet avslutas:

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

Skapa databastabeller

Med vår Base, våra definierade modeller och vår engine kan vi nu skapa de faktiska databastabellerna!

Metoden Base.metadata.create_all(engine) granskar alla klasser som ärver från Base och skapar motsvarande tabeller i databasen som engine ansluter till.

Om tabellerna redan finns försöker SQLAlchemy inte skapa dem igen, vilket förhindrar fel.

Fullständigt exempel: definiera och skapa

Vi sätter ihop allt! Kör denna kod för att se hur du definierar en modell och skapar dess tabell i en SQLite-databas i minnet.

Observera hur vi importerar allt som behövs, definierar Base, skapar vår User-modell, konfigurerar engine och slutligen skapar tabellerna.

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

Din central för databasinteraktion: Session

Att definiera modeller och skapa tabeller är bara de första stegen. För att faktiskt interagera med data, alltså lägga till, fråga efter, uppdatera och ta bort data, behöver du en Session.

En Session är som en tillfällig arbetsyta för dina databasoperationer. Den innehåller alla objekt du har läst in eller skapat och håller reda på ändringar.

Du skapar en Session med sessionmaker och binder den till din 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()

Snabbtest: konfigurera modellen

Du har lärt dig hur du konfigurerar grunderna i SQLAlchemy ORM. Nu testar vi dina kunskaper om de centrala komponenterna.

Besvara frågan i den interaktiva lektionen

Repetition: grunderna i SQLAlchemy ORM

Bra jobbat! Du har tagit dina första steg in i SQLAlchemy ORM:s värld.

Här är det vi har gått igenom:

Vad är ett ORM: Mappar Python-objekt till databastabeller.
SQLAlchemy: Ett kraftfullt Python-ORM.
Deklarativ bas: Grunden (Base = declarative_base()) för dina modeller.
Definiera modeller: Skapa Python-klasser (som User) som ärver från Base.
Kolumner: Använda Column med datatyper (Integer, String) och attribut (primary_key).
Engine: Ansluta till din databas (create_engine).
Skapa tabeller: Göra modellerna tillgängliga i databasen (Base.metadata.create_all(engine)).
Session: Din arbetsyta för databasinteraktioner (sessionmaker).

Härnäst lär vi oss hur du kan lägga till, söka efter, uppdatera och ta bort data med hjälp av dessa koncept!

Gratis att börja

Lär dig Bootcamp i backendutveckling med FastAPI med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grunderna i SQLAlchemy ORM” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Bootcamp i backendutveckling med FastAPI, inklusive ”Grunderna i SQLAlchemy ORM”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i SQLAlchemy ORM”?

Kom igång med SQLAlchemy:s Object Relational Mapper (ORM) för att definiera databasmodeller och interagera med databasen. Ni övar på Bootcamp i backendutveckling med FastAPI med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med FastAPI?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med FastAPI på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grunderna i SQLAlchemy ORM”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med FastAPI-lektionen?

Ja. Varje Bootcamp i backendutveckling med FastAPI-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Bootcamp i backendutveckling med FastAPI