sqlalchemyAan de slag met sqlalchemy


Opmerkingen

FILOSOFIE VAN SQLALCHEMY

Van de SQLAlchemy-website :

SQL-databases gedragen zich minder als objectcollecties naarmate de grootte en de prestaties er meer toe doen; objectcollecties gedragen zich minder als tabellen en rijen, hoe meer abstractie er toe doet. SQLAlchemy streeft ernaar om aan beide principes tegemoet te komen.

SQLAlchemy beschouwt de database als een relationele algebra-engine, niet alleen als een verzameling tabellen. Rijen kunnen worden geselecteerd uit niet alleen tabellen, maar ook joins en andere select-instructies; elk van deze eenheden kan in een grotere structuur worden samengesteld. De uitdrukkingstaal van SQLAlchemy bouwt voort op dit concept vanuit de kern.

SQLAlchemy is het meest bekend om zijn object-relationele mapper (ORM), een optionele component die het datamap-patroon biedt, waarbij klassen op open manieren op verschillende manieren aan de database kunnen worden toegewezen - waardoor het objectmodel en het databaseschema zich kunnen ontwikkelen in een netjes losgekoppeld vanaf het begin.

De algemene benadering van SQLAlchemy voor deze problemen is geheel anders dan die van de meeste andere SQL / ORM-tools, geworteld in een zogenaamde op complementariteit gerichte benadering; in plaats van SQL te verbergen en relationele details achter een muur van automatisering te verbergen, worden alle processen volledig belicht binnen een reeks samengestelde, transparante tools. De bibliotheek neemt de taak op zich om redundante taken te automatiseren, terwijl de ontwikkelaar de controle behoudt over hoe de database is georganiseerd en hoe SQL is opgebouwd.

Het hoofddoel van SQLAlchemy is om de manier waarop u denkt over databases en SQL te veranderen!

versies

Versie Status vrijgeven Wijzig logboek Publicatiedatum
1.1 beta 1.1 2016/07/26
1.0 Huidige uitgave 1.0 2015/04/16
0.9 Onderhoud 0.9 2013/12/30
0.8 Veiligheid 0.8 2013/03/09

Hallo Wereld! (SQLAlchemy Core)

In dit voorbeeld wordt getoond hoe u een tabel maakt, gegevens invoegt en uit de database selecteert met behulp van SQLAlchemy Core. Voor informatie over: de SQLAlchemy ORM, zie hier .

Eerst moeten we verbinding maken met onze database.

from sqlalchemy import create_engine

engine = create_engine('sqlite://')
 

De motor is het startpunt voor elke SQLAlchemy-toepassing. Het is een 'thuisbasis' voor de eigenlijke database en de DBAPI, geleverd aan een SQLAlchemy-toepassing via een verbindingspool en een dialect, dat beschrijft hoe te praten met een specifiek soort combinatie database / DBAPI. De Engine verwijst naar zowel een dialect als een verbindingspool, die samen de DBAPI-modulefuncties en het gedrag van de database interpreteren.

Nadat we onze engine hebben gemaakt, moeten we onze tabellen definiëren en maken .

from sqlalchemy import Column, Integer, Text, MetaData, Table

metadata = MetaData()
messages = Table(
    'messages', metadata,
    Column('id', Integer, primary_key=True),
    Column('message', Text),
)

messages.create(bind=engine)
 

Om het MetaData-object nader toe te lichten, zie het onderstaande uit de documenten:

Een verzameling tabelobjecten en de bijbehorende onderliggende objecten worden database-metagegevens genoemd

We definiëren onze tabellen allemaal in een catalogus met de naam MetaData, met behulp van de tabelconstructie, die lijkt op reguliere SQL CREATE TABLE-instructies.

Nu we onze tabellen hebben gedefinieerd en gemaakt, kunnen we beginnen met het invoegen van gegevens! Invoegen bestaat uit twee stappen. Het invoegen van het construct en het uitvoeren van de laatste query.

insert_message = messages.insert().values(message='Hello, World!')
engine.execute(insert_message)
 

