SQLAlchemy: imprime a consulta real

Eu realmente gostaria de poder imprimir SQL válido para o meu aplicativo, incluindo valores, em vez de parâmetros de ligação, mas não é óbvio como fazer isso no SQLAlchemy (por design, tenho certeza).

Alguém resolveu esse problema de uma maneira geral?

Na grande maioria dos casos, a "stringification" de uma instrução ou consulta SQLAlchemy é tão simples quanto:

print str(statement)

Isso se aplica tanto a um ORM Queryquanto a qualquer select()outra declaração.

Nota : a resposta detalhada a seguir está sendo mantida na documentação do sqlalchemy .

Para obter a instrução compilada em um dialeto ou mecanismo específico, se a própria declaração ainda não estiver vinculada a uma, você pode passar para compile () :

print statement.compile(someengine)

ou sem um motor:

from sqlalchemy.dialects import postgresql
print statement.compile(dialect=postgresql.dialect())

Quando é fornecido um Queryobjeto ORM , para obter o compile()método, precisamos acessar apenas o acessador .statement primeiro:

statement = query.statement
print statement.compile(someengine)

No que diz respeito à estipulação original de que os parâmetros vinculados devem ser "incorporados" na sequência final, o desafio aqui é que o SQLAlchemy normalmente não é encarregado disso, pois isso é tratado adequadamente pelo DBAPI do Python, sem mencionar que os parâmetros vinculados são ignorados. provavelmente as falhas de segurança mais amplamente exploradas em aplicativos da web modernos. O SQLAlchemy possui capacidade limitada para fazer essa stringificação em determinadas circunstâncias, como a de emitir DDL. Para acessar essa funcionalidade, pode-se usar o sinalizador 'literal_binds', passado para compile_kwargs:

from sqlalchemy.sql import table, column, select

t = table('t', column('x'))

s = select([t]).where(t.c.x == 5)

print s.compile(compile_kwargs={"literal_binds": True})

a abordagem acima tem as ressalvas de que ele é suportado apenas para tipos básicos, como ints e strings, e além disso, se um valor bindparam sem um valor pré-definido for usado diretamente, também não será possível especificá-lo.

Para oferecer suporte à renderização literal embutida para tipos não suportados, implemente a TypeDecoratorpara o tipo de destino que inclui um TypeDecorator.process_literal_parammétodo:

from sqlalchemy import TypeDecorator, Integer


class MyFancyType(TypeDecorator):
    impl = Integer

    def process_literal_param(self, value, dialect):
        return "my_fancy_formatting(%s)" % value

from sqlalchemy import Table, Column, MetaData

tab = Table('mytable', MetaData(), Column('x', MyFancyType()))

print(
    tab.select().where(tab.c.x > 5).compile(
        compile_kwargs={"literal_binds": True})
)

produzindo saída como:

SELECT mytable.x
FROM mytable
WHERE mytable.x > my_fancy_formatting(5)

Isso funciona em python 2 e 3 e é um pouco mais limpo do que antes, mas requer SA> = 1.0.

from sqlalchemy.engine.default import DefaultDialect
from sqlalchemy.sql.sqltypes import String, DateTime, NullType

# python2/3 compatible.
PY3 = str is not bytes
text = str if PY3 else unicode
int_type = int if PY3 else (int, long)
str_type = str if PY3 else (str, unicode)


class StringLiteral(String):
    """Teach SA how to literalize various things."""
    def literal_processor(self, dialect):
        super_processor = super(StringLiteral, self).literal_processor(dialect)

        def process(value):
            if isinstance(value, int_type):
                return text(value)
            if not isinstance(value, str_type):
                value = text(value)
            result = super_processor(value)
            if isinstance(result, bytes):
                result = result.decode(dialect.encoding)
            return result
        return process


class LiteralDialect(DefaultDialect):
    colspecs = {
        # prevent various encoding explosions
        String: StringLiteral,
        # teach SA about how to literalize a datetime
        DateTime: StringLiteral,
        # don't format py2 long integers to NULL
        NullType: StringLiteral,
    }


def literalquery(statement):
    """NOTE: This is entirely insecure. DO NOT execute the resulting strings."""
    import sqlalchemy.orm
    if isinstance(statement, sqlalchemy.orm.Query):
        statement = statement.statement
    return statement.compile(
        dialect=LiteralDialect(),
        compile_kwargs={'literal_binds': True},
    ).string

