Allt du behöver veta om Python- och objektrelationskartor

Allt du behöver veta om Python- och objektrelationskartor

Du kanske har hört talas om objektrelationell kartläggning (ORM). Du kanske till och med har använt en, men vad är de exakt? Och hur använder du dem i Python?





Här är allt du behöver veta om ORM och Python.



Vad är en ORM?

Objekt-relationell kartläggning (ORM) är en programmeringsteknik som används för att komma åt en databas. Det exponerar din databas i en serie objekt. Du behöver inte skriva SQL -kommandon för att infoga eller hämta data, du använder en serie attribut och metoder kopplade till objekt.





Det kan låta komplext och onödigt, men de kan spara mycket tid och hjälpa till att kontrollera åtkomsten till din databas.

Här är ett exempel. Säg att när du sätter in ett lösenord i din databas vill du hasha det, som förklaras i webbplatsens lösenordsäkerhet. Detta är inte ett problem för enkla användningsfall --- du gör beräkningen innan du sätter in den. Men vad händer om du behöver infoga en post på många ställen i koden? Vad händer om en annan programmerare sätter in i ditt bord och du inte vet om det?



Genom att använda en ORM kan du skriva kod för att säkerställa att när som helst och var som helst rad eller fält i din databas öppnas, körs din andra anpassade kod först.

Detta fungerar också som en 'enda sanningskälla'. Om du vill ändra en anpassad beräkning behöver du bara ändra den på ett ställe, inte flera. Det är möjligt att utföra många av dessa principer med objektorienterad programmering (OOP) i Python , men ORM fungerar tillsammans med OOP -principer för att kontrollera åtkomst till en databas.



Det finns vissa saker att se upp för när du använder en ORM, och det finns omständigheter där du kanske inte vill använda en, men de anses i allmänhet vara bra att ha, särskilt i en stor kodbas.

ORM i Python med SQLAlchemy

Precis som många andra uppgifter i Python är det snabbare och enklare att importera en modul än att skriva din egen. Naturligtvis är det möjligt att skriva din egen ORM, men varför uppfinna hjulet på nytt?



Följande exempel använder alla SQLAlchemy , en populär Python ORM, men många av principerna gäller oavsett implementering.

Konfigurera Python för SQLAlchemy

Innan du hoppar direkt måste du konfigurera din maskin för Python -utveckling med SQLAlchemy.

Du måste använda Python 3.6 för att följa med dessa exempel. Även om äldre versioner fungerar, kommer koden nedan att behöva ändras innan den körs. Osäker på skillnaderna? Våra vanliga frågor om Python täcker alla skillnader.

Innan du kodar bör du skapa en Python -miljö som förhindrar problem med andra importerade Python -paket.

Se till att du har PIP, Python -pakethanteraren installerad, som levereras med de flesta moderna versioner av Python.

När du är redo att gå kan du börja med att göra SQLAlchemy redo. Från din Python -miljö på kommandoraden, installera SQLAlchemy med pip installera kommando:

pip install SQLAlchemy-1.2.9

De 1.2.9 är versionsnumret. Du kan lämna detta för att få det senaste paketet, men det är bra att vara specifik. Du vet inte när en ny version kan bryta din nuvarande kod.

Nu är du redo att börja koda. Du kan behöva förbereda din databas för att acceptera en Python -anslutning, men följande exempel använder alla en SQLite databas skapad i minnet nedan.

Modeller i SQLAlchemy

En av nyckelkomponenterna i en ORM är a modell . Detta är en Python -klass som beskriver hur ett bord ska se ut och hur det ska fungera. Det är ORM -versionen av SKAPA BORD uttalande i SQL. Du behöver en modell för varje tabell i din databas.

Öppna din favorittextredigerare eller IDE och skapa en ny fil som heter test.py . Ange denna startkod, spara filen och kör den:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database

Denna kod gör flera saker. Importen är nödvändig så att Python förstår var man kan hitta de SQLAlchemy -moduler den behöver. Dina modeller kommer att använda deklarativ_bas senare, och det konfigurerar alla nya modeller att fungera som förväntat.

De skapa_motor metoden skapar en ny anslutning till din databas. Om du redan har en databas måste du ändra sqlite: // till din databas -URI. Som det är kommer den här koden endast att skapa en ny databas i minnet. Databasen förstörs när koden körs.

Slutligen, skapa_all method skapar alla tabeller som definieras i dina lägen i din databas. Eftersom du inte har definierat några modeller än så kommer ingenting att hända. Kör den här koden så att du inte har några problem eller stavfel.

Låt oss göra en modell. Lägg till ytterligare en import högst upp i filen:

from sqlalchemy import Column, Integer, String

Detta importerar Kolumn , Heltal , och Sträng moduler från SQLAlchemy. De definierar hur databastabeller, fält, kolumner och datatyper fungerar.

Under deklarativ_bas , skapa din modellklass:

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

Detta enkla exempel använder bilar, men dina tabeller kan innehålla data.

Varje klass måste ärva Bas . Ditt databastabellnamn definieras i __tabellnamn__ . Detta bör vara samma som klassnamnet, men det här är bara en rekommendation, och ingenting går sönder om de inte matchar.

