SQLAlchemy式から生のコンパイル済みSQLクエリを取得するにはどうすればよいですか？

SQLAlchemyクエリオブジェクトがあり、すべてのパラメーターがバインドされた（たとえば%s、ステートメントコンパイラーまたはMySQLdbダイアレクトエンジンによってバインドされるのを待っている変数がないなど）、コンパイルされたSQLステートメントのテキストを取得します。

str()クエリを呼び出すと、次のようなことがわかります。

SELECT id WHERE date_added <= %s AND date_added >= %s ORDER BY count DESC

query._paramsを調べてみましたが、空の辞書です。私はこのsqlalchemy.ext.compiler.compilesデコレータの例を使用して独自のコンパイラを作成しましたが、そこにあるステートメントでさえ、%sデータが必要な場所にまだあります。

クエリを作成するためにパラメーターが混在するタイミングがよくわかりません。クエリオブジェクトを調べるとき、それらは常に空のディクショナリです（ただし、クエリは正常に実行され、エコーロギングをオンにするとエンジンが出力します）。

SQLAlchemyは、基になるクエリを知りたくないというメッセージを受け取り始めています。これは、さまざまなDB-APIのすべての式APIのインターフェイスの一般的な性質を破壊するためです。クエリが何であるかがわかる前にクエリが実行されてもかまいません。ただ知りたいだけです！

このブログは更新された回答を提供します。

ブログの投稿から引用すると、これは推奨され、私にとってはうまくいきました。

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

ここで、qは次のように定義されます。

>>> q = DBSession.query(model.Name).distinct(model.Name.value) \
             .order_by(model.Name.value)

または、あらゆる種類のsession.query（）。

答えをくれたNicolas Cadouに感謝します。ここで検索を行う人に役立つことを願っています。

ドキュメントが使用するliteral_bindsクエリ印刷するqパラメータを含むを：

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

上記のアプローチには、intやstringなどの基本的なタイプでのみサポートされているという警告があります。さらに、事前設定された値のないbindparam（）を直接使用すると、そのいずれかを文字列化できません。

ドキュメントもこの警告を発行します：

Webフォームや他のユーザー入力アプリケーションなど、信頼できない入力から受け取った文字列コンテンツでは、この手法を使用しないでください。Python値を直接SQL文字列値に強制変換するSQLAlchemyの機能は、信頼できない入力に対して安全ではなく、渡されるデータのタイプを検証しません。リレーショナルデータベースに対して非DDL SQLステートメントをプログラムで呼び出す場合は、常にバインドされたパラメーターを使用します。

これはSqlalchemy> = 0.6で動作するはずです

from sqlalchemy.sql import compiler

from psycopg2.extensions import adapt as sqlescape
# or use the appropiate escape function from your db driver

def compile_query(query):
    dialect = query.session.bind.dialect
    statement = query.statement
    comp = compiler.SQLCompiler(dialect, statement)
    comp.compile()
    enc = dialect.encoding
    params = {}
    for k,v in comp.params.iteritems():
        if isinstance(v, unicode):
            v = v.encode(enc)
        params[k] = sqlescape(v)
    return (comp.string.encode(enc) % params).decode(enc)

MySQLdbバックエンドの場合、albertovの素晴らしい答えを少し修正しました（ありがとうございました！）。私はそれらがマージされたかどうかをチェックするためにマージできると確信していますcomp.positionalがTrue、それはこの質問の範囲を少し超えています。

def compile_query(query):
    from sqlalchemy.sql import compiler
    from MySQLdb.converters import conversions, escape

    dialect = query.session.bind.dialect
    statement = query.statement
    comp = compiler.SQLCompiler(dialect, statement)
    comp.compile()
    enc = dialect.encoding
    params = []
    for k in comp.positiontup:
        v = comp.params[k]
        if isinstance(v, unicode):
            v = v.encode(enc)
        params.append( escape(v, conversions) )
    return (comp.string.encode(enc) % tuple(params)).decode(enc)

ことは、sqlalchemyがデータとクエリを決して混合しないことです。クエリとデータは、基になるデータベースドライバーに個別に渡されます。データの補間はデータベースで行われます。

Sqlalchemyは、これまで見てきたようにクエリをstr(myquery)データベースに渡し、値は別のタプルに入れられます。

（albertovが以下に提案するように）クエリを使用してデータを補間するいくつかのアプローチを使用できますが、それはsqlalchemyが実行しているものとは異なります。

psycopg2を使用するpostgresqlバックエンドのdo_execute場合、イベントをリッスンしてから、カーソル、ステートメント、および型強制パラメーターを使用しCursor.mogrify()て、パラメーターをインライン化できます。Trueを返して、クエリが実際に実行されないようにすることができます。

import sqlalchemy

class QueryDebugger(object):
    def __init__(self, engine, query):
        with engine.connect() as connection:
            try:
                sqlalchemy.event.listen(engine, "do_execute", self.receive_do_execute)
                connection.execute(query)
            finally:
                sqlalchemy.event.remove(engine, "do_execute", self.receive_do_execute)

    def receive_do_execute(self, cursor, statement, parameters, context):
        self.statement = statement
        self.parameters = parameters
        self.query = cursor.mogrify(statement, parameters)
        # Don't actually execute
        return True

使用例：

>>> engine = sqlalchemy.create_engine("postgresql://postgres@localhost/test")
>>> metadata = sqlalchemy.MetaData()
>>> users = sqlalchemy.Table('users', metadata, sqlalchemy.Column("_id", sqlalchemy.String, primary_key=True), sqlalchemy.Column("document", sqlalchemy.dialects.postgresql.JSONB))
>>> s = sqlalchemy.select([users.c.document.label("foobar")]).where(users.c.document.contains({"profile": {"iid": "something"}}))
>>> q = QueryDebugger(engine, s)
>>> q.query
'SELECT users.document AS foobar \nFROM users \nWHERE users.document @> \'{"profile": {"iid": "something"}}\''
>>> q.statement
'SELECT users.document AS foobar \nFROM users \nWHERE users.document @> %(document_1)s'
>>> q.parameters
{'document_1': '{"profile": {"iid": "something"}}'}

まず、主にデバッグの目的でこれを行っていると仮定します。SQLAlchemyFluent APIの外部でステートメントを変更することはお勧めしません。

残念ながら、クエリパラメータを含めてコンパイルされたステートメントを表示する簡単な方法はないようです。SQLAlchemyは、実際にはパラメーターをステートメントに入れません。パラメーターは、辞書としてデータベースエンジンに渡されます。これにより、データベース固有のライブラリが特殊文字のエスケープなどを処理して、SQLインジェクションを回避できます。

しかし、これは2ステップのプロセスでかなり簡単に行うことができます。ステートメントを取得するには、すでに示したようにしてクエリを印刷します。

>>> print(query)
SELECT field_1, field_2 FROM table WHERE id=%s;

query.statementを使用すると、パラメータ名を確認できます。（:id_1下と%s上の注意-この非常に単純な例では実際には問題ではありませんが、より複雑なステートメントでは重要になる可能性があります。）

>>> print(query.statement)
>>> print(query.statement.compile()) # reasonably equivalent, you can also
                                     # pass in a dialect if you want
SELECT field_1, field_2 FROM table WHERE id=:id_1;

次に、paramsコンパイルされたステートメントのプロパティを取得することにより、パラメーターの実際の値を取得できます。

>>> print(query.statement.compile().params)
{u'id_1': 1} 

これは、少なくともMySQLバックエンドでは機能しました。また、PostgreSQLを使用する必要がなく、十分に一般的であると思いますpsycopg2。

次のソリューションはSQLAlchemy式言語を使用し、SQLAlchemy 1.1で動作します。このソリューションでは、パラメーターを（元の作成者の要求どおりに）クエリと混合しませんが、SQLAlchemyモデルを使用して、さまざまなSQL方言のSQLクエリ文字列とパラメーターディクショナリを生成する方法を提供します。この例は、チュートリアルhttp://docs.sqlalchemy.org/en/rel_1_0/core/tutorial.htmlに基づいています。

クラスを考えると、

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class foo(Base):
    __tablename__ = 'foo'
    id = Column(Integer(), primary_key=True)
    name = Column(String(80), unique=True)
    value = Column(Integer())

select関数を使用してクエリステートメントを作成できます。

from sqlalchemy.sql import select    
statement = select([foo.name, foo.value]).where(foo.value > 0)

次に、ステートメントをクエリオブジェクトにコンパイルできます。

query = statement.compile()

デフォルトでは、ステートメントはSQLiteやOracleなどのSQLデータベースと互換性のある基本的な「名前付き」実装を使用してコンパイルされます。PostgreSQLなどの方言を指定する必要がある場合は、

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

または、方言をSQLiteとして明示的に指定する場合は、paramstyleを「qmark」から「named」に変更できます。

from sqlalchemy.dialects import sqlite
query = statement.compile(dialect=sqlite.dialect(paramstyle="named"))

クエリオブジェクトから、クエリ文字列とクエリパラメータを抽出できます。

query_str = str(query)
query_params = query.params

最後にクエリを実行します。

conn.execute( query_str, query_params )

ConnectionEventsファミリーのイベントを使用できます。after_cursor_executeまたはbefore_cursor_execute。

@zzzeekによるsqlalchemy UsageRecipesには、次の例があります。

Profiling

...
@event.listens_for(Engine, "before_cursor_execute")
def before_cursor_execute(conn, cursor, statement,
                        parameters, context, executemany):
    conn.info.setdefault('query_start_time', []).append(time.time())
    logger.debug("Start Query: %s" % statement % parameters)
...

ここでステートメントにアクセスできます

だから、これらのさまざまな答えを少しまとめて、私は必要なものを思いつきました：ドロップインして、時々しかし確実に（つまり、すべてのデータ型を処理する）単純なコードのセットが、送信された正確なコンパイル済みSQLを取得しますクエリ自体を調べるだけでPostgresバックエンド：

from sqlalchemy.dialects import postgresql

query = [ .... some ORM query .... ]

compiled_query = query.statement.compile(
    dialect=postgresql.dialect()
)
mogrified_query = session.connection().connection.cursor().mogrify(
    str(compiled_query),
    compiled_query.params
)

print("compiled SQL = {s}".format(mogrified_query.decode())

私は.statementがおそらくトリックを実行すると思います：http : //docs.sqlalchemy.org/en/latest/orm/query.html ?highlight=query

>>> local_session.query(sqlalchemy_declarative.SomeTable.text).statement
<sqlalchemy.sql.annotation.AnnotatedSelect at 0x6c75a20; AnnotatedSelectobject>
>>> x=local_session.query(sqlalchemy_declarative.SomeTable.text).statement
>>> print(x)
SELECT sometable.text 
FROM sometable