Nu we gegevens hebben, kunnen we de selectiefunctie gebruiken om onze gegevens op te vragen. Kolomobjecten zijn beschikbaar als benoemde attributen van het c-kenmerk op het tabelobject, waardoor het gemakkelijk is om kolommen direct te selecteren. Als u deze select-opdracht ResultProxy wordt een ResultProxy object ResultProxy dat toegang heeft tot enkele methoden, fetchone () , fetchall () en fetchmany () , die allemaal een aantal databaserijen retourneren die in onze select-opdracht zijn opgevraagd.

from sqlalchemy import select
stmt = select([messages.c.message]) 
message, = engine.execute(stmt).fetchone()
print(message)
 

Hello, World!
 

En dat is het! Zie de SQLAlchemy SQL Expressions-zelfstudie voor meer voorbeelden en informatie.

Hallo Wereld! (SQLAlchemy ORM)

Dit voorbeeld laat zien hoe u een tabel kunt maken, gegevens kunt invoegen en uit de database kunt selecteren met behulp van de SQLAlchemy ORM . Voor informatie over: SQLAlchemy Core, zie hier .

Allereerst moeten we verbinding maken met onze database, die identiek is aan hoe we verbinding zouden maken met behulp van SQLAlchemy Core (Core).

from sqlalchemy import create_engine

engine = create_engine('sqlite://')
 

Nadat we onze engine hebben aangesloten en gemaakt, moeten we onze tabellen definiëren en maken. Dit is waar de SQLAlchemy ORM-taal sterk begint te verschillen van Core. In ORM begint het proces voor het maken en definiëren van tabellen met het definiëren van de tabellen en de klassen die we gebruiken om aan die tabellen toe te wijzen. Dit proces gebeurt in één stap in ORM, die SQLAlchemy het Declarative- systeem noemt.

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
 

Nu onze basistoewijzer is gedeclareerd, kunnen we er een subklasse van maken om onze declaratieve toewijzingen of models .

from sqlalchemy import Column, Integer, String

class Message(Base):
    __tablename__ = 'messages'
    
    id = Column(Integer, primary_key=True)
    message = Column(String)
 

Met behulp van de declaratieve basisklasse maken we uiteindelijk een Table en Mapper object. Uit de documenten:

Het Table-object is lid van een grotere verzameling die bekend staat als MetaData. Bij gebruik van Declarative is dit object beschikbaar met het kenmerk .metadata van onze declarative base class.

Met dat in gedachten kunnen we, om alle tabellen te maken die nog niet bestaan, de onderstaande opdracht gebruiken, die het MetaData-register van SQLAlchemy Core gebruikt.

Base.metadata.create_all(engine)
 

Nu onze tabellen zijn toegewezen en gemaakt, kunnen we gegevens invoegen! Invoegen gebeurt door het creëren van mapper-instanties .

message = Message(message="Hello World!")
message.message # 'Hello World!
 

Op dit moment is alles wat we hebben een exemplaar van bericht op het niveau van het ORM-abstractieniveau, maar er is nog niets in de database opgeslagen. Om dit te doen, moeten we eerst een sessie maken .

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)
session = Session()
 

Dit sessieobject is onze databasehandler. Volgens de SQLAlchemy-documenten:

het haalt een verbinding op uit een pool van verbindingen onderhouden door de Engine en houdt deze vast totdat we alle wijzigingen doorvoeren en / of het sessieobject sluiten.

Nu we onze sessie, kunnen we voegen onze nieuwe boodschap aan de sessie en onze wijzigingen in de database te plegen.

session.add(message)
session.commit()
 

Nu we gegevens hebben, kunnen we profiteren van de ORM-zoektaal om onze gegevens op te halen.

query = session.query(Message)
instance = query.first()
print (instance.message) # Hello World!
 

Maar dat is nog maar het begin! Er zijn veel meer functies die kunnen worden gebruikt om zoekopdrachten samen te stellen, zoals filter , order_by en nog veel meer. Zie de SQLAlchemy ORM-zelfstudie voor meer voorbeelden en informatie.

Installatie of instellingen

pip install sqlalchemy
 

Voor de meest voorkomende applicaties, met name webapplicaties, wordt het meestal aanbevolen dat beginners overwegen een aanvullende bibliotheek te gebruiken, zoals flask-sqlalchemy .

pip install flask-sqlalchemy