SQLAlchemy: affiche la requête réelle

J'aimerais vraiment pouvoir imprimer du SQL valide pour mon application, y compris des valeurs, plutôt que des paramètres de liaison, mais ce n'est pas évident de le faire dans SQLAlchemy (de par sa conception, j'en suis assez sûr).

Quelqu'un at-il résolu ce problème de manière générale?

Dans la grande majorité des cas, la "stringification" d'une instruction ou d'une requête SQLAlchemy est aussi simple que:

print str(statement)

Cela s'applique à la fois à un ORM Queryet à toute select()instruction ou autre.

Remarque : la réponse détaillée suivante est maintenue dans la documentation de sqlalchemy .

Pour obtenir l'instruction compilée dans un dialecte ou un moteur spécifique, si l'instruction elle-même n'est pas déjà liée à un, vous pouvez la transmettre à compile () :

print statement.compile(someengine)

ou sans moteur:

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

Lorsqu'on lui donne un Queryobjet ORM , pour accéder à la compile()méthode, il suffit d'accéder d' abord à l' accesseur .statement :

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

en ce qui concerne la stipulation d'origine selon laquelle les paramètres liés doivent être "intégrés" dans la chaîne finale, le défi ici est que SQLAlchemy n'est normalement pas chargé de cela, car cela est géré de manière appropriée par le Python DBAPI, sans parler du contournement des paramètres liés. probablement les failles de sécurité les plus largement exploitées dans les applications Web modernes. SQLAlchemy a une capacité limitée à effectuer cette stringification dans certaines circonstances telles que l'émission de DDL. Pour accéder à cette fonctionnalité, on peut utiliser le drapeau 'literal_binds', passé à 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})

l'approche ci-dessus a la mise en garde qu'elle n'est prise en charge que pour les types de base, tels que les ints et les chaînes, et de plus si un bindparam sans valeur prédéfinie est utilisé directement, il ne pourra pas non plus le stringify.

Pour prendre en charge le rendu littéral en ligne pour les types non pris en charge, implémentez un TypeDecoratorpour le type cible qui inclut une TypeDecorator.process_literal_paramméthode:

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

produisant une sortie comme:

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

Cela fonctionne en python 2 et 3 et est un peu plus propre qu'avant, mais nécessite 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

Démo:

# 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()

Donne cette sortie: (testé en python 2.7 et 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

Étant donné que ce que vous voulez n'a de sens que lors du débogage, vous pouvez démarrer SQLAlchemy avec echo=True, pour enregistrer toutes les requêtes SQL. Par exemple:

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

Cela peut également être modifié pour une seule demande:

echo=False- si True, le moteur enregistre toutes les instructions ainsi qu'une repr()de leurs listes de paramètres dans le journal des moteurs, qui est par défaut sys.stdout. L' echoattribut de Enginepeut être modifié à tout moment pour activer et désactiver la connexion. Si défini sur la chaîne "debug", les lignes de résultat seront également imprimées sur la sortie standard. Cet indicateur contrôle finalement un enregistreur Python; voir Configuration de la journalisation pour plus d'informations sur la configuration directe de la journalisation.

Source: Configuration du moteur SQLAlchemy

S'il est utilisé avec Flask, vous pouvez simplement définir

app.config["SQLALCHEMY_ECHO"] = True

pour obtenir le même comportement.

Nous pouvons utiliser la méthode de compilation à cet effet. À partir de la documentation :

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

Résultat:

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

Avertissement de la documentation:

N'utilisez jamais cette technique avec un contenu de chaîne reçu à partir d'une entrée non approuvée, telle que des formulaires Web ou d'autres applications d'entrée utilisateur. Les fonctionnalités de SQLAlchemy pour contraindre les valeurs Python en valeurs de chaîne SQL directes ne sont pas protégées contre les entrées non approuvées et ne valident pas le type de données transmises. Utilisez toujours des paramètres liés lors de l'appel par programme d'instructions SQL non DDL sur une base de données relationnelle.

Donc, en me basant sur les commentaires de @ zzzeek sur le code de @ bukzor, j'ai trouvé ceci pour obtenir facilement une requête "assez imprimable":

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)

sqlparsePersonnellement, j'ai du mal à lire du code qui n'est pas indenté, j'ai donc l'habitude de réindenter le SQL. Il peut être installé avec pip install sqlparse.

Ce code est basé sur la brillante réponse existante de @bukzor. Je viens d'ajouter un rendu personnalisé pour le datetime.datetimetype dans Oracle TO_DATE().

N'hésitez pas à mettre à jour le code en fonction de votre base de données:

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)

Je tiens à souligner que les solutions données ci-dessus ne "fonctionnent pas seulement" avec des requêtes non triviales. Un problème que j'ai rencontré était des types plus compliqués, tels que les ARRAY pgsql causant des problèmes. J'ai trouvé une solution qui, pour moi, fonctionnait même avec les ARRAY pgsql:

emprunté à: https://gist.github.com/gsakkis/4572159

Le code lié semble être basé sur une ancienne version de SQLAlchemy. Vous obtiendrez une erreur indiquant que l'attribut _mapper_zero_or_none n'existe pas. Voici une version mise à jour qui fonctionnera avec une version plus récente, il vous suffit de remplacer _mapper_zero_or_none par bind. De plus, cela prend en charge les tableaux 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)

Testé à deux niveaux de tableaux imbriqués.