Home » Beitrag verschlagwortet mit 'DB' (Seite 2)
Schlagwort-Archive: DB
Erste Flask Python Webapp mit DB zugriff über sqlAlchemy
Referenzen
Overall Example
Python HTTP-Server (Flask) Applikation, die vom Browser aufgerufen mit ‚Hello <name>‘ antwortet, wobei der Name von der Personen-Tabelle der DB gelesen wird.
Flask wird dabei benutzt um den HTTP Server zur Verfügung zu stellen und darin die Web-App auf definierter URL anzubieten.
SQLAlchemy (in der Flask-Version) bietet die APIs um DB Entitäten als Klassen (z.B. ‚Person‘) formulieren zu können diese als Objekte auf die relationale DB zu mappen (ORM provider).
flask-postgres-sql-hello-app.p
y:
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__) #Create a flask app with the name of this runnable python file (stored in the env var __name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://myDB:pw@localhost:5432/testDB'
db = SQLAlchemy(app)
class Person(db.Model):
__tablename__ = 'persons'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
#create all defined entities:
db.create_all()
#Insert an object to the DB:
person1 = Person(name = 'Marc')
db.session.add(person1)
db.session.commit()
person = Person.query.first()
#Handle web request on the web root:
@app.route('/')
def index():
return 'Hello ' + person.name
# Wird dieser Code auskommentiert, dann kann diese HTTP-Server-App
# durch 'python dieses-file-py' gestartet werden.
#if __name__ == '__main__':
# app.run()
Define an Entity
class Person(db.Model):
__tablename__ = 'persons'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), unique=False, nullable=False)
ahv = db.Column(db.String(), unique=True, nullable=False)
How to run a Flask HTTP Server
Das obige HTTP-Server-Script flask-postgres-sql-hello-app.p
y wird gestartet mit:
> flask run
nachdem die Umgebungsvariablen FLASK_APP=pfad/flask-postgres-sql-hello-app.py
gesetzt ist (Windows).
In Linux wird anscheinend so aufgerufen: >FLASK_APP=pfad/flask-postgres-sql-hello-app.py flask run
Debug-Mode: (Autorerun des HTTP-Server-Scripts)
Env. Variable setzen: FLASK_DEBUG=true
Remark flask --reload
probably does the same as set FLASK_DEBUG=TRUE
: Reloads the app as soon as code has changed.
Alternative Start-Methode:
Sieh code auch oben:
# Wird dieser Code auskommentiert, dann kann diese HTTP-Server-App
# durch 'python dieses-file-py' gestartet werden.
#if __name__ == '__main__':
# app.run()
Soll die Server-App von aussen Aufrufbar sein:
>flask run --host=0.0.0.0
oder
if __name__ == '__main__':
app.run(host="0.0.0.0")
Use Python Interactive Console to Import script and query script defined Entities
C:\tmp\Python_Workspace1\src>python
>>> from flask_postgres_sql_hello_app import db,Person
>>> Person.query.all()
[<Person ID: 5, name: Marc>
, <Person ID: 9, name: Marc>
, <Person ID: 10, name: Marc>
Funktioniert nur mit PY-Files deren Namen nach Konvention ist (kein ‚-‚).
Object Lifecycle in SQLAlchemy
The Lifecycle is: –object instantiated–> transient— query add executed–> pending –qery select/filter OR commit exec–> flushed –commit ex.–> committed
Flushed heisst: Im internen (in Memory) ORM-Object-Model-Cache sind die Änderungen bereits geschrieben.
!! ORM Selects (z.B. Person.query.all()
) erhält bereits alle Objekte, die oberhalb im Code mit session.query.add(person)
hinzugefügt/verändert/gelöscht wurden. –> ORM select-artige Queries löschen Flush aus!
Der SQL Select (direkt auf der DB) zeigt diese aber erst nach einem Commit!
Criteria API: Join mit Filter auf beiden joined Tables
Der Knackpunkt is dieser:
Mit
Root<TabelleA> root = query.from(TabelleA.class)
wird die Ausgangstabelle (root) bezeichnet.
Mit
Join<TabelleA, TablleB> join = root.join(TabelleA.bRef);
wir TabelleB hinzu ge-joined.
Wichig Referenzen (z.B. der Filter auf das Feld feldXY) müssen nun von join aus gehen:
join.get(TablleB.feldXY)
Oder die ganze Where-Clause:
.where(criteriaBuilder.equal(root.get(TabelleA.id), "id000001"), criteriaBuilder.like( join.get(TablleB.feldXY), "%gesuchterInhalt%"))
Ganze Beispiel
CriteriaBuilder criteriaBuilder = ippDaoProvider.getEntityManager().getCriteriaBuilder(); CriteriaQuery<TabelleA> query = criteriaBuilder.createQuery(TabelleA.class); Root<TabelleA> root = query.from(TabelleA.class); Join<TabelleA, TablleB> join = root.join(TabelleA.bRef); query.select(root).where(criteriaBuilder.equal(root.get(TabelleA.id), "id000001"), criteriaBuilder.like( join.get(TablleB.feldXY), "%gesuchterInhalt%")); List<TabelleA> aList = daoProvider.getTableADao().find(query);
Criteria API: Select where in / In list where clause
CriteriaBuilder cb = daoProvider.getEntityManager().getCriteriaBuilder(); CriteriaQuery<Employee2> criteriaQuery = cb.createQuery(Employee2.class); Root<Employee2> employee2Root = criteriaQuery.from(Employee2.class); criteriaQuery.select(employee2Root).where(employee2Root.get(Employee2._ATTR_gpn).in(gpns)); TypedQuery<Employee2> query = daoProvider.getEntityManager().createQuery(criteriaQuery); List<Employee2> employees = query.getResultList();