MySQLdb.le curseur.exécuter ne peut pas exécuter plusieurs requêtes

Nous essayons d'exécuter des fichiers SQL contenant les instructions insert comme une seule requête, mais il semble rollback échoue lorsque l'un quelconque des états de contenir une erreur.

MySQLd configuration:

sql_mode = STRICT_ALL_TABLES
default-storage-engine = innodb

Code Python:

from contextlib import closing
import MySQLdb
database_connection = MySQLdb.connect(host="127.0.0.1", user="root")
with closing(database_connection.cursor()) as cursor:
    database_connection.begin()
    cursor.execute('DROP DATABASE IF EXISTS db_name')
    cursor.execute('CREATE DATABASE db_name')
    cursor.execute('USE db_name')
    cursor.execute('CREATE TABLE table_name(first_field INTEGER)')
with closing(database_connection.cursor()) as cursor:
    try:
        database_connection.begin()
        cursor.execute('USE db_name')
        cursor.execute('INSERT INTO table_name VALUES (1)')
        cursor.execute('INSERT INTO table_name VALUES ("non-integer value")')
        database_connection.commit()
    except Exception as error:
        print("Exception thrown: {0}".format(error))
        database_connection.rollback()
        print("Rolled back")
with closing(database_connection.cursor()) as cursor:
    try:
        database_connection.begin()
        cursor.execute('USE db_name')
        cursor.execute('INSERT INTO table_name VALUES (1); INSERT INTO table_name VALUES ("non-integer value")')
        database_connection.commit()
    except:
        print("Exception thrown: {0}".format(error))
        database_connection.rollback()
        print("Rolled back")

Résultat attendu: "Exception" et "annulées" imprimé deux fois.

Résultat réel avec MySQL-python 1.2.4:

Exception thrown: (1366, "Incorrect integer value: 'non-integer value' for column 'first_field' at row 1")
Rolled back
Exception thrown: (1366, "Incorrect integer value: 'non-integer value' for column 'first_field' at row 1")
Traceback (most recent call last):
  File "test.py", line 30, in <module>
    print("Rolled back")
  File ".../python-2.7/lib/python2.7/contextlib.py", line 154, in __exit__
    self.thing.close()
  File ".../virtualenv-python-2.7/lib/python2.7/site-packages/MySQLdb/cursors.py", line 100, in close
    while self.nextset(): pass
  File ".../virtualenv-python-2.7/lib/python2.7/site-packages/MySQLdb/cursors.py", line 132, in nextset
    nr = db.next_result()
_mysql_exceptions.OperationalError: (1366, "Incorrect integer value: 'non-integer value' for column 'first_field' at row 1")

Ce qui donne? Faut-il vraiment analyser le code SQL de diviser les états (avec tous l'évasion et la citation de manipulation que cela implique) pour exécuter en plusieurs executes?

OriginalL'auteur l0b0 | 2013-12-11

15

Comme tous les Python DB-API 2.0 implémentations, le cursor.execute() méthode est conçue pour ne prendre que un déclaration, car elle permet de garanties sur l'état du curseur par la suite.

Utiliser le curseur.executemany() méthode à la place. Notez que, comme par le DB-API 2.0:

Utilisation de cette méthode pour une opération qui produit un ou plusieurs ensembles de résultats constitue un comportement indéfini, et la mise en œuvre est autorisée (mais pas obligatoire) pour soulever une exception lorsqu'il détecte qu'un ensemble de résultats a été créé par une invocation de l'opération.

L'utilisation de ce pour de multiples INSERT déclarations doivent être parfaitement:
```
cursor.executemany('INSERT INTO table_name VALUES (%s)',
    [(1,), ("non-integer value",)]
)
```
Si vous avez besoin d'exécuter une série de différents états, comme à partir d'un script, puis pour la plupart des cas, vous pouvez simplement diviser les déclarations sur ; et nourrir chaque énoncé pour cursor.execute() séparément.

Je ne vois pas où .execute DB-spécification de l'API interdit plusieurs états. La simple existence de la nextset méthode implique que execute est le droit de la fonction pour plusieurs requêtes. executemany est certainement pas: non seulement la norme en garde contre elle, la fonction de signature et la fin est complètement différente de l'opération de execute. Quelles garanties sur l'état de curseur sont maintenus en ne permettant qu'à une seule déclaration?
vous semblez être confusion avec l'opération qui les produit. execute() prend un de la requête ou de la commande (la formulation est clairement singulier dans les specs). L'avertissement sur executemany() préoccupations des requêtes qui produisent des ensembles de résultats; en particulier SELECT. L'OP est à l'aide de INSERT, qui ne produit pas de résultat si l'avertissement ne s'applique pas. Ils utilisent exactement la même requête dans chaque cas, seules les valeurs sont variables, ce qui est exactement ce executemany est idéal pour: répétition de la même requête avec des valeurs de paramètres différentes.
si vous vouliez exécuter un script, puis il n'y a pas de disposition à cet égard dans le DB-API. Certains adaptateurs de mettre en œuvre une certaine forme d'exécution de script (comme sqlite3's executescript() fonction, mais qui ne fait pas partie de l'API spec.
Personnellement, j'ai l'impression que vous êtes plus de la lecture de la PEP à ce point. Pourquoi, même si le PEP (et des réalisateurs de la PEP) permettent seulement une seule requête? Il rend significativement de plus en plus lourde pour avoir un .fichier sql que Python exécute: soit vous êtes obligés de mettre en œuvre et de l'ensemble de l'analyseur SQL, ou d'avoir à envelopper le SQL dans un microlanguage qui sépare les commandes, complètement briser la capacité à la nourrir de la bonne DB client. En bref, le PEP de lutter activement contre le programmeur a besoin à ce moment-là; c'est exaspérant.
est une méthode de curseur. Un curseur modèles de un jeu de résultats, et non plusieurs. Vous ne pouvez pas obtenir les résultats de plusieurs requêtes, exécuter ainsi seulement vous permet d'exécuter une seule instruction à la fois.

OriginalL'auteur Martijn Pieters
4

Je pense que vous avez besoin pour passer multi=True à execute lors de l'utilisation de plusieurs instructions, voir http://dev.mysql.com/doc/connector-python/en/connector-python-api-mysqlcursor-execute.html

Mise à jour: Cela s'applique à la mysql.connector module, pas MySQLdb utilisé dans ce cas.

OriginalL'auteur Johannes
3

Il n'est apparemment pas moyen de le faire dans MySQLdb (aka. MySQL-python), nous avons donc fini juste communicateing les données de subprocess.Popen([mysql, ...], stdin=subprocess.PIPE) et la vérification de la returncode.

OriginalL'auteur l0b0
1

Essayé le multi=True méthode, mais a fini par diviser le fichier en semi et en boucle à travers. De toute évidence ne va pas fonctionner si vous avez échappé à la demi-finale, mais semble être la meilleure méthode pour moi.
```
with connection.cursor() as cursor:
    for statement in script.split(';'):
        if len(statement) > 0:
             cursor.execute(statement + ';')
```
OriginalL'auteur DavidSM
0

À l'aide de la mysql programme via Popen sera certainement le travail, mais si vous voulez juste utiliser une connexion existante (et curseur), la sqlparse paquet a une split fonction qui sera divisée en états. Je ne suis pas sûr de ce que la compatibilité est, mais j'ai un script qui n':
```
with open('file.sql', 'rb') as f:
    for statement in sqlparse.split(f.read()):
        if not statement:
            continue
        cur.execute(statement)
```
Uniquement de la fed TABLE et CREATE TABLE, mais fonctionne pour moi.

https://pypi.python.org/pypi/sqlparse

OriginalL'auteur morganwahl
-2

utiliser en dessous de la ligne de l'élément à l'instruction execute :

pour _ curseur.execute(requête, multi=True): pass

OriginalL'auteur abhishek

Vous devez vous connecter pour publier un commentaire.