quick - Cómo arreglar "cerca de ''con'': error de sintaxis" en la consulta CTE recursiva(matraz/sqlalchemy)

sqlalchemy relationship

Question

Estoy tratando de reproducir esta consulta que se encuentra en la página de documentos SqlAlchemy. Después de configurar la clase Part en models.py , esto es lo que tengo:

from app import app, db, models
from models import *

@app.route(''/'')
def test():
    included_parts = db.session.query(
                    Part.sub_part,
                    Part.part,
                    Part.quantity)./
                        filter(Part.part=="our part")./
                        cte(name="included_parts", recursive=True)

    incl_alias = db.aliased(included_parts, name="pr")
    parts_alias = db.aliased(Part, name="p")
    included_parts = included_parts.union_all(
        db.session.query(
            parts_alias.sub_part,
            parts_alias.part,
            parts_alias.quantity)./
                filter(parts_alias.part==incl_alias.c.sub_part)
        )

    q = db.session.query(
            included_parts.c.sub_part,
            db.func.sum(included_parts.c.quantity).
                label(''total_quantity'')
        )./
        group_by(included_parts.c.sub_part).all()

    return ''test complete''

Pero esto da un error:

OperationalError: (sqlite3.OperationalError) near "WITH": syntax error [SQL: u''WITH RECURSIVE included_parts(sub_part, part, quantity) AS /n(SELECT parts.sub_part AS sub_part, parts.part AS part, parts.quantity AS quantity /nFROM parts /nWHERE parts.part = ? UNION ALL SELECT p.sub_part AS p_sub_part, p.part AS p_part, p.quantity AS p_quantity /nFROM parts AS p, included_parts AS pr /nWHERE p.part = pr.sub_part)/n SELECT included_parts.sub_part AS included_parts_sub_part, sum(included_parts.quantity) AS total_quantity /nFROM included_parts GROUP BY included_parts.sub_part''] [parameters: (''our part'',)]

La consulta generada (copia pegada desde el mensaje de error) se ve así:

WITH RECURSIVE included_parts(sub_part, part, quantity) AS /n(SELECT parts.sub_part AS sub_part, parts.part AS part, parts.quantity AS quantity /nFROM parts /nWHERE parts.part = ? UNION ALL SELECT p.sub_part AS p_sub_part, p.part AS p_part, p.quantity AS p_quantity /nFROM parts AS p, included_parts AS pr /nWHERE p.part = pr.sub_part)/n SELECT included_parts.sub_part AS included_parts_sub_part, sum(included_parts.quantity) AS total_quantity /nFROM included_parts GROUP BY included_parts.sub_part

Formateado (con saltos de línea en diferentes lugares para la legibilidad):

WITH RECURSIVE included_parts(sub_part, part, quantity) AS (
    SELECT parts.sub_part AS sub_part, parts.part AS part, parts.quantity AS quantity 
    FROM parts
    WHERE parts.part = ? 
    UNION ALL 
    SELECT p.sub_part AS p_sub_part, p.part AS p_part, p.quantity AS p_quantity
    FROM parts AS p, included_parts AS pr 
    WHERE p.part = pr.sub_part
)
SELECT included_parts.sub_part AS included_parts_sub_part, sum(included_parts.quantity) AS total_quantity 
FROM included_parts 
GROUP BY included_parts.sub_part

Y, para fines de comparación, aquí está la consulta pura de PostgreSQL a la que el archivo sqlalchemy hace un enlace :

WITH RECURSIVE included_parts(sub_part, part, quantity) AS (
    SELECT sub_part, part, quantity FROM parts WHERE part = ''our_product''
  UNION ALL
    SELECT p.sub_part, p.part, p.quantity
    FROM included_parts pr, parts p
    WHERE p.part = pr.sub_part
  )
SELECT sub_part, SUM(quantity) as total_quantity
FROM included_parts
GROUP BY sub_part

Las únicas diferencias que puedo ver entre la consulta de Postgre (que supongo que se supone que debe funcionar) y la que estoy generando son:

1. Todas las declaraciones "AS" adicionales ( SELECT parts.sub_part AS sub_part SELECT sub_part )
2. Formato diferente (la consulta generada tiene saltos de línea en lugares extraños, por ejemplo, no hay interrupción de línea entre UNION ALL y SELECT )

Pero, por lo que puedo decir, ninguno de ellos debería causar un error de sintaxis ... También he intentado ejecutar la consulta de Postgre como SQL sin formato (aunque SQLAlchemy utiliza sqlite3, aparentemente, pero aún):

    query = db.engine.execute(/
    ''''''WITH RECURSIVE included_parts(sub_part, part, quantity) AS (
SELECT sub_part, part, quantity FROM parts WHERE part = ''our_product''
UNION ALL
SELECT p.sub_part, p.part, p.quantity
FROM included_parts pr, parts p
WHERE p.part = pr.sub_part
)
SELECT sub_part, SUM(quantity) as total_quantity
FROM included_parts
GROUP BY sub_part'''''').all()

Pero sigo teniendo un error de sintaxis.

OperationalError: (sqlite3.OperationalError) near "WITH": syntax error [SQL: "WITH RECURSIVE included_parts(sub_part, part, quantity) AS (/nSELECT sub_part, part, quantity FROM parts WHERE part = ''our_product''/nUNION ALL/nSELECT p.sub_part, p.part, p.quantity/nFROM included_parts pr, parts p/nWHERE p.part = pr.sub_part/n)/nSELECT sub_part, SUM(quantity) as total_quantity/nFROM included_parts/nGROUP BY sub_part"]

También intenté reformatear la consulta generada y ejecutarla como SQL sin procesar con resultados similares.

Y, finalmente, intenté escribir una consulta en SQLite y ejecutarla:

WITH RECURSIVE included_parts(sub_part, part, quantity) AS (
    SELECT sub_part, part, quantity FROM parts WHERE part="our_product"
    UNION ALL
    SELECT parts.sub_part, parts.part, parts.quantity FROM parts, included_parts WHERE parts.part=included_parts.sub_part
)
SELECT sub_part, SUM(quantity) AS total_quantity
FROM included_parts
GROUP BY sub_part

Esto también arroja un error de sintaxis.

En este punto, no estoy seguro de qué hacer ... parece que incluso una consulta WITH con la sintaxis correcta aún arrojará un error. Sé que las consultas recursivas CTE son compatibles con Sqlalchemy, de acuerdo con los documentos y de acuerdo con esta (_http: //stackoverflow.com/a/24780445) respuesta aquí. Sinceramente, no tengo idea de por qué se considera que todas estas consultas tienen mala sintaxis. Mi código python es prácticamente idéntico al ejemplo en los documentos.

¿Debo instalar algo para WITH RECURSIVE para trabajar en SQLAlchemy? ¿Mi sintaxis es realmente incorrecta? Casi perdido aquí, cualquier ayuda es apreciada.

(Editando para regresar a la página principal. Desearía poder decir que he progresado, pero literalmente no tengo ni idea de qué hacer en este momento. ¿Es esto un problema de PostgreSQL frente a SQLite? ¿Alguien tiene un ejemplo de trabajo? de lo que estoy tratando de hacer que puedo mirar?)

Answer 1

El problema es que está ejecutando una versión anterior de sqlite3 (como se discutió en #sqlalchemy); tiene 3.8.2 y se agregó soporte CTE en 3.8.3.