L'exécution des différentes requêtes à l'aide de mysql-python

Je travaille avec une télécommande db pour l'importation de données à mon Django proyect de la db.

Avec l'aide de MySQLdb j'ai réussi avec la facilité de créer une fonction d'importation comme suit:

def connect_and_get_data(useful_string):
    CONNECTION = MySQLdb.connect(host=..., port=...,
                                 user=..., passwd=..., db=...,
                                 cursorclass=MySQLdb.cursors.DictCursor,
                                 charset = "utf8")
    cursor = CONNECTION.cursor()
    cursor.execute("SELECT ... FROM ... WHERE ... AND some_field=%s", (useful_string))
    result = cursor.fetchall()
    cursor.close()

Très heureux, fonctionne comme prévu.

Mais en allant sur le code, j'ai remarqué que, parfois, je vais avoir besoin de vous connecter à la db de nouveau, afin d'exécuter d'autres requêtes différentes.

La première idée était tout à fait logique, pour moi:
pour chaque requête, je vais avoir besoin, de définir une fonction qui appelle connect_and_get_data avec la requête donnée en paramètre... quelque chose comme ceci:

def get_data_about_first_amazing_topic(useful_string):
    query = "SELECT ... FROM ... WHERE ... AND some_field=%s" %(useful_string)
    connect_and_get_data(query)
    ...

def get_data_about_second_amazing_topic(other_useful_string):
    query = "SELECT ... FROM ... WHERE ... AND some_field=%s" %(other_useful_string)
    connect_and_get_data(query)
    ...

avec ces modifications à connect_and_get_data:

def connect_and_get_data(query):
    ...
    cursor.execute(query)
    ...

Comme vous l'avez déjà peut l'imaginer, cette solutions échoue.

Lecture mluebke, la réponse à la question python mysql fetch requête

"Vous êtes de passage d'arguments à la fonction execute, ne pas faire de python substitution de chaîne"

J'ai compris tout de suite où j'ai eu tort; mais j'ai toujours l'impression qu'il manque quelque chose: j'ai essayé différentes solutions, mais je suis vraiment malheureux avec eux tous.

Est-il un "bon" manière à encapsuler mon connect_and_get_data(query) de la fonction, afin de me servir de la façon dont je le veux, ou je suis totalement dans le mauvais chemin?

Ceux qui sont considérés comme "meilleures pratiques" dans cette situation?

OriginalL'auteur dolma33 | 2011-11-11

  1. 6

    Je pense que c'est ce que vous cherchez.

    def connect_and_get_data(query, data):
    ...
    cursor.execute(query, data)
    ...

def get_data_about_first_amazing_topic(useful_string):
    query = "SELECT ... FROM ... WHERE ... AND some_field=%s"
    connect_and_get_data(query, ("one","two","three"))
    ...

    Mais, si vous allez faire plusieurs requêtes rapidement, il serait préférable de réutiliser votre connexion, depuis de trop nombreuses connexions peuvent perdre de temps.

    ...
CONNECTION = MySQLdb.connect(host=..., port=...,
                             user=..., passwd=..., db=...,
                             cursorclass=MySQLdb.cursors.DictCursor,
                             charset = "utf8")
cursor = CONNECTION.cursor()
cursor.execute("SELECT ... FROM ... WHERE ... AND some_field=%s", ("first", "amazing", "topic"))
first_result = cursor.fetchall()

cursor.execute("SELECT ... FROM ... WHERE ... AND some_field=%s", (("first", "amazing", "topic")))
second_result = cursor.fetchall()

cursor.close()
...

    Cela permettra de rendre votre code plus performant.

    Oui... Vous avez raison! Je vais dans ce sens... Mais si je vais avoir besoin de deux useful_strings dans ma requête? qui allait transformer data un tableau args... droit? et comment va réagir le curseur.exécuter lors de la réception d'un tableau de chaînes de caractères? mmm...
    Vous pouvez utiliser un tuple (une séquence similaire à un tableau) comme le 2e paramètre de connect_and_get_data. cursor.execute accepte les tuples comme second paramètre. Les Tuples sont juste une séquence d'éléments entouré par des parenthèses, par exemple ("one","two","three"). En fait, si vous regardez votre code, vous pouvez voir (useful_string), entre parenthèses, que l'argument de execute().
    Ne peut pas réutiliser ma connexion pour de nombreuses requêtes: malheureusement, la distance db se trouve sur une machine avec un très slooow (moins de 10k télécharger) et super instable de connexion (travail sur une île au milieu du pacifique a ses inconvénients, et l'un d'eux est la lenteur de la connexion par satellite)... donc, je dois avoir, à court et lumière "atomique" db connections...
    BTW, j'aime votre solution (1er morceau de code, parce que la 2ème ne s'applique pas). Je ne sais pas pourquoi j'ai bloqué moi-même en face de ce tuple-argument chose... C'est vrai que parfois nous sommes tout simplement trop immergé dans notre code, on ne voit pas de solutions évidentes couché devant notre nez... Merci 😉
    "drôle" remarque: dans la première version, celle décrite dans mon premier code, le résultat renvoyé de execute() est une liste de dictionnaires. dans la version modifiée, l'un encapsulés de la fonction, le résultat renvoyé de execute() est un n-uplet de dictionnaires... une idée sur la raison?

    OriginalL'auteur Kylos