[PYTHON] 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)