Traitement des insertions de table DB à l'aide de sqlalchemy

ex1) Insérez plusieurs enregistrements dans n'importe quelle table (1)

Réticent au début, mais honnête? L'enregistrement a été inséré une ligne à la fois dans la table en répétant le processus de définition de la valeur de chaque colonne dans myobject et session.add (myobject) dans une boucle for.

sql_insert_old.py



Base = sqlalchemy.ext.declarative.declarative_base()

class Hogega_tmp(Base):
    __tablename__ = 'hogega_tmps'
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
    y = sqlalchemy.Column(sqlalchemy.String(10))
    m = sqlalchemy.Column(sqlalchemy.String(10))
    d = sqlalchemy.Column(sqlalchemy.String(10))
    dim4 = sqlalchemy.Column(sqlalchemy.String(100))
    pv = sqlalchemy.Column(sqlalchemy.String(50))
    rsf = sqlalchemy.Column(sqlalchemy.String(10))
    fld = sqlalchemy.Column(sqlalchemy.String(10))

def orm(data,fld):
    
    #Initialisation de SQL Alchemy
    CONNECT_INFO = 'mssql+pyodbc://hogehoge'
    engine = sqlalchemy.create_engine(CONNECT_INFO, encoding='utf-8')

    #Créer une session
    Session = sqlalchemy.orm.sessionmaker(bind=engine)
    session = Session()

    #Avec ou sans fonction d'échantillonnage aléatoire
    if data["containsSampledData"]:
       rsf=1
    else:
       rsf=0
    cnt=data["totalResults"]
    print(ref)

    #Insérez les enregistrements dans le tableau un par un par traitement en boucle
    if cnt!=0: 
       for i,n in enumerate(data["rows"]): 
           print(i)
           if fld.find("source")!= -1: 
               myobject = Hogega_tmp(y=n[0],m=n[1],d=n[2],dim4=n[3],pv=n[4]
                                     rsf=rsf,fld=fld)
       
           session.add(myobject) #Insérer une ligne
           if fld.find("source")!= -1 and i>=24: #Nombre limité d'insertions
                  break
       session.commit() #commettre
    session.close() #Clôture de la session

Note) Dans ce qui précède, par exemple, supposons une scène dans laquelle le résultat de l'exécution de l'API de Google Analytics est stocké dans SQL Server.

ex2) Insérez plusieurs enregistrements dans une table arbitraire (Partie 2)

Ce n'est pas cool de répéter l'insertion de ligne une par une, ou même avec SQL, plusieurs données peuvent être insérées avec une instruction Insert, donc le script suivant a cherché à voir si cela pouvait être réalisé avec Sqlalchemy.

sql_insert_new.py



def orm2(data,fld):
    
    #Initialisation de SQL Alchemy
    CONNECT_INFO = 'mssql+pyodbc://hogehoge'
    engine = sqlalchemy.create_engine(CONNECT_INFO, encoding='utf-8')

    #Créer une session
    Session = sqlalchemy.orm.sessionmaker(bind=engine)
    session = Session()

    #Avec ou sans fonction d'échantillonnage aléatoire
    if data["containsSampledData"]:
       rsf=1
    else:
       rsf=0


    clm =["y","m","d","dim4","pv","rsf","fld"]
    ex=[rsf,fld]
    cnt=data["totalResults"]

    if cnt!=0: 
       rws = data["rows"]   
       if fld.find("source")!= -1: 
          rws = rws[:25] #Nombre limité d'insertions

       #Insérer une ligne
       lst = [dict(zip(clm,r+ex)) for r in rws ] #génération de clause de valeur
       ins_statement = Hogega_tmp.__table__.insert().values(lst)
       session.execute(ins_statement)   
       session.commit()
       session.close()

Supplément

Si vous écrivez la «liste contenant plusieurs dictionnaires» suivante dans la partie argument (lst) de l'instruction Insert, vous pouvez regrouper plusieurs données sans répéter le processus d'insertion une par une dans la boucle for. Il semble que vous puissiez insérer une ligne de tableau avec. (Autrement dit, cela correspond à la clause Values de "Insert Into ... Values ..." en SQL)

sql_insert_apdx1.py


[{y:2016,m:5,d:1,dim4:yahoo,pv:100},
 {y:2016,m:5,d:1,dim4:google,pv:200},
    ...
 {y:2016,m:5,d:1,dim4:smartnews,pv:300}]

Dans le sql_insert_new.py ci-dessus, lst dans la notation d'inclusion de liste devient l'image suivante lorsque la signification du traitement est décomposée.

sql_insert_apdx2.py


lst = list()
for r in rws:
    vle = r+ex
    y = dict(zip(clm,vle)
    lst.append(y)

(Vle correspond à la valeur stockée dans la table, clm correspond au nom de la colonne de la table, et ces deux séquentiels sont répertoriés par ZIP () et convertis en dictionnaire de type y, et le processus de les ajouter séquentiellement à la liste lst est répété dans une boucle for. Sens)

Recommended Posts

Traitement des insertions de table DB à l'aide de sqlalchemy
Paramètres de base de données lors de l'utilisation de Django + SQLAlchemy + Alembic
Comment lire les définitions de table générées dynamiquement à l'aide de SQL Alchemy
Retour en utilisant le processus gaussien
Définition de table dans SQL Alchemy
Conseils de définition de table sqlalchemy
Rechercher la table à l'aide de sqlalchemy et créer un dictionnaire
Générer des définitions de table SQL Alchemy à partir d'un serveur MySQL existant à l'aide de sqlacodegen
Régression de processus gaussien utilisant GPy
Obtenez la table dynamiquement avec sqlalchemy
Migration SQLAlchemy + DB par Alembic
Essayez d'utiliser SQLAlchemy + MySQL (partie 1)
Essayez d'utiliser SQLAlchemy + MySQL (partie 2)
Traiter sur GPU en utilisant chainer.cuda.elementwise