Demo:

# coding: UTF-8
from datetime import datetime
from decimal import Decimal

from literalquery import literalquery


def test():
    from sqlalchemy.sql import table, column, select

    mytable = table('mytable', column('mycol'))
    values = (
        5,
        u'snowman: ☃',
        b'UTF-8 snowman: \xe2\x98\x83',
        datetime.now(),
        Decimal('3.14159'),
        10 ** 20,  # a long integer
    )

    statement = select([mytable]).where(mytable.c.mycol.in_(values)).limit(1)
    print(literalquery(statement))


if __name__ == '__main__':
    test()

Dá esta saída: (testado em python 2.7 e 3.4)

SELECT mytable.mycol
FROM mytable
WHERE mytable.mycol IN (5, 'snowman: ☃', 'UTF-8 snowman: ☃',
      '2015-06-24 18:09:29.042517', 3.14159, 100000000000000000000)
 LIMIT 1

Dado que o que você deseja faz sentido apenas durante a depuração, você pode iniciar o SQLAlchemy com echo=True, para registrar todas as consultas SQL. Por exemplo:

engine = create_engine(
    "mysql://scott:tiger@hostname/dbname",
    encoding="latin1",
    echo=True,
)

Isso também pode ser modificado para apenas uma única solicitação:

echo=False- se True, o mecanismo registrará todas as instruções e uma repr()de suas listas de parâmetros no criador de logs de mecanismos, cujo padrão é sys.stdout. O echoatributo de Enginepode ser modificado a qualquer momento para ativar e desativar o log. Se definido como a sequência "debug", as linhas de resultado também serão impressas na saída padrão. Esse sinalizador controla o logger do Python; consulte Configurando o log para obter informações sobre como configurar o log diretamente.

Fonte: configuração do mecanismo SQLAlchemy

Se usado com o Flask, você pode simplesmente definir

app.config["SQLALCHEMY_ECHO"] = True

para obter o mesmo comportamento.

Podemos usar o método de compilação para esse fim. Dos documentos :

from sqlalchemy.sql import text
from sqlalchemy.dialects import postgresql

stmt = text("SELECT * FROM users WHERE users.name BETWEEN :x AND :y")
stmt = stmt.bindparams(x="m", y="z")

print(stmt.compile(dialect=postgresql.dialect(),compile_kwargs={"literal_binds": True}))

Resultado:

SELECT * FROM users WHERE users.name BETWEEN 'm' AND 'z'

Aviso dos documentos:

Nunca use essa técnica com conteúdo de sequência de caracteres recebido de entrada não confiável, como formulários da Web ou outros aplicativos de entrada do usuário. As instalações do SQLAlchemy para coagir valores Python em valores diretos de string SQL não são seguras contra entradas não confiáveis ​​e não validam o tipo de dados que estão sendo transmitidos. Sempre use parâmetros associados ao chamar programaticamente instruções SQL não DDL em um banco de dados relacional.

Então, com base nos comentários de @ zzzeek no código de @ bukzor, eu vim com isso para obter facilmente uma consulta "bastante imprimível":

def prettyprintable(statement, dialect=None, reindent=True):
    """Generate an SQL expression string with bound parameters rendered inline
    for the given SQLAlchemy statement. The function can also receive a
    `sqlalchemy.orm.Query` object instead of statement.
    can 

    WARNING: Should only be used for debugging. Inlining parameters is not
             safe when handling user created data.
    """
    import sqlparse
    import sqlalchemy.orm
    if isinstance(statement, sqlalchemy.orm.Query):
        if dialect is None:
            dialect = statement.session.get_bind().dialect
        statement = statement.statement
    compiled = statement.compile(dialect=dialect,
                                 compile_kwargs={'literal_binds': True})
    return sqlparse.format(str(compiled), reindent=reindent)

Pessoalmente, tenho dificuldade em ler o código que não é recuado, então eu costumava sqlparsereindentar o SQL. Pode ser instalado com pip install sqlparse.

Esse código é baseado na resposta brilhante existente de @bukzor. Acabei de adicionar renderização personalizada para o datetime.datetimetipo no Oracle TO_DATE().

Sinta-se livre para atualizar o código para se adequar ao seu banco de dados:

