Question

我试图在单个查询中获取一组固定的行，以及子查询找到的其他一些行。我的问题是我的SQLAlchemy代码生成的查询不正确。

问题是SQLAlchemy生成的查询如下：

SELECT tbl.id AS tbl_id
FROM tbl
WHERE tbl.id IN
(
SELECT t2.id AS t2_id
FROM tbl AS t2, tbl AS t1
WHERE t2.id =
(
SELECT t3.id AS t3_id
FROM tbl AS t3, tbl AS t1
WHERE t3.id < t1.id ORDER BY t3.id DESC LIMIT 1 OFFSET 0
)
AND t1.id IN (4, 8)
)
OR tbl.id IN (0, 8)

虽然正确的查询不应该有第二个tbl AS t1（此查询的目标是选择ID 0和8，以及4和8之前的ID）。

不幸的是，我无法找到如何让SQLAlchemy生成正确的（请参阅下面的代码）。

也欢迎使用更简单的查询获得相同结果的建议（虽然它们需要高效 - 我尝试了一些变体，有些变量在我的实际用例上慢得多）。

产生查询的代码：

from sqlalchemy import create_engine, or_
from sqlalchemy import Column, Integer, MetaData, Table
from sqlalchemy.orm import sessionmaker

engine = create_engine('sqlite:///:memory:', echo=True)
meta = MetaData(bind=engine)
table = Table('tbl', meta, Column('id', Integer))
session = sessionmaker(bind=engine)()
meta.create_all()

# Insert IDs 0, 2, 4, 6, 8.
i = table.insert()
i.execute(*[dict(id=i) for i in range(0, 10, 2)])
print session.query(table).all()
# output: [(0,), (2,), (4,), (6,), (8,)]

# Subquery of interest: look for the row just before IDs 4 and 8.
sub_query_txt = (
        'SELECT t2.id '
        'FROM tbl t1, tbl t2 '
        'WHERE t2.id = ( '
        ' SELECT t3.id from tbl t3 '
        ' WHERE t3.id < t1.id '
        ' ORDER BY t3.id DESC '
        ' LIMIT 1) '
        'AND t1.id IN (4, 8)')
print session.execute(sub_query_txt).fetchall()
# output: [(2,), (6,)]

# Full query of interest: get the rows mentioned above, as well as more rows.
query_txt = (
        'SELECT * '
        'FROM tbl '
        'WHERE ( '
        ' id IN (%s) '
        'OR id IN (0, 8))'
        ) % sub_query_txt
print session.execute(query_txt).fetchall()
# output: [(0,), (2,), (6,), (8,)]

# Attempt at an SQLAlchemy translation (from innermost sub-query to full query).
t1 = table.alias('t1')
t2 = table.alias('t2')
t3 = table.alias('t3')
q1 = session.query(t3.c.id).filter(t3.c.id < t1.c.id).order_by(t3.c.id.desc()).\
             limit(1)
q2 = session.query(t2.c.id).filter(t2.c.id == q1, t1.c.id.in_([4, 8]))
q3 = session.query(table).filter(
                               or_(table.c.id.in_(q2), table.c.id.in_([0, 8])))
print list(q3)
# output: [(0,), (6,), (8,)]

Answer 1

您缺少的是最里面的子查询与下一级别查询之间的关联;没有相关性，SQLAlchemy将在最里面的子查询中包含t1别名：

>>> print str(q1)
SELECT t3.id AS t3_id 
FROM tbl AS t3, tbl AS t1 
WHERE t3.id < t1.id ORDER BY t3.id DESC
 LIMIT ? OFFSET ?
>>> print str(q1.correlate(t1))
SELECT t3.id AS t3_id 
FROM tbl AS t3 
WHERE t3.id < t1.id ORDER BY t3.id DESC
 LIMIT ? OFFSET ?

请注意，查询中现在缺少tbl AS t1。来自.correlate() method documentation：

返回一个Query构造，它将给定的FROM子句与封闭的Query或select（）的子句相关联。

因此，t1被假定为封闭查询的一部分，并且未在查询本身中列出。

现在您的查询有效：

>>> q1 = session.query(t3.c.id).filter(t3.c.id < t1.c.id).order_by(t3.c.id.desc()).\
...              limit(1).correlate(t1)
>>> q2 = session.query(t2.c.id).filter(t2.c.id == q1, t1.c.id.in_([4, 8]))
>>> q3 = session.query(table).filter(
...                                or_(table.c.id.in_(q2), table.c.id.in_([0, 8])))
>>> print list(q3)
2012-10-24 22:16:22,239 INFO sqlalchemy.engine.base.Engine SELECT tbl.id AS tbl_id 
FROM tbl 
WHERE tbl.id IN (SELECT t2.id AS t2_id 
FROM tbl AS t2, tbl AS t1 
WHERE t2.id = (SELECT t3.id AS t3_id 
FROM tbl AS t3 
WHERE t3.id < t1.id ORDER BY t3.id DESC
 LIMIT ? OFFSET ?) AND t1.id IN (?, ?)) OR tbl.id IN (?, ?)
2012-10-24 22:16:22,239 INFO sqlalchemy.engine.base.Engine (1, 0, 4, 8, 0, 8)
[(0,), (2,), (6,), (8,)]

Answer 2

我只是确定我理解你要求的查询。让我们分解一下：

此查询的目标是选择ID 0和8，以及4和8之前的ID。

看起来你想要查询两种东西，然后将它们组合起来。适当的运算符是union。做简单的查询并在最后添加它们。我将从第二位开始，“在X之前的ids”。

首先;让我们看一下给定值之前的所有id。为此，我们将使用<：

加入表格

# select t1.id t1_id, t2.id t2_id from tbl t1 join tbl t2 on t1.id < t2.id;
 t1_id | t2_id 
-------+-------
     0 |     2
     0 |     4
     0 |     6
     0 |     8
     2 |     4
     2 |     6
     2 |     8
     4 |     6
     4 |     8
     6 |     8
(10 rows)

这肯定会给我们所有左侧小于右侧的行对。在所有这些中，我们希望给定t2_id的行尽可能高;我们将按t2_id分组并选择最大t1_id

# select max(t1.id), t2.id from tbl t1 join tbl t2 on t1.id < t2.id group by t2.id;
 max | id 
-----+-------
   0 |     2
   2 |     4
   4 |     6
   6 |     8
(4 rows)

您的查询使用limit可以实现此目的，但是当存在替代方案时，通常最好避免使用此技术，因为分区在数据库实现中没有良好的可移植支持。 Sqlite可以使用这种技术，但postgresql不喜欢它，它使用一种称为“分析查询”的技术（它既标准化又更通用）。 MySQL既不能做也不能做。但是，上述查询在所有sql数据库引擎中都能保持一致。

其余工作只是使用in或其他等效的过滤查询，并且在sqlalchemy中难以表达。样板......

>>> import sqlalchemy as sa
>>> from sqlalchemy.orm import Query
>>> engine = sa.create_engine('sqlite:///:memory:')
>>> meta = sa.MetaData(bind=engine)
>>> table = sa.Table('tbl', meta, sa.Column('id', sa.Integer))
>>> meta.create_all()

>>> table.insert().execute([{'id':i} for i in range(0, 10, 2)])

>>> t1 = table.alias()
>>> t2 = table.alias()

>>> before_filter = [4, 8]

首先，我们给'max（id）'表达式命名。这是必要的，这样我们就可以不止一次地引用它，并将它从子查询中提取出来。

>>> c1 = sa.func.max(t1.c.id).label('max_id')
>>> #                                ^^^^^^

查询的“繁重”部分，加入上述别名，分组并选择最大值

>>> q1 = Query([c1, t2.c.id]) \
...      .join((t2, t1.c.id < t2.c.id)) \
...      .group_by(t2.c.id) \
...      .filter(t2.c.id.in_(before_filter))

因为我们将使用union，所以我们需要它来生成正确数量的字段：我们将它包装在子查询中并投影到我们感兴趣的唯一列。这将具有我们给它的名称在上面的label()电话中。

>>> q2 = Query(q1.subquery().c.max_id)
>>> #                          ^^^^^^

工会的另一半更简单：

>>> t3 = table.alias()
>>> exact_filter = [0, 8]
>>> q3 = Query(t3).filter(t3.c.id.in_(exact_filter))

剩下的就是将它们结合起来：

>>> q4 = q2.union(q3)
>>> engine.execute(q4.statement).fetchall()
[(0,), (2,), (6,), (8,)]

Answer 3

这里的回复帮助我解决了问题，但就我而言，我必须同时使用correlate()和subquery()：

# ...
subquery = subquery.correlate(OuterCorrelationTable).subquery()
filter_query = db.session.query(func.sum(subquery.c.some_count_column))
filter = filter_query.as_scalar() == as_many_as_some_param
# ...
final_query = db.session.query(OuterCorrelationTable).filter(filter)

如何在SQLAlchemy子查询中指定FROM表？

3 个答案: