Exécution de requêtes SQL à partir d'un fichier dans SQLAlchemy

Comment puis-je exécuter l'ensemble des fichiers sql dans la base de données à l'aide de SQLAlchemy? Il existe beaucoup de différentes requêtes sql dans le fichier, y compris begin et commit/rollback.

InformationsquelleAutor Szymon Lipiński | 2010-02-15

4

Malheureusement, je ne suis pas au courant d'une bonne réponse à cette question. Certains dbapi de l' (psycopg2 par exemple) pour l'exécution de plusieurs instructions à la fois. Si les fichiers ne sont pas énormes, vous pouvez simplement charger dans une chaîne de caractères et de les exécuter sur une connexion. Pour les autres, je voudrais essayer d'utiliser un client de ligne de commande pour que db et le tuyau de données en utilisant le sous-processus module.

Si ces approches ne sont pas acceptables, alors vous aurez à aller de l'avant et de mettre en œuvre un petit analyseur SQL qui peut diviser le fichier à l'écart, dans des déclarations séparées. C'est vraiment difficile à obtenir 100% de réponses correctes, que vous aurez à facteur dans la base de données dialecte spécifique littérale échapper à des règles, le jeu de caractères utilisé, toute base de données options de configuration qui affectent littéral de l'analyse (par exemple, PostgreSQL standard_conforming_strings).

Si vous avez seulement besoin d'obtenir cette 99.9% de réponses correctes, puis quelques regexp magie devrait vous obtenez la plupart du chemin.

InformationsquelleAutor Ants Aasma

J'ai été en mesure d'exécuter .schéma sql fichiers à l'aide de pure SQLAlchemy et certaines manipulations de chaînes. Il n'est sûrement pas une approche élégante, mais il fonctionne.

# Open the .sql file
sql_file = open('file.sql','r')

# Create an empty command string
sql_command = ''

# Iterate over all lines in the sql file
for line in sql_file:
    # Ignore commented lines
    if not line.startswith('--') and line.strip('\n'):
        # Append line to the command string
        sql_command += line.strip('\n')

        # If the command string ends with ';', it is a full statement
        if sql_command.endswith(';'):
            # Try to execute statement and commit it
            try:
                session.execute(text(sql_command))
                session.commit()

            # Assert in case of error
            except:
                print('Ops')

            # Finally, clear command string
            finally:
                sql_command = ''

Il parcourt toutes les lignes dans une .fichier sql en ignorant les lignes commentées.
Puis il enchaîne des lignes qui forment une déclaration complète et tente d'exécuter l'instruction. Vous avez juste besoin d'un gestionnaire de fichier et un objet de session.

InformationsquelleAutor Joao Felipe Santos

4

Si vous utilisez sqlite3 il a une extension utile pour dbapi appelé conn.executescript(str), j'ai accroché ce par quelque chose comme cela et ça semblait fonctionner: (Pas tout le contexte est montré, mais il devrait être suffisant pour obtenir la dérive)
```
def init_from_script(script):
    Base.metadata.drop_all(db_engine)
    Base.metadata.create_all(db_engine)     

    # HACK ALERT: we can do this using sqlite3 low level api, then reopen session.
    f = open(script)
    script_str = f.read().strip()
    global db_session
    db_session.close()
    import sqlite3
    conn = sqlite3.connect(db_file_name)
    conn.executescript(script_str)
    conn.commit()

    db_session = Session()
```
Est-ce mal pur, je me demande? J'ai cherché en vain une "pure" sqlalchemy équivalent, cela pourrait peut-être être ajouté à la bibliothèque, quelque chose comme db_session.execute_script(file_name) ? J'espère que db_session fonctionnent très bien, après tout ça (c'est à dire, pas besoin de redémarrer le moteur), mais pas sûr encore... plus de recherche est nécessaire (c'est à dire que nous avons besoin d'un nouveau moteur ou tout simplement une session après avoir derrière sqlalchemy est de retour?)

FYI sqlite3 comprend une relative routine: sqlite3.complete_statement(sql) si vous roulez votre propre parser...

InformationsquelleAutor CarlS
1

Vous pouvez le faire avec SQLalchemy et psycopg2.
```
file = open(path)
engine = sqlalchemy.create_engine(db_url)
escaped_sql = sqlalchemy.text(file.read())
engine.execute(escaped_sql)
```
- Cela ne fonctionnera pas avec tous les dialectes. SQLite par exemple, interdit explicitement l'exécution de plusieurs requêtes en une seule "exécution de la commande".
- pysqlite ne fournissent executescript donc une condition simple vérification de permettre, au travers d'une raw_connection
InformationsquelleAutor AlexQueue
0

Vous pouvez accéder à la crue DBAPI connexion par le biais de ce
```
raw_connection = mySqlAlchemyEngine.raw_connection()
raw_cursor = raw_connection() #get a hold of the proxied DBAPI connection instance
```
mais ensuite cela dépend du dialecte/pilote que vous utilisez, ce qui peut être considéré par le biais de ce liste.

Pour pyscog2, il vous suffit de faire
```
raw_cursor.execute(open("my_script.sql").read())
```
mais pysqlite vous aurez besoin de faire
```
raw_cursor.executescript(open("my_script").read())
```
et en ligne avec qui vous auriez besoin de vérifier la documentation de celui DBAPI pilote que vous utilisez pour voir si plusieurs états sont autorisés dans un exécuter ou si vous avez besoin d'utiliser une aide comme executescript qui est unique à pysqlite.

InformationsquelleAutor David

Vous devez vous connecter pour publier un commentaire.