Slutligen definieras varje kolumn som en pythonvariabel inom klassen. Olika datatyper används och primärnyckel attribut berättar för SQLAlchemy att skapa id kolumn som primärnyckel.

Fortsätt och lägg till en sista import, den här gången för Främmande nyckel modul. Lägg till detta tillsammans med din Kolumn importera:

from sqlalchemy import Column, ForeignKey, Integer, String

Skapa nu en andra modellklass. Denna klass kallas Bilägare , och lagrar ägarinformation om specifika bilar som lagras i Bilar tabell:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

Det finns flera nya attribut som introduceras här. De bil_id fält definieras som en främmande nyckel. Det är kopplat till id i bilar tabell. Lägg märke till hur tabellnamnet för små bokstäver används, i stället för klassnamnet med stora bokstäver.

Slutligen ett attribut av bil definieras som a relation . Detta gör att din modell kan komma åt Bilar tabell genom denna variabel. Detta visas nedan.

Om du kör den här koden nu ser du att ingenting händer. Detta beror på att du inte har sagt till den att göra något märkbart än.

Objekt i SQLAlchemy

Nu när dina modeller har skapats kan du börja komma åt objekten och läsa och skriva data. Det är en bra idé att placera din logik i sin egen klass och fil, men för närvarande kan den hålla sig bredvid modellerna.

Skriva data

I det här exemplet måste du infoga några data i databasen innan du kan läsa den. Om du använder en befintlig databas kan du redan ha data. Hur som helst är det fortfarande mycket användbart att veta hur man sätter in data.

Du kanske är van att skriva FÖRA IN uttalanden i SQL. SQLAlchemy hanterar detta åt dig. Så här sätter du in en rad i Bilar modell. Börja med en ny import för sessionmaker :

from sqlalchemy.orm import sessionmaker

Detta behövs för att skapa session och DBSession objekt som används för att läsa och skriva data:

DBSession = sessionmaker(bind=engine)
session = DBSession()

Lägg det här under din skapa_all påstående:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

Låt oss bryta ner den koden. Variabeln bil1 definieras som ett objekt baserat på Bilar modell. Dess märke och färg anges som parametrar. Det här är som att säga 'gör mig till en bil, men skriv inte till databasen ännu'. Den här bilen finns i minnet men väntar på att bli skriven.

Lägg till bilen till sessionen med session. lägg till och skriv det sedan till databasen med session.commit .

Låt oss nu lägga till en ägare:

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

Denna kod är nästan identisk med den tidigare infogningen för Bilar modell. Den största skillnaden här är det bil_id är en främmande nyckel så behöver ett rad -ID som finns i den andra tabellen. Detta nås via bil1.id fast egendom.

Du behöver inte fråga databasen eller returnera några id: er, eftersom SQLAlchemy hanterar detta åt dig (så länge du begär data först).

Läsa data

När du har skrivit några data kan du börja läsa den igen. Så här frågar du efter Bilar och Bilägare tabeller:

result = session.query(Cars).all()

Det är så enkelt. Genom att använda fråga metod som finns i session , anger du modellen och använder sedan Allt metod för att hämta alla resultat. Om du vet att det bara kommer ett resultat kan du använda först metod:

result = session.query(Cars).first()

När du har frågat efter modellen och lagrat dina returnerade resultat i en variabel kan du komma åt data via objektet:

print(result[0].color)

Detta skriver ut färgen 'silver', eftersom posten är den första raden. Du kan gå över resultatobjektet om du vill.

När du definierade relationen i din modell är det möjligt att komma åt data i relaterade tabeller utan att ange en koppling:

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

Detta fungerar eftersom din modell innehåller detaljer om din bordstruktur och bil attribut definierades som en länk till bilar tabell.

Vad är inte att gilla med ORM?

Denna handledning täckte bara det grundläggande, men när du väl har koll på dem kan du gå vidare med de avancerade ämnena. Det finns några potentiella nackdelar med ORM:

  • Du måste skriva din modell innan några frågor kan köras.
  • Det är en annan ny syntax att lära sig.
  • Det kan vara för komplext för enkla behov.
  • Du måste ha en bra databasdesign till att börja med.

Dessa frågor är inte ett stort problem i sig, men de är saker att se upp för. Om du arbetar med en befintlig databas kan du fastna.

Om du inte är övertygad om att en ORM är rätt verktyg för dig, se till att du läser om viktiga SQL -kommandon programmerare bör veta .

Dela med sig Dela med sig Tweet E-post Ska du uppgradera till Windows 11 omedelbart?

Windows 11 kommer snart, men ska du uppdatera så snart som möjligt eller vänta några veckor? Låt oss ta reda på.

Läs Nästa Relaterade ämnen
  • Programmering
  • Pytonorm
  • SQL
  • Handledning för kodning
Om författaren Joe Coburn(136 artiklar publicerade)

Joe är utbildad i datavetenskap från University of Lincoln, Storbritannien. Han är en professionell mjukvaruutvecklare, och när han inte flyger drönare eller skriver musik, kan han ofta hittas ta foton eller producera videor.

hur man fixar xbox one controller
Mer från Joe Coburn

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera