小马（ORM）如何发挥作用？

Pony ORM很好地把生成器表达式转换成SQL。例：

>>> select(p for p in Person if p.name.startswith('Paul'))
        .order_by(Person.name)[:2]

SELECT "p"."id", "p"."name", "p"."age"
FROM "Person" "p"
WHERE "p"."name" LIKE "Paul%"
ORDER BY "p"."name"
LIMIT 2

[Person[3], Person[1]]
>>>

我知道Python具有出色的自省和内置元编程功能，但是该库如何能够在不进行预处理的情况下转换生成器表达式？看起来像魔术。

[更新]

搅拌器写道：

这是您要查找的文件。似乎可以使用一些自省向导来重构生成器。我不确定它是否支持100％的Python语法，但这很酷。- 搅拌机

我以为他们正在研究生成器表达协议中的某些功能，但正在查看此文件并看到其中ast涉及的模块...不，他们不是在动态检查程序源，是吗？令人振奋...

@BrenBarn：如果我尝试在select函数调用之外调用生成器，则结果为：

>>> x = (p for p in Person if p.age > 20)
>>> x.next()
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
  File "<interactive input>", line 1, in <genexpr>
  File "C:\Python27\lib\site-packages\pony\orm\core.py", line 1822, in next
    % self.entity.__name__)
  File "C:\Python27\lib\site-packages\pony\utils.py", line 92, in throw
    raise exc
TypeError: Use select(...) function or Person.select(...) method for iteration
>>>

好像他们在做更多不可思议的事情，例如检查select函数调用和动态处理Python抽象语法语法树。

我仍然希望看到有人对此进行解释，其来源远远超出了我的巫术水平。

小马ORM作者在这里。

Pony通过三个步骤将Python生成器转换为SQL查询：

1. 反编译生成器字节码并重建生成器AST（抽象语法树）
2. 将Python AST转换为“抽象SQL”-SQL查询的基于列表的通用表示形式
3. 将抽象SQL表示转换为特定于数据库的SQL方言

最复杂的部分是第二步，其中Pony必须了解Python表达式的“含义”。似乎您对第一步最感兴趣，所以让我解释一下反编译的工作原理。

让我们考虑以下查询：

>>> from pony.orm.examples.estore import *
>>> select(c for c in Customer if c.country == 'USA').show()

将其转换为以下SQL：

SELECT "c"."id", "c"."email", "c"."password", "c"."name", "c"."country", "c"."address"
FROM "Customer" "c"
WHERE "c"."country" = 'USA'

下面是该查询的结果，将其打印出来：

id|email              |password|name          |country|address  
--+-------------------+--------+--------------+-------+---------
1 |john@example.com   |***     |John Smith    |USA    |address 1
2 |matthew@example.com|***     |Matthew Reed  |USA    |address 2
4 |rebecca@example.com|***     |Rebecca Lawson|USA    |address 4

该select()函数接受python生成器作为参数，然后分析其字节码。我们可以使用标准的python dis模块获取此生成器的字节码指令：

>>> gen = (c for c in Customer if c.country == 'USA')
>>> import dis
>>> dis.dis(gen.gi_frame.f_code)
  1           0 LOAD_FAST                0 (.0)
        >>    3 FOR_ITER                26 (to 32)
              6 STORE_FAST               1 (c)
              9 LOAD_FAST                1 (c)
             12 LOAD_ATTR                0 (country)
             15 LOAD_CONST               0 ('USA')
             18 COMPARE_OP               2 (==)
             21 POP_JUMP_IF_FALSE        3
             24 LOAD_FAST                1 (c)
             27 YIELD_VALUE         
             28 POP_TOP             
             29 JUMP_ABSOLUTE            3
        >>   32 LOAD_CONST               1 (None)
             35 RETURN_VALUE

Pony ORM decompile()在模块内pony.orm.decompiling具有可以从字节码恢复AST 的功能：

>>> from pony.orm.decompiling import decompile
>>> ast, external_names = decompile(gen)

在这里，我们可以看到AST节点的文本表示形式：

>>> ast
GenExpr(GenExprInner(Name('c'), [GenExprFor(AssName('c', 'OP_ASSIGN'), Name('.0'),
[GenExprIf(Compare(Getattr(Name('c'), 'country'), [('==', Const('USA'))]))])]))

现在让我们看看该decompile()函数是如何工作的。

该decompile()函数创建一个Decompiler对象，该对象实现了Visitor模式。反编译器实例一一获取字节码指令。对于每条指令，反编译器对象都会调用其自己的方法。该方法的名称等于当前字节码指令的名称。

Python计算表达式时，它使用堆栈，该堆栈存储中间的计算结果。反编译器对象也有自己的堆栈，但是该堆栈不存储表达式计算的结果，而是存储表达式的AST节点。

当调用下一个字节码指令的反编译器方法时，它将从堆栈中取出AST节点，将它们组合成一个新的AST节点，然后将该节点放在堆栈的顶部。

例如，让我们看看如何c.country == 'USA'计算子表达式。相应的字节码片段为：

              9 LOAD_FAST                1 (c)
             12 LOAD_ATTR                0 (country)
             15 LOAD_CONST               0 ('USA')
             18 COMPARE_OP               2 (==)

因此，反编译器对象执行以下操作：

1. 来电decompiler.LOAD_FAST('c')。此方法将Name('c')节点放在反编译器堆栈的顶部。
2. 来电decompiler.LOAD_ATTR('country')。此方法Name('c')从堆栈中取出节点，创建该Geattr(Name('c'), 'country')节点并将其放在堆栈顶部。
3. 来电decompiler.LOAD_CONST('USA')。此方法将Const('USA')节点放在堆栈顶部。
4. 来电decompiler.COMPARE_OP('==')。此方法从堆栈中获取两个节点（Getattr和Const），然后将其Compare(Getattr(Name('c'), 'country'), [('==', Const('USA'))]) 放在堆栈的顶部。

在处理完所有字节码指令之后，反编译器堆栈将包含一个与整个生成器表达式相对应的AST节点。

由于Pony ORM仅需要反编译生成器和lambda，因此并没有那么复杂，因为生成器的指令流相对简单-它只是一堆嵌套循环。

目前，Pony ORM涵盖了整个生成器指令集，但以下两点除外：

1. 内联if表达式： a if b else c
2. 复合比较： a < b < c

如果Pony遇到此类表达，则会引发NotImplementedError异常。但是即使在这种情况下，您也可以通过将生成器表达式作为字符串传递来使其工作。当您将生成器作为字符串传递时，Pony不使用反编译器模块。相反，它使用标准Python compiler.parse函数获取AST 。

希望这能回答您的问题。