Làm cách nào để lấy truy vấn SQL thô, đã biên dịch từ biểu thức SQLAlchemy?

Tôi có một đối tượng truy vấn SQLAlchemy và muốn lấy văn bản của câu lệnh SQL đã biên dịch, với tất cả các tham số của nó bị ràng buộc (ví dụ: không %shoặc các biến khác đang chờ bị ràng buộc bởi trình biên dịch câu lệnh hoặc công cụ phương ngữ MySQLdb, v.v.).

Gọi str()trên truy vấn cho thấy một cái gì đó như thế này:

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

Tôi đã thử tìm kiếm trong query._params nhưng đó là một câu lệnh trống. Tôi đã viết trình biên dịch của riêng mình bằng cách sử dụng ví dụ này về trình sqlalchemy.ext.compiler.compilestrang trí nhưng ngay cả câu lệnh ở đó vẫn có%s nơi tôi muốn dữ liệu.

Tôi hoàn toàn không thể tìm ra khi nào các tham số của tôi được trộn vào để tạo truy vấn; khi kiểm tra đối tượng truy vấn, chúng luôn là một từ điển trống (mặc dù truy vấn thực thi tốt và công cụ in ra khi bạn bật ghi nhật ký tiếng vọng).

Tôi bắt đầu nhận được thông báo rằng SQLAlchemy không muốn tôi biết truy vấn cơ bản, vì nó phá vỡ bản chất chung của giao diện API biểu thức tất cả các DB-API khác nhau. Tôi không phiền nếu truy vấn được thực thi trước khi tôi tìm ra nó là gì; Tôi chỉ muốn biết!

Blog này cung cấp một câu trả lời cập nhật.

Trích dẫn từ bài đăng trên blog, điều này được đề xuất và làm việc cho tôi.

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

Trong đó q được định nghĩa là:

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

Hoặc chỉ bất kỳ loại session.query () nào.

Cảm ơn Nicolas Cadou về câu trả lời! Tôi hy vọng nó sẽ giúp những người khác tìm kiếm ở đây.

Các tài liệu hướng dẫn sử dụng literal_bindsđể in một truy vấn qbao gồm các thông số:

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

cách tiếp cận ở trên có lưu ý rằng nó chỉ được hỗ trợ cho các kiểu cơ bản, chẳng hạn như int và chuỗi, và hơn nữa nếu một bindparam () không có giá trị đặt trước được sử dụng trực tiếp, nó cũng sẽ không thể chuỗi ký tự đó.

Tài liệu cũng đưa ra cảnh báo này:

Không bao giờ sử dụng kỹ thuật này với nội dung chuỗi nhận được từ đầu vào không đáng tin cậy, chẳng hạn như từ biểu mẫu web hoặc các ứng dụng do người dùng nhập khác. Các cơ sở của SQLAlchemy để ép buộc các giá trị Python thành các giá trị chuỗi SQL trực tiếp không an toàn trước đầu vào không đáng tin cậy và không xác thực kiểu dữ liệu được truyền. Luôn sử dụng các tham số ràng buộc khi gọi các câu lệnh SQL không phải DDL theo chương trình đối với cơ sở dữ liệu quan hệ.

Điều này sẽ hoạt động với 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)

Đối với phần phụ trợ MySQLdb, tôi đã sửa đổi câu trả lời tuyệt vời của albertov (cảm ơn rất nhiều!) Một chút. Tôi chắc chắn họ có thể được sáp nhập để kiểm tra xem comp.positionalđã Truenhưng đó là hơi vượt quá phạm vi của câu hỏi này.

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)

Điều đó là, sqlalchemy không bao giờ trộn dữ liệu với truy vấn của bạn. Truy vấn và dữ liệu được chuyển riêng đến trình điều khiển cơ sở dữ liệu bên dưới của bạn - việc nội suy dữ liệu xảy ra trong cơ sở dữ liệu của bạn.

Sqlalchemy chuyển truy vấn như bạn đã thấy trong str(myquery) cơ sở dữ liệu và các giá trị sẽ đi trong một bộ dữ liệu riêng biệt.

Bạn có thể sử dụng một số phương pháp mà bạn tự nội suy dữ liệu với truy vấn (như albertov đề xuất bên dưới), nhưng đó không phải là điều mà sqlalchemy đang thực thi.

