Estoy tratando de encontrar la mejor manera de formatear una cadena de consulta SQL. Cuando estoy depurando mi aplicación, me gustaría iniciar sesión para archivar todas las cadenas de consulta SQL, y es importante que la cadena esté formateada correctamente.

Opción 1

def myquery():
    sql = "select field1, field2, field3, field4 from table where condition1=1 and condition2=2"
    con = mymodule.get_connection()
    ...

• Esto es bueno para imprimir la cadena sql.
• No es una buena solución si la cadena es larga y no se ajusta al ancho estándar de 80 caracteres.

opcion 2

def query():
    sql = """
        select field1, field2, field3, field4
        from table
        where condition1=1
        and condition2=2"""
    con = mymodule.get_connection()
    ...

• Aquí el código es claro, pero cuando imprime la cadena de consulta SQL, obtiene todos estos molestos espacios en blanco.

  u '\ nseleccionar campo1, campo2, campo3, campo4 \ ​​n_ _ ___ de la tabla \ n _ ___ donde condición1 = 1 \ n _ ___ _ y condición2 = 2'

Nota: he reemplazado los espacios en blanco con un guión bajo _, porque el editor los recorta

Opción 3

def query():
    sql = """select field1, field2, field3, field4
from table
where condition1=1
and condition2=2"""
    con = mymodule.get_connection()
    ...

• No me gusta esta opción porque rompe la claridad del código bien tabulado.

Opción 4

def query():
    sql = "select field1, field2, field3, field4 " \
          "from table " \
          "where condition1=1 " \
          "and condition2=2 "
    con = mymodule.get_connection()    
    ...

• No me gusta esta opción porque toda la escritura adicional en cada línea y también es difícil editar la consulta.

Para mí la mejor solución sería la Opción 2 pero no me gustan los espacios en blanco adicionales cuando imprimo la cadena sql.

¿Conoces otras opciones?

Perdón por publicar en un hilo tan antiguo, pero como alguien que también comparte la pasión por lo 'mejor' pitónico, pensé en compartir nuestra solución.

La solución es construir declaraciones SQL usando la Concatenación de Literal de Cadena de Python ( http://docs.python.org/ ), que podría calificarse en algún lugar entre la Opción 2 y la Opción 4

Ejemplo de código:

sql = ("SELECT field1, field2, field3, field4 "
       "FROM table "
       "WHERE condition1=1 "
       "AND condition2=2;")

Funciona también con f-strings :

fields = "field1, field2, field3, field4"
table = "table"
conditions = "condition1=1 AND condition2=2"

sql = (f"SELECT {fields} "
       f"FROM {table} "
       f"WHERE {conditions};")

Pros:

1. Conserva el formato pitónico 'bien tabulado', pero no agrega caracteres de espacio extraños (que contamina el registro).
2. Evita la fealdad de la continuación de la barra invertida de la Opción 4, lo que dificulta la adición de declaraciones (sin mencionar la ceguera de los espacios en blanco).
3. Y además, es realmente simple expandir la declaración en VIM (simplemente coloque el cursor en el punto de inserción y presione SHIFT-O para abrir una nueva línea).

Obviamente, ha considerado muchas formas de escribir el SQL de manera que se imprima bien, pero ¿qué tal cambiar la declaración 'imprimir' que usa para el registro de depuración, en lugar de escribir su SQL de formas que no le gustan? Usando su opción favorita anterior, ¿qué tal una función de registro como esta:

def debugLogSQL(sql):
     print ' '.join([line.strip() for line in sql.splitlines()]).strip()

sql = """
    select field1, field2, field3, field4
    from table"""
if debug:
    debugLogSQL(sql)

Esto también haría que sea trivial agregar lógica adicional para dividir la cadena registrada en varias líneas si la línea es más larga que la longitud deseada.

La forma más limpia con la que me he encontrado está inspirada en la guía de estilo sql .

sql = """
    SELECT field1, field2, field3, field4
      FROM table
     WHERE condition1 = 1
       AND condition2 = 2;
"""

Esencialmente, las palabras clave que comienzan una cláusula deben estar alineadas a la derecha y los nombres de los campos, etc., deben estar alineados a la izquierda. Esto se ve muy ordenado y también es más fácil de depurar.

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1={} "
       "and condition2={}").format(1, 2)

Output: 'select field1, field2, field3, field4 from table 
         where condition1=1 and condition2=2'

si el valor de la condición debe ser una cadena, puede hacer lo siguiente:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1='{0}' "
       "and condition2='{1}'").format('2016-10-12', '2017-10-12')

Output: "select field1, field2, field3, field4 from table where
         condition1='2016-10-12' and condition2='2017-10-12'"

Para evitar el formateo por completo , creo que una gran solución es utilizar procedimientos .

Llamar a un procedimiento le da el resultado de cualquier consulta que desee poner en este procedimiento. De hecho, puede procesar varias consultas dentro de un procedimiento. La llamada simplemente devolverá la última consulta que se llamó.

MYSQL

DROP PROCEDURE IF EXISTS example;
 DELIMITER //
 CREATE PROCEDURE example()
   BEGIN
   SELECT 2+222+2222+222+222+2222+2222 AS this_is_a_really_long_string_test;
   END //
 DELIMITER;

#calling the procedure gives you the result of whatever query you want to put in this procedure. You can actually process multiple queries within a procedure. The call just returns the last query result
 call example;

Pitón

sql =('call example;')

podría poner los nombres de los campos en una matriz "campos", y luego:

sql = 'select %s from table where condition1=1 and condition2=2' % (
 ', '.join(fields))

Sugeriría ceñirse a la opción 2 (siempre la uso para consultas más complejas que SELECT * FROM table) y si desea imprimirla de una manera agradable, siempre puede usar un módulo separado .

Para consultas cortas que pueden caber en una o dos líneas, uso la solución literal de cadena en la solución más votada anterior. Para consultas más largas, las divido en .sqlarchivos. Luego uso una función contenedora para cargar el archivo y ejecutar el script, algo como:

script_cache = {}
def execute_script(cursor,script,*args,**kwargs):
    if not script in script_cache:
        with open(script,'r') as s:
            script_cache[script] = s
    return cursor.execute(script_cache[script],*args,**kwargs)

Por supuesto, esto a menudo vive dentro de una clase, por lo que generalmente no tengo que aprobar cursorexplícitamente. También uso generalmente codecs.open(), pero esto hace que la idea general se entienda. Entonces, los scripts SQL son completamente autónomos en sus propios archivos con su propia sintaxis resaltada.

sql = """\
select field1, field2, field3, field4
from table
where condition1=1
and condition2=2
"""

[editar en responder al comentario]
Tener una cadena SQL dentro de un método NO significa que tenga que "tabularlo":

>>> class Foo:
...     def fubar(self):
...         sql = """\
... select *
... from frobozz
... where zorkmids > 10
... ;"""
...         print sql
...
>>> Foo().fubar()
select *
from frobozz
where zorkmids > 10
;
>>>