Discussion :

[dedalios]

Bonjour

Dans ce code la lecture du fichier csv charge a chaque enregistrement la Base Python

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 # coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import datetime
import csv
import os
import encodings
from unidecode import unidecode
from codecs import open
 
def convertie_date(src):
    if src =='NULL':
        valid_date = None
    else:
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[4:6]) 
        alpha_jj =  int(src[6:8]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
            return None
pass  
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
def Estce_nombreNull(src):
    if src =='NULL':
        return  None
    else:
        return int(src)    
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'')
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
 
 
class vls_actes(object):
 
    def __init__(self,liste):
 
        self.ACT_CODE = EstceNull(liste[0]);
        self.ACT_LIBELLE = EstceNull(liste[1]);
 
    def __str__(self):
        resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
        resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
        return  resultat
 
    def table_sqllite(self,Base):
        creer_table  = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255) NOT NULL,
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
        );
        """ 
 
        detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
 
        curseur =  Base.cursor() # appel au curseur
 
        # supprimer table existante
        if(detruire_table !=""):
            try:
                curseur.execute(detruire_table)  
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                Base.rollback()
            else:
              Base.commit()    
 
        pass       
        if(creer_table !=""):
            print("creer base")
            try:
                curseur.execute(creer_table)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"++ creer_table )  
                Base.rollback()
            else:
              Base.commit()    
        pass
 
    def insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        if(self.ACT_CODE == '9BFC1'):
            print(data)     
        rq = """       INSERT INTO vsl_actes
                        (ACT_CODE, ACT_LIBELLE)
                           VALUES(?, ?);"""
 
        try:
            curseur.execute(rq,data)
 
        except sqlite3.Error as e:
            print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
            print(rq)
            Base.rollback()
        else: 
            Base.commit()  
 
def actes(nomfichier,Base):
 
    file = open(nomfichier,  encoding='utf8')
    i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
    #
    # Ouverture du fichier source.
    #
    try:
        #
        # Cr�ation du ''lecteur'' CSV.
        #
        fichier_lu = csv.reader(file, 'excel-fr')
 
        max_long_ACT_CODE = 0
        max_long_ACT_LIBELLE = 0
        for row in fichier_lu:
            i+=1
 
            if(i>1):
                nouvel_acte = vls_actes(row)  
 
                if(i==2): # Suppprsseion de la table precedente  si besion 
                    # creation de la nouvelle table 
                    nouvel_acte.table_sqllite(Base)
                # insertion de donnees
                nouvel_acte.insertion_sqllite(Base)
 
                if(max_long_ACT_CODE < len(nouvel_acte.ACT_CODE)):
                     max_long_ACT_CODE = len(nouvel_acte.ACT_CODE)
 
                if(max_long_ACT_LIBELLE < len(nouvel_acte.ACT_LIBELLE)):
                     max_long_ACT_LIBELLE = len(nouvel_acte.ACT_LIBELLE)
 
        #print(max_long_ACT_CODE, end='\n' )
        #print(max_long_ACT_LIBELLE , end='\n')
    except OSError:
            print("Problème d'access au fichier :" + nomfichier)
    finally:
        #
        # Fermeture du fichier source
        #
        file.close()     
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupres du module csv
    encodage ="utf-8"
    LaBase ="nombase2.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    actes("actes.csv" , Base)
 
    Base.close()

Problème j'ai 15 fichiers de ce type a convertir dans une seule base de données .
Les structures de base sont pour chaque cas specifique.
mais sur ce moèle j'ai creer 5 tables ( et les autres sont en ours de finalisation).

Pour autant avec autant de donnée a charge la fait de réaliser l'insertion dans la base cela duree 1h30.
le plus gros fichier fait 1250ko et les autres 5ko.

Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert .

je me demande quelle solution est la plus pertinante.

modifier la classe: class vls_GTs(object):
pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.

[wiztricks]

Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert.

Pour faire çà, il faut avoir des listes de tuples et utiliser executemany

je me demande quelle solution est la plus pertinante.

modifier la classe: class vls_GTs(object):
pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.

Tant que vous alimentez executemany en tuples, ranger votre code en class (ou pas), c'est pas çà qui fera le boulot...

- W

[dedalios]

bonjour ,

mon idee est de découper la class vsl_actes en 2parties.
creer une class bd_actes
qui charge un objet vls_actes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class vls_actes(object):
 
    def __init__(self,liste):
 
        self.ACT_CODE = EstceNull(liste[0]);
        self.ACT_LIBELLE = EstceNull(liste[1]);
 
    def __str__(self):
        resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
        resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
        return  resultat
 
...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class bd_actes(object):
  les_actes = vls_actes[]
    def __init__(self,liste):

Charger les donnees du fichier lu dans un objet bd_actes via des append(x)

puis transferrer les donnees à la base pour bloc.

Classe ou pas, en fait c'est plus pour améliorer ma compréhension du monde objet.

[wiztricks]

mon idee est de découper la class vsl_actes en 2parties.
creer une class bd_actes qui charge un objet vls_actes

Si vous voulez allez vite, difficile de passer à côté d'executemany...
Et pour passer par là, il faut commencer par respecter/s'aligner avec l'interface proposée....
Ce qui réduit les options qu'on peut (imaginer) avoir.

- W

[dedalios]

Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import datetime
import csv
import os
import encodings
 
from codecs import open
 
def convertie_date(src):
    if src =='NULL':
        valid_date = None
    else:
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[4:6]) 
        alpha_jj =  int(src[6:8]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
            return None
pass  
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
def Estce_nombreNull(src):
    if src =='NULL':
        return  None
    else:
        return int(src)    
 
class ExcelFr(csv.excel):
    # Séparateur de champ
    delimiter = ";"
    # Séparateur de ''chaîne''
    quotechar = None
    # Gestion du séparateur dans les ''chaînes''
    escapechar = None
    doublequote = True
    # Fin de ligne
    lineterminator = "\r\n"
    # Ajout automatique du séparateur de chaîne (pour ''writer'')
    quoting = csv.QUOTE_NONE
    # Ne pas ignorer les espaces entre le délimiteur de chaîne
    # et le texte
    skipinitialspace = False 
 
 
class vls_actes(object):
 
    def __init__(self,liste):
 
        self.ACT_CODE = EstceNull(liste[0]);
        self.ACT_LIBELLE = EstceNull(liste[1]);
 
    def __str__(self):
        resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
        resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
        return  resultat
 
    def insertion_sqllite(self,Base):
 
        curseur = Base.cursor() # appel au curseur
        data=[self.ACT_CODE,self.ACT_LIBELLE]
 
        rq = """       INSERT INTO vsl_actes
                        (ACT_CODE, ACT_LIBELLE)
                           VALUES(?, ?);"""
 
        try:
            curseur.execute(rq,data)
 
        except sqlite3.Error as e:
            print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
            print(rq)
            Base.rollback()
        else: 
            Base.commit()  
 
class Les_Actes(object):
    def __init__(self,Nomfichier,Base):
        self.Les_Actes=[]
        self.Nomfichier=Nomfichier
        self.Base=Base
        file = open(self.Nomfichier,  encoding='utf8')
        i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
        #
        # Ouverture du fichier source.
        #
        try:
            #
            # Cr�ation du ''lecteur'' CSV.
            #
            fichier_lu = csv.reader(file, 'excel-fr')
 
            max_long_ACT_CODE = 0
            max_long_ACT_LIBELLE = 0
            for row in fichier_lu:
                i+=1
 
                if(i>1):
                    nouvel_acte = vls_actes(row)  
                    self.Les_Actes.append(nouvel_acte) 
 
        except OSError:
            print("Problème d'access au fichier :" + self.Nomfichier)
        finally:
            #
            # Fermeture du fichier source
            #
            file.close()             
 
    def __str__(self):  
        resultat =""
        for actes in self.Les_Actes:
            if(actes ==""):
                resultat = str(actes)
            else:
                resultat += "/n" + str(actes)
        return resultat
 
    def table_sqllite(self,Base):
        creer_table  = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255) NOT NULL,
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
        );
        """ 
 
        detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
 
        curseur =  Base.cursor() # appel au curseur
 
        # supprimer table existante
        if(detruire_table !=""):
            try:
                curseur.execute(detruire_table)  
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                Base.rollback()
            else:
                Base.commit()    
 
 
        if(creer_table !=""):
            print("creer base")
            try:
                curseur.execute(creer_table)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ creer_table )  
                Base.rollback()
            else:
                Base.commit()    
 
        index_table =""" CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""       
        if(index_table !=""):
            try:
                curseur.execute(index_table)
 
            except sqlite3.Error as e:
                print("Problème de creation d'index : "  +   e.args[0]  + "/n" )  
                print(index_table)
                Base.rollback()
            else: 
                Base.commit()      
 
 # self.GEL_CODE = self.GEL_CODE[7:12]
        pass
 
    def insertion_sqllite(self,Base):
        for actes in self.Les_Actes:
            # insrtion
 
            curseur = Base.cursor() # appel au curseur
 
            data=[actes.ACT_CODE,actes.ACT_LIBELLE]
 
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
 
            try:
                curseur.executemany(rq,data)
 
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                print(data)
                Base.rollback()
            else: 
                Base.commit() 
 
 
 
if __name__ == '__main__':
    # Enregistre ce dialecte aupr�s du module csv
    encodage ="utf-8"
    LaBase ="actes.sq3" 
    Base = sqlite3.connect(LaBase)
    csv.register_dialect('excel-fr', ExcelFr())
 
    traiter_actes =  Les_Actes("actes.csv" , Base)
    traiter_actes.table_sqllite(Base)
    traiter_actes.insertion_sqllite(Base)
 
    Base.close()

[wiztricks]

Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code

Certes mais y-a-t-il une question en rapport avec le sujet?

- W