import decimal
import datetime

def printquery(statement, bind=None):
    """
    print a query, with values filled in
    for debugging purposes *only*
    for security, you should always separate queries from their values
    please also note that this function is quite slow
    """
    import sqlalchemy.orm
    if isinstance(statement, sqlalchemy.orm.Query):
        if bind is None:
            bind = statement.session.get_bind(
                    statement._mapper_zero_or_none()
            )
        statement = statement.statement
    elif bind is None:
        bind = statement.bind 

    dialect = bind.dialect
    compiler = statement._compiler(dialect)
    class LiteralCompiler(compiler.__class__):
        def visit_bindparam(
                self, bindparam, within_columns_clause=False, 
                literal_binds=False, **kwargs
        ):
            return super(LiteralCompiler, self).render_literal_bindparam(
                    bindparam, within_columns_clause=within_columns_clause,
                    literal_binds=literal_binds, **kwargs
            )
        def render_literal_value(self, value, type_):
            """Render the value of a bind parameter as a quoted literal.

            This is used for statement sections that do not accept bind paramters
            on the target driver/database.

            This should be implemented by subclasses using the quoting services
            of the DBAPI.

            """
            if isinstance(value, basestring):
                value = value.replace("'", "''")
                return "'%s'" % value
            elif value is None:
                return "NULL"
            elif isinstance(value, (float, int, long)):
                return repr(value)
            elif isinstance(value, decimal.Decimal):
                return str(value)
            elif isinstance(value, datetime.datetime):
                return "TO_DATE('%s','YYYY-MM-DD HH24:MI:SS')" % value.strftime("%Y-%m-%d %H:%M:%S")

            else:
                raise NotImplementedError(
                            "Don't know how to literal-quote value %r" % value)            

    compiler = LiteralCompiler(dialect, statement)
    print compiler.process(statement)

Gostaria de salientar que as soluções fornecidas acima não "apenas funcionam" com consultas não triviais. Um problema que encontrei foram tipos mais complicados, como ARRAYs do pgsql, causando problemas. Eu encontrei uma solução que, para mim, funcionou mesmo com ARRAYs do pgsql:

emprestado de: https://gist.github.com/gsakkis/4572159

O código vinculado parece basear-se em uma versão mais antiga do SQLAlchemy. Você receberá um erro dizendo que o atributo _mapper_zero_or_none não existe. Aqui está uma versão atualizada que funcionará com uma versão mais recente; você simplesmente substitui _mapper_zero_or_none por bind. Além disso, isso tem suporte para matrizes pgsql:

# adapted from:
# https://gist.github.com/gsakkis/4572159
from datetime import date, timedelta
from datetime import datetime

from sqlalchemy.orm import Query


try:
    basestring
except NameError:
    basestring = str


def render_query(statement, dialect=None):
    """
    Generate an SQL expression string with bound parameters rendered inline
    for the given SQLAlchemy statement.
    WARNING: This method of escaping is insecure, incomplete, and for debugging
    purposes only. Executing SQL statements with inline-rendered user values is
    extremely insecure.
    Based on http://stackoverflow.com/questions/5631078/sqlalchemy-print-the-actual-query
    """
    if isinstance(statement, Query):
        if dialect is None:
            dialect = statement.session.bind.dialect
        statement = statement.statement
    elif dialect is None:
        dialect = statement.bind.dialect

    class LiteralCompiler(dialect.statement_compiler):

        def visit_bindparam(self, bindparam, within_columns_clause=False,
                            literal_binds=False, **kwargs):
            return self.render_literal_value(bindparam.value, bindparam.type)

        def render_array_value(self, val, item_type):
            if isinstance(val, list):
                return "{%s}" % ",".join([self.render_array_value(x, item_type) for x in val])
            return self.render_literal_value(val, item_type)

        def render_literal_value(self, value, type_):
            if isinstance(value, long):
                return str(value)
            elif isinstance(value, (basestring, date, datetime, timedelta)):
                return "'%s'" % str(value).replace("'", "''")
            elif isinstance(value, list):
                return "'{%s}'" % (",".join([self.render_array_value(x, type_.item_type) for x in value]))
            return super(LiteralCompiler, self).render_literal_value(value, type_)

    return LiteralCompiler(dialect, statement).process(statement)

Testado para dois níveis de matrizes aninhadas.