Como executar SQL bruto no aplicativo Flask-SQLAlchemy

Como você executa SQL bruto no SQLAlchemy?

Eu tenho um aplicativo da web python que é executado no balão e faz interface com o banco de dados por meio do SQLAlchemy.

Eu preciso de uma maneira de executar o SQL bruto. A consulta envolve várias junções de tabela junto com exibições embutidas.

Eu tentei:

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

Mas continuo recebendo erros de gateway.

Você tentou:

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

ou:

from sqlalchemy import text

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

Os objetos de sessão do SQL Alchemy têm seu próprio executemétodo:

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

Todas as suas consultas de aplicativos devem passar por um objeto de sessão, sejam eles SQL brutos ou não. Isso garante que as consultas sejam gerenciadas adequadamente por uma transação , o que permite que várias consultas na mesma solicitação sejam confirmadas ou revertidas como uma única unidade. Sair da transação usando o mecanismo ou a conexão oferece um risco muito maior de sutis, possivelmente difíceis de detectar bugs que podem deixar dados corrompidos. Cada solicitação deve ser associada a apenas uma transação e usardb.session garantirá que este é o caso do seu aplicativo.

Observe também que executefoi projetado para consultas parametrizadas . Use parâmetros, como :valno exemplo, para quaisquer entradas na consulta para se proteger de ataques de injeção de SQL. Você pode fornecer o valor para esses parâmetros passando umdict como o segundo argumento, em que cada chave é o nome do parâmetro, conforme aparece na consulta. A sintaxe exata do próprio parâmetro pode ser diferente dependendo do seu banco de dados, mas todos os principais bancos de dados relacionais os suportam de alguma forma.

Supondo que é um SELECT consulta, isso retornará uma iterável deRowProxy objetos.

Você pode acessar colunas individuais com uma variedade de técnicas:

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

Pessoalmente, prefiro converter os resultados em namedtuple s:

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 você não estiver usando a extensão Flask-SQLAlchemy, ainda poderá usar facilmente uma sessão:

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: Tutorial da linguagem de expressão SQL - Usando texto

exemplo:

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

Você pode obter os resultados das consultas SELECT SQL usando from_statement()e text()como mostrado aqui . Você não precisa lidar com tuplas dessa maneira. Como exemplo de uma classe Usercom o nome da tabela, usersvocê pode tentar,

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

executa o, <sql here>mas não o confirma, a menos que você estejaautocommit modo. Portanto, inserções e atualizações não refletiriam no banco de dados.

Para confirmar após as alterações, faça

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

Esta é uma resposta simplificada de como executar a consulta SQL a partir do Flask Shell

Primeiro, mapeie seu módulo (se seu módulo / aplicativo estiver manage.py na pasta principal e você estiver em um sistema operacional UNIX), execute:

export FLASK_APP=manage

Executar shell do balão

flask shell

Importe o que precisamos:

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

Execute sua consulta:

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

Isso usa a conexão de banco de dados atualmente que possui o aplicativo.

Você já tentou usar connection.execute(text( <sql here> ), <bind params here> )e vincular parâmetros, conforme descrito nos documentos ? Isso pode ajudar a resolver muitos problemas de formatação e desempenho de parâmetros. Talvez o erro do gateway seja um tempo limite? Os parâmetros de ligação tendem a fazer consultas complexas serem executadas substancialmente mais rapidamente.

Se você deseja evitar tuplas, outra maneira é chamar os métodos first, oneou all:

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

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