¿Cómo Pony (ORM) hace sus trucos?

Pony ORM hace el buen truco de convertir una expresión generadora en SQL. Ejemplo:

>>> 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]]
>>>

Sé que Python tiene una maravillosa introspección y metaprogramación incorporada, pero ¿cómo esta biblioteca puede traducir la expresión del generador sin preprocesar? Parece magia.

[actualizar]

Blender escribió:

Aquí está el archivo que busca. Parece reconstruir el generador usando algo de magia de introspección. No estoy seguro de si es compatible con el 100% de la sintaxis de Python, pero esto es bastante bueno. - Licuadora

Estaba pensando que estaban explorando alguna característica del protocolo de expresión del generador, pero mirando este archivo y viendo el astmódulo involucrado ... No, no están inspeccionando la fuente del programa sobre la marcha, ¿verdad? Alucinante ...

@BrenBarn: Si intento llamar al generador fuera de la selectllamada a la función, el resultado es:

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

Parece que están haciendo encantamientos más arcanos, como inspeccionar la selectllamada a la función y procesar el árbol gramatical de sintaxis abstracta de Python sobre la marcha.

Todavía me gustaría que alguien lo explicara, la fuente está mucho más allá de mi nivel de hechicería.

El autor de Pony ORM está aquí.

Pony traduce el generador de Python a una consulta SQL en tres pasos:

1. Descompilación del código de bytes del generador y reconstrucción del AST del generador (árbol de sintaxis abstracta)
2. Traducción de Python AST en "SQL abstracto": representación universal basada en listas de una consulta SQL
3. Conversión de la representación SQL abstracta en un dialecto SQL específico dependiente de la base de datos

La parte más compleja es el segundo paso, donde Pony debe comprender el "significado" de las expresiones de Python. Parece que estás más interesado en el primer paso, así que déjame explicarte cómo funciona la descompilación.

Consideremos esta consulta:

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

Que se traducirá al siguiente SQL:

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

Y a continuación se muestra el resultado de esta consulta que se imprimirá:

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

La select()función acepta un generador de Python como argumento y luego analiza su código de bytes. Podemos obtener instrucciones de código de bytes de este generador usando el dismódulo estándar de Python :

>>> 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 tiene la función decompile()dentro del módulo pony.orm.decompilingque puede restaurar un AST desde el código de bytes:

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

Aquí, podemos ver la representación textual de los nodos AST:

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

Veamos ahora cómo decompile()funciona la función.

La decompile()función crea un Decompilerobjeto, que implementa el patrón Visitor. La instancia del descompilador obtiene instrucciones de código de bytes una por una. Para cada instrucción, el objeto descompilador llama a su propio método. El nombre de este método es igual al nombre de la instrucción de código de bytes actual.

Cuando Python calcula una expresión, usa pila, que almacena un resultado intermedio del cálculo. El objeto descompilador también tiene su propia pila, pero esta pila no almacena el resultado del cálculo de la expresión, sino el nodo AST para la expresión.

Cuando se llama al método de descompilador para la siguiente instrucción de código de bytes, toma los nodos AST de la pila, los combina en un nuevo nodo AST y luego coloca este nodo en la parte superior de la pila.

Por ejemplo, veamos cómo c.country == 'USA'se calcula la subexpresión . El fragmento de código de bytes correspondiente es:

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

Entonces, el objeto descompilador hace lo siguiente:

1. Llamadas decompiler.LOAD_FAST('c'). Este método coloca el Name('c')nodo en la parte superior de la pila del descompilador.
2. Llamadas decompiler.LOAD_ATTR('country'). Este método toma el Name('c')nodo de la pila, crea el Geattr(Name('c'), 'country')nodo y lo coloca en la parte superior de la pila.
3. Llamadas decompiler.LOAD_CONST('USA'). Este método coloca el Const('USA')nodo en la parte superior de la pila.
4. Llamadas decompiler.COMPARE_OP('=='). Este método toma dos nodos (Getattr y Const) de la pila y luego los coloca Compare(Getattr(Name('c'), 'country'), [('==', Const('USA'))]) en la parte superior de la pila.

Después de que se procesan todas las instrucciones de código de bytes, la pila del descompilador contiene un solo nodo AST que corresponde a toda la expresión del generador.

Dado que Pony ORM solo necesita descompilar generadores y lambdas, esto no es tan complejo, porque el flujo de instrucciones para un generador es relativamente sencillo: es solo un montón de bucles anidados.

Actualmente, Pony ORM cubre todo el conjunto de instrucciones del generador, excepto dos cosas:

1. Expresiones if en línea: a if b else c
2. Comparaciones compuestas: a < b < c

Si Pony encuentra tal expresión, plantea la NotImplementedErrorexcepción. Pero incluso en este caso, puede hacer que funcione pasando la expresión del generador como una cadena. Cuando pasas un generador como una cadena, Pony no usa el módulo descompilador. En su lugar, obtiene el AST utilizando la compiler.parsefunción estándar de Python .

Espero que esto responda a su pregunta.