Trước tiên, hãy để tôi mở đầu bằng cách nói rằng tôi cho rằng bạn đang làm điều này chủ yếu vì mục đích gỡ lỗi - tôi không khuyên bạn nên cố gắng sửa đổi câu lệnh bên ngoài API thông thạo SQLAlchemy.

Thật không may, dường như không có một cách đơn giản nào để hiển thị câu lệnh đã biên dịch với các tham số truy vấn được bao gồm. SQLAlchemy không thực sự đưa các tham số vào câu lệnh - chúng được chuyển vào cơ sở dữ liệu dưới dạng từ điển . Điều này cho phép thư viện dành riêng cho cơ sở dữ liệu xử lý những thứ như thoát các ký tự đặc biệt để tránh chèn SQL.

Nhưng bạn có thể thực hiện điều này theo quy trình hai bước một cách hợp lý dễ dàng. Để nhận được câu lệnh, bạn có thể làm như bạn đã hiển thị và chỉ cần in truy vấn:

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

Bạn có thể tiến gần hơn một bước với query.statement, để xem tên tham số. Lưu ý :id_1bên dưới so với %sbên trên - không thực sự là một vấn đề trong ví dụ rất đơn giản này, nhưng có thể là chìa khóa trong một câu lệnh phức tạp hơn.

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

Sau đó, bạn có thể nhận các giá trị thực của các tham số bằng cách lấy thuộc paramstính của câu lệnh đã biên dịch:

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

Điều này ít nhất đã hoạt động đối với phần phụ trợ MySQL; Tôi hy vọng nó cũng đủ chung cho PostgreSQL mà không cần sử dụng psycopg2.

Đối với phần phụ trợ postgresql sử dụng psycopg2, bạn có thể lắng nghe do_executesự kiện, sau đó sử dụng con trỏ, câu lệnh và nhập các tham số cưỡng chế cùng với Cursor.mogrify()nội tuyến các tham số. Bạn có thể trả về True để ngăn việc thực thi truy vấn thực tế.

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

Sử dụng mẫu:

>>> 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"}}'}

Giải pháp sau sử dụng Ngôn ngữ biểu thức SQLAlchemy và hoạt động với SQLAlchemy 1.1. Giải pháp này không trộn các tham số với truy vấn (theo yêu cầu của tác giả gốc), nhưng cung cấp cách sử dụng mô hình SQLAlchemy để tạo chuỗi truy vấn SQL và từ điển tham số cho các phương ngữ SQL khác nhau. Ví dụ dựa trên hướng dẫn http://docs.sqlalchemy.org/en/rel_1_0/core/tutorial.html

Cho lớp học,

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

chúng ta có thể tạo một câu lệnh truy vấn bằng cách sử dụng hàm select .

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

Tiếp theo, chúng ta có thể biên dịch câu lệnh thành một đối tượng truy vấn.

query = statement.compile()

Theo mặc định, câu lệnh được biên dịch bằng cách sử dụng triển khai 'được đặt tên' cơ bản tương thích với cơ sở dữ liệu SQL như SQLite và Oracle. Nếu bạn cần chỉ định một phương ngữ chẳng hạn như PostgreSQL, bạn có thể làm

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

Hoặc nếu bạn muốn chỉ định rõ ràng phương ngữ là SQLite, bạn có thể thay đổi kiểu tham số từ 'qmark' thành 'được đặt tên'.

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

Từ đối tượng truy vấn, chúng ta có thể trích xuất chuỗi truy vấn và các tham số truy vấn

query_str = str(query)
query_params = query.params

và cuối cùng thực hiện truy vấn.

conn.execute( query_str, query_params )

Bạn có thể sử dụng các sự kiện từ họ ConnectionEvents : after_cursor_executehoặc before_cursor_execute.

Trong sqlalchemy UsageRecipes của @zzzeek, ​​bạn có thể tìm thấy ví dụ sau:

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

Ở đây bạn có thể nhận được quyền truy cập vào tuyên bố

Vì vậy, khi tập hợp rất nhiều câu trả lời khác nhau, tôi đã nghĩ ra thứ tôi cần: một bộ mã đơn giản để truy cập và thỉnh thoảng nhưng đáng tin cậy (tức là xử lý tất cả các kiểu dữ liệu) lấy chính xác, đã biên dịch SQL được gửi đến Postgres backend bằng cách chỉ thẩm vấn chính truy vấn:

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

Tôi nghĩ .statement có thể sẽ thực hiện thủ thuật: 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