Comment mettre à jour plusieurs lignes avec une seule requête MySQL en python?

#!/usr/bin/python

# -*- coding: utf-8 -*-
import MySQLdb as mdb

con = mdb.connect('localhost', 'root', 'root', 'kuis')

with con:

    cur = con.cursor()
    cur.execute("UPDATE Writers SET Name = %s WHERE Id = %s ",
        ("new_value" , "3"))
    print "Number of rows updated:",  cur.rowcount

Avec le code ci-dessus la troisième ligne de la valeur de la table des Écrivains dans la base de données kuis est mis à jour avec nouvelle_valeur et la sortie sera Nombre de lignes mises à jour: 1

Comment suis-je censé mettre à jour plusieurs lignes en même temps?

Changer votre WHERE déclaration pour correspondre à de multiples critères?
peut-être curseur.execute('update sql ...', multi=True)?
voulez-vous mettre à jour plusieurs lignes avec "new_values" = 3, ou plusieurs mises à jour sql avec différents "nouvelle_valeur"?
Je veux mettre à jour comme "tom" dans la troisième rangée, c'est à dire en " 3 " et "sam" dans le quatrième c'est à dire '4', est-il possible avec le seul cur.execute(...) de la requête ou dois-je utiliser la même commande à plusieurs reprises?
les deux mon commentaire et @PeterMmm la réponse va travailler pour vous

OriginalL'auteur TechJhola | 2015-01-02

  1. 17

    Probablement vous êtes à la recherche pour le curseur.executemany.

    cur.executemany("UPDATE Writers SET Name = %s WHERE Id = %s ",
        [("new_value" , "3"),("new_value" , "6")])
    J'ai obtenu le résultat mais pourquoi Nombre de lignes mises à jour est toujours le même c'est à dire 1, qui devrait être de 2 quand j'ai mis à jour deux champs?
    c'est parce que sur le execute niveau il n'y a pas de base de données commettre jusqu'au point de vous faire conn.commit(), c'est le point de vous demander de executemany n'est-ce pas?
    Merci pour cette. Pouvez-vous m'aider dans la requête. Req - "Update matable SET status = 'statut' where id in ()"
    matable SET status = %s where id = %s",[("nouveau statut" , "3"),("nouveau statut" , "6")])

    OriginalL'auteur PeterMmm

  2. 3

    Je ne pense pas que mysqldb a une façon de gérer plusieurs requêtes de mise à JOUR à la fois.

    Mais vous pouvez utiliser une requête d'INSERTION avec SUR le DOUBLE de la CLÉ de mise à JOUR de la condition à la fin.

    J'ai écrit l'exemple suivant pour la facilité d'utilisation et la lisibilité. 

    import MySQLdb

def update_many(data_list=None, mysql_table=None):
    """
    Updates a mysql table with the data provided. If the key is not unique, the
    data will be inserted into the table.

    The dictionaries must have all the same keys due to how the query is built.

    Param:
        data_list (List):
            A list of dictionaries where the keys are the mysql table
            column names, and the values are the update values
        mysql_table (String):
            The mysql table to be updated.
    """

    # Connection and Cursor
    conn = MySQLdb.connect('localhost', 'jeff', 'atwood', 'stackoverflow')
    cur = conn.cursor()

    query = ""
    values = []

    for data_dict in data_list:

        if not query:
            columns = ', '.join('`{0}`'.format(k) for k in data_dict)
            duplicates = ', '.join('{0}=VALUES({0})'.format(k) for k in data_dict)
            place_holders = ', '.join('%s'.format(k) for k in data_dict)
            query = "INSERT INTO {0} ({1}) VALUES ({2})".format(mysql_table, columns, place_holders)
            query = "{0} ON DUPLICATE KEY UPDATE {1}".format(query, duplicates)

        v = data_dict.values()
        values.append(v)

    try:
        cur.executemany(query, values)
    except MySQLdb.Error, e:
        try:
            print"MySQL Error [%d]: %s" % (e.args[0], e.args[1])
        except IndexError:
            print "MySQL Error: %s" % str(e)

        conn.rollback()
        return False

    conn.commit()
    cur.close()
    conn.close()

    Explication de l'un des paquebots de

    columns = ', '.join('`{}`'.format(k) for k in data_dict)

    est le même que

    column_list = []
for k in data_dict:
    column_list.append(k)
columns = ", ".join(columns)

    Voici un exemple d'utilisation

    test_data_list = []
test_data_list.append( {'id' : 1, 'name' : 'Tech', 'articles' : 1 } )
test_data_list.append( {'id' : 2, 'name' : 'Jhola', 'articles' : 8 } )
test_data_list.append( {'id' : 3, 'name' : 'Wes', 'articles' : 0 } )

update_many(data_list=test_data_list, mysql_table='writers')

    La sortie de la requête

    INSERT INTO writers (`articles`, `id`, `name`) VALUES (%s, %s, %s) ON DUPLICATE KEY UPDATE articles=VALUES(articles), id=VALUES(id), name=VALUES(name)

    Valeurs de sortie

    [[1, 1, 'Tech'], [8, 2, 'Jhola'], [0, 3, 'Wes']]
    En fait il y en a un et il est expliqué juste au-dessus de votre réponse. Espérons que vous aussi en profiter 😉
    Cette réponse m'a sauvé beaucoup de temps. J'ai été mise à jour d'une table massive à l'aide de la première réponse et qu'il allait prendre des heures. À l'aide de l'INSERT SUR le DOUBLE de la CLÉ ne prend environ une minute avec la même requête. La raison en est expliqué sur la base de la page: "Dans la plupart des cas, la executemany() la méthode parcourt la séquence de paramètres, à chaque fois en passant les paramètres actuels de la méthode execute ()."

    OriginalL'auteur Westly White

  3. 0

    Simple que j'ai à écrire pour mon utilisation est.

    sql='''INSERT INTO <Tabel Name> (column 1, column 2, ... , column N)
 VALUES (%s, %s, ..., %s) 
ON DUPLICATE KEY UPDATE column1=VALUES(column 1), column3=VALUES(column N)'''

    mycursor.executemany(sql, données)

    data = ['valeur de la colonne 1', 'valeur de la colonne 2' , ... ,'la valeur de la colonne N']

    OriginalL'auteur Kapil Tiwari