J'essaie de trouver le meilleur moyen de formater une chaîne de requête SQL. Lorsque je débogue mon application, j'aimerais me connecter pour classer toutes les chaînes de requête SQL, et il est important que la chaîne soit correctement formatée.

Option 1

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

• C'est bon pour imprimer la chaîne sql.
• Ce n'est pas une bonne solution si la chaîne est longue et ne correspond pas à la largeur standard de 80 caractères.

Option 2

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

• Ici, le code est clair, mais lorsque vous imprimez la chaîne de requête SQL, vous obtenez tous ces espaces blancs ennuyeux.

  u '\ nsélectionnez champ1, champ2, champ3, champ4 \ n_ _ ___ de la table \ n _ ___ où condition1 = 1 \ n _ ___ _et condition2 = 2'

Remarque: j'ai remplacé les espaces blancs par des traits de soulignement _, car ils sont coupés par l'éditeur

Option 3

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

• Je n'aime pas cette option car elle brise la clarté du code bien tabulé.

Option 4

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

• Je n'aime pas cette option car toute la saisie supplémentaire dans chaque ligne et il est également difficile de modifier la requête.

Pour moi, la meilleure solution serait l' option 2 mais je n'aime pas les espaces supplémentaires lorsque j'imprime la chaîne sql.

Connaissez-vous d'autres options?

Désolé d'avoir posté sur un fil aussi ancien - mais en tant que personne partageant également une passion pour le «meilleur» pythonique, j'ai pensé partager notre solution.

La solution consiste à créer des instructions SQL en utilisant la concaténation littérale de chaîne de python ( http://docs.python.org/ ), qui pourrait être qualifiée quelque part entre les options 2 et 4.

Exemple de code:

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

Fonctionne également avec les chaînes F :

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

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

Avantages:

1. Il conserve le format pythonique «bien tabulé», mais n'ajoute pas de caractères d'espace superflus (ce qui pollue la journalisation).
2. Cela évite la laideur de la continuation de la barre oblique inverse de l'option 4, ce qui rend difficile l'ajout d'instructions (sans parler de la cécité des espaces blancs).
3. De plus, il est vraiment simple de développer l'instruction dans VIM (placez simplement le curseur sur le point d'insertion et appuyez sur SHIFT-O pour ouvrir une nouvelle ligne).

Vous avez évidemment envisagé de nombreuses façons d'écrire le SQL de manière à ce qu'il s'imprime correctement, mais que diriez-vous de changer l'instruction 'print' que vous utilisez pour la journalisation du débogage, plutôt que d'écrire votre SQL d'une manière que vous n'aimez pas? En utilisant votre option préférée ci-dessus, que diriez-vous d'une fonction de journalisation comme celle-ci:

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)

Cela rendrait également trivial d'ajouter une logique supplémentaire pour diviser la chaîne journalisée sur plusieurs lignes si la ligne est plus longue que la longueur souhaitée.

La manière la plus propre que j'ai rencontrée est inspirée du guide de style SQL .

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

Essentiellement, les mots-clés qui commencent une clause doivent être alignés à droite et les noms de champs, etc., doivent être alignés à gauche. Cela semble très soigné et est également plus facile à déboguer.

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 la valeur de condition doit être une chaîne, vous pouvez faire comme ceci:

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

Pour éviter complètement le formatage , je pense qu'une excellente solution est d'utiliser des procédures .

L'appel d'une procédure vous donne le résultat de la requête que vous souhaitez mettre dans cette procédure. Vous pouvez en fait traiter plusieurs requêtes dans une procédure. L'appel renverra simplement la dernière requête qui a été appelée.

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;

Python

sql =('call example;')

vous pouvez mettre les noms de champs dans un tableau "fields", puis:

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

Je suggérerais de m'en tenir à l'option 2 (je l'utilise toujours pour les requêtes plus complexes que SELECT * FROM table) et si vous souhaitez l'imprimer de manière agréable, vous pouvez toujours utiliser un module séparé .

Pour les requêtes courtes qui peuvent tenir sur une ou deux lignes, j'utilise la solution littérale de chaîne dans la solution la plus votée ci-dessus. Pour les requêtes plus longues, je les divise en .sqlfichiers. J'utilise ensuite une fonction wrapper pour charger le fichier et exécuter le script, quelque chose comme:

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)

Bien sûr, cela vit souvent dans une classe, donc je n'ai généralement pas à passer cursorexplicitement. J'utilise aussi généralement codecs.open(), mais cela fait passer l'idée générale. Ensuite, les scripts SQL sont complètement autonomes dans leurs propres fichiers avec leur propre coloration syntaxique.

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

[edit in responese to comment]
Avoir une chaîne SQL dans une méthode ne signifie PAS que vous devez la «tabuler»:

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