Come eseguire SQL raw nell'app Flask-SQLAlchemy

Come si esegue SQL grezzo in SQLAlchemy?

Ho un'app Web Python che funziona su pallone e si interfaccia al database tramite SQLAlchemy.

Ho bisogno di un modo per eseguire l'SQL grezzo. La query coinvolge più join di tabella insieme a viste Inline.

Ho provato:

connection = db.session.connection()
connection.execute( <sql here> )

Ma continuo a ricevere errori del gateway.

Hai provato:

result = db.engine.execute("<sql here>")

o:

from sqlalchemy import text

sql = text('select name from penguins')
result = db.engine.execute(sql)
names = [row[0] for row in result]
print names

Gli oggetti sessione Alchemy SQL hanno il loro executemetodo:

result = db.session.execute('SELECT * FROM my_table WHERE my_column = :val', {'val': 5})

Tutte le query dell'applicazione dovrebbero passare attraverso un oggetto sessione, siano esse SQL grezzo o meno. Ciò garantisce che le query siano gestite correttamente da una transazione , il che consente di eseguire il commit o il rollback di più query nella stessa richiesta come una singola unità. Uscire dalla transazione utilizzando il motore o la connessione ti espone a un rischio molto maggiore di bug sottili, forse difficili da rilevare, che possono lasciarti con dati danneggiati. Ogni richiesta deve essere associata a una sola transazione e utilizzodb.session garantirà che ciò per l'applicazione.

Si noti inoltre che executeè progettato per query con parametri . Usa parametri, come:val nell'esempio, per qualsiasi input alla query per proteggersi dagli attacchi SQL injection. È possibile fornire il valore per questi parametri passando adict come secondo argomento, dove ogni chiave è il nome del parametro come appare nella query. L'esatta sintassi del parametro stesso può variare a seconda del database, ma tutti i principali database relazionali li supportano in qualche modo.

Supponendo che sia una SELECTquery, questo restituirà un iterabile diRowProxy oggetti.

Puoi accedere alle singole colonne con una varietà di tecniche:

for r in result:
    print(r[0]) # Access by positional index
    print(r['my_column']) # Access by column name as a string
    r_dict = dict(r.items()) # convert to dict keyed by column names

Personalmente, preferisco convertire i risultati in namedtuples:

from collections import namedtuple

Record = namedtuple('Record', result.keys())
records = [Record(*r) for r in result.fetchall()]
for r in records:
    print(r.my_column)
    print(r)

Se non si utilizza l'estensione Flask-SQLAlchemy, è comunque possibile utilizzare facilmente una sessione:

import sqlalchemy
from sqlalchemy.orm import sessionmaker, scoped_session

engine = sqlalchemy.create_engine('my connection string')
Session = scoped_session(sessionmaker(bind=engine))

s = Session()
result = s.execute('SELECT * FROM my_table WHERE my_column = :val', {'val': 5})

docs: Esercitazione sul linguaggio delle espressioni SQL - Utilizzo del testo

esempio:

from sqlalchemy.sql import text

connection = engine.connect()

# recommended
cmd = 'select * from Employees where EmployeeGroup = :group'
employeeGroup = 'Staff'
employees = connection.execute(text(cmd), group = employeeGroup)

# or - wee more difficult to interpret the command
employeeGroup = 'Staff'
employees = connection.execute(
                  text('select * from Employees where EmployeeGroup = :group'), 
                  group = employeeGroup)

# or - notice the requirement to quote 'Staff'
employees = connection.execute(
                  text("select * from Employees where EmployeeGroup = 'Staff'"))


for employee in employees: logger.debug(employee)
# output
(0, 'Tim', 'Gurra', 'Staff', '991-509-9284')
(1, 'Jim', 'Carey', 'Staff', '832-252-1910')
(2, 'Lee', 'Asher', 'Staff', '897-747-1564')
(3, 'Ben', 'Hayes', 'Staff', '584-255-2631')

È possibile ottenere i risultati delle query SELECT SQL utilizzando from_statement()e text()come mostrato qui . Non devi affrontare le tuple in questo modo. Ad esempio per una classe Usercon il nome della tabella usersche puoi provare,

from sqlalchemy.sql import text
.
.
.
user = session.query(User).from_statement(
    text("SELECT * FROM users where name=:name")).\
    params(name='ed').all()

return user

result = db.engine.execute(text("<sql here>"))

esegue il <sql here>ma non lo commette a meno che tu non sia attivoautocommit modalità. Pertanto, inserimenti e aggiornamenti non si rifletterebbero nel database.

Per eseguire il commit dopo le modifiche, fare

result = db.engine.execute(text("<sql here>").execution_options(autocommit=True))

Questa è una risposta semplificata su come eseguire query SQL da Flask Shell

Innanzitutto, mappare il modulo (se il modulo / app è manage.py nella cartella principale e ci si trova in un sistema operativo UNIX), eseguire:

export FLASK_APP=manage

Esegui la shell Flask

flask shell

Importa ciò di cui abbiamo bisogno ::

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy(app)
from sqlalchemy import text

Esegui la tua query:

result = db.engine.execute(text("<sql here>").execution_options(autocommit=True))

Questo utilizza la connessione al database attualmente che ha l'applicazione.

Hai provato a utilizzare connection.execute(text( <sql here> ), <bind params here> )e associare i parametri come descritto nei documenti ? Questo può aiutare a risolvere molti problemi di formattazione e prestazioni dei parametri. Forse l'errore del gateway è un timeout? I parametri di bind tendono a rendere le query complesse eseguite in modo sostanzialmente più veloce.

Se si vuole evitare di tuple, un altro modo è chiamando i first, oneo allmetodi:

query = db.engine.execute("SELECT * FROM blogs "
                           "WHERE id = 1 ")

assert query.first().name == "Welcome to my blog"