Convertion csv vers python

Version imprimable

Bonjour

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

Code:

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.

02/04/2018, 16h34
wiztricks

Citation:

Envoyé par dedalios

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

Citation:

Envoyé par dedalios

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

idee

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:

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:

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.

03/04/2018, 11h19
wiztricks

Citation:

Envoyé par dedalios

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

reflexion

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

Code:

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()

04/04/2018, 14h15
wiztricks

Citation:

Envoyé par dedalios

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

voila 2 version du code avec 2 erreurs

voici les codes .
sur le principe je lis un fichiercsv .
je transfert les donnees pour appliquer divers correction à un objet de type vls_actes qui est le reflet de la base de donne a produire
chaque lecture charge aussi une liste d'un objet de type Les_Actes(object) qui contient une liste d'objet self.Les_Actes de type vls_actes
hormis la denommination qui pourrait etre différentié entre

le nom de la class Les_Actes(object) et la vauer self.Les_Actes de ce meme objet . Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas

Code:

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()

Problème :Incorrect number of bindings supplied. The current statement uses 2, and there are 5 supplied.
sur commande d'insertion

INSERT INTO vsl_actes
(ACT_CODE, ACT_LIBELLE)
VALUES(?, ?);
data= ['9BLA6', '9BLA6']

Code:

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
219
220
# 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 =  actes.ACT_CODE  +"/" + actes.ACT_LIBELLE
            else:
                resultat += "\n" + actes.ACT_CODE  +"/" + actes.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()    
 
 
        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,self.Les_Actes)
 
        except sqlite3.Error as e:
            print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion \n" )  
            print(rq)
 
            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)
    #print(traiter_actes)
    traiter_actes.insertion_sqllite(Base)
 
    Base.close()

lorsque je lance ce 2ieme code problème
creer base
Traceback (most recent call last):
File " actes2.py", line 218, in <module>
traiter_actes.insertion_sqllite(Base)
File " actes2.py", line 196, in insertion_sqllite
curseur.executemany(rq,self.Les_Actes)
ValueError: parameters are of unsupported type

05/04/2018, 08h24
tyrtamos

Bonjour,

Logiquement, executemany devrait avoir en 2ème argument une liste de listes (ou liste de tuples), chaque sous-liste étant appliquée successivement à la requête SQL. En fait, quand l'erreur dit "and there are 5 supplied", il prend chacun des caractères de '9BLA6'.

Salut,

Citation:

Envoyé par dedalios

Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas

Dans votre histoire, il y a un Reader qui lit le fichier CSV et produit des enregistrements qui seront cohérents avec le schéma de la BDD et un Writer qui s'occupe d'écrire ces enregistrements et au milieu un machin qui tire les enregistrements du Reader pour les pousser dans le Writer.

Et si on écrit çà pour voir comment çà marche, çà devrait/pourrait ressembler à:

Code:

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
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), row[1]))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Une fois cette mécanique maîtrisée, "spécialiser" en fonction des différents fichiers et des tables à remplir seront d'autres détails à triturer.

- W

QUid de ce code

Que veulent dire ces parties du code ?

Code:

1
2
3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')

Code:

1
2
3
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)

:memory: la base sql est en mémoire , pas de conservation poste traitement ?

Code:

1
2
3
4
5
6
7
8
9
 
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             )

il s'agit d'une simulation du fichier csv?

Code:

StringIO(actes)

06/04/2018, 08h16
wiztricks
Salut,
Citation:
Envoyé par dedalios

Code:

1 2 3 class Writer: def __init__(self, path=':memory:'): cnx = self._cnx = sqlite3.connect(path)

:memory: la base sql est en mémoire , pas de conservation poste traitement ?
Est-ce que vous avez essayé avec un fichier?

Je trouve qu'il est plus simple de commencer avec "tout en mémoire", histoire de repartir d'un état "clean" lors des premières mises au point. De même qu'il est plus simple de partir d'un exemple de fichier CSV de quelques lignes.

L'objectif étant d'illustrer le découpage des traitements entre Reader et Writer et l'utilisation d'executemany (et la construction de listes de tuple), y a-t-il besoin de plus?
Citation:
Envoyé par dedalios

Que veulent dire ces parties du code ?

Code:

1 2 3 from collections import namedtuple record = namedtuple('record', 'code, libelle')
collections et io sont des bibliothèques standards. Il suffit d'ouvrir la documentation pour voir ce que c'est.

- W
07/04/2018, 21h37
dedalios

Malheureusement cela n'est pas toujours possible ,définition des données non existante.
Double enregistrement sur les fichiers...

mais merci pour ces infors
07/04/2018, 22h23
wiztricks

Citation:

Envoyé par dedalios

Malheureusement cela n'est pas toujours possible définition des données non existante.
Double enregistrement sur les fichiers...

Qu'est ce qui n'est pas possible? Utiliser executemany? Faire un brouillon de code avec des données significatives pour s'assurer que le code qui est derrière saura les traiter? Découper les activités en Reader et Writer?

- W

pourquoi la cle prmaire régit elle

bonjour

J'ai reprise ce code et j'ai ajouter

Code:

1
2
3
 
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))

ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information

donc afin que le derniere enregsitrement ne soit pas chargé dans records

Code:

1
2
             '4 ddd\n'
             '4 ddd\n'

LE CODE COMPLET

Code:

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
 
 
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists
            actes(code integer, libelle text ,  
            CONSTRAINT code_pk PRIMARY KEY(code));''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '4 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

mais voila

Code:

1
2
3
4
5
6
7
8
 Traceback (most recent call last):
  File "\src\csvconv.py", line 63, in <module>
    load(Reader(StringIO(actes)), writer)
  File "\src\csvconv.py", line 49, in load
    writer.write(records)
  File "\src\csvconv.py", line 37, in write
    self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
sqlite3.IntegrityError: UNIQUE constraint failed: actes.code

10/04/2018, 08h38
wiztricks
Salut,
Citation:
Envoyé par dedalios

J'ai reprise ce code et j'ai ajouter

Code:

1 2 3 if(record(int(row[0]), row[1]) not in records): records.append(record(int(row[0]), row[1]))

ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information
Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

- W

Citation:

Envoyé par wiztricks

Salut,

Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

- W

Le code complet est poste dans ma demande.
J'ai fait des tests primaires avec les listes simples ou de tuples. Le IN ou sont contraire NOT IN pour vérifier la présence d'un éléments tuple ou autre dans une liste cela fonctionne .
il n'y a aucun problème a tester l'existant d'un tuple dans une liste de tuple .

voici le cas de test primaires
Code:

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 from collections import namedtuple enregistrement = namedtuple('enregistrement', 'code, libelle') type_enregistrement = enregistrement(15,"coucou") print(type_enregistrement.code ) print(type_enregistrement.libelle) z1, z2 = type_enregistrement print(z1) print(type_enregistrement[0] ) print(type_enregistrement[1] ) liste_enr =[] liste_enr.append( enregistrement(15,"coucou") ) liste_enr.append( enregistrement(1,"dodo") ) liste_enr.append( enregistrement(2,"KKK") ) if enregistrement(1,"dodo") not in liste_enr: liste_enr.append( enregistrement(1,"dodo") ) if enregistrement(1,"dodo") not in liste_enr: liste_enr.append( enregistrement(2,"KKK")) for cas in liste_enr: print(cas) if enregistrement(1,"dodo") in liste_enr : print("oui") else: print("non")
et le retour des print
Code:

1 2 3 4 5 6 7 8 9 15 coucou 15 15 coucou enregistrement(code=15, libelle='coucou') enregistrement(code=1, libelle='dodo') enregistrement(code=2, libelle='KKK') oui

10/04/2018, 13h43
wiztricks

Citation:

Envoyé par dedalios

Le code complet est poste dans ma demande

Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

- W
10/04/2018, 14h33
dedalios

Citation:

Envoyé par wiztricks

Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

- W

Effectivement la solution de charger dans une liste de l'intégralité des enregistrements du fichier csv sous forme de tuple pour pouvoir utiliser le mécanisme d' insertion via executemany oblige a chercher une solution soit de suppression des doublons soit de non chargement des tuples csv dans la liste intémédiaire.

Je peux faire en sorte de traiter l'insertion sql d'utiliser les exception pour traiter les blocages de type "sqlite3.IntegrityError: UNIQUE constraint failed: " pour exclure ces cas.

une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:.
rejet t'il l'intégralité des données ou uniquement les enregistrements en échecs ?

et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.
10/04/2018, 15h24
wiztricks

Citation:

Envoyé par dedalios

une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:..

Ce n'est pas si compliqué de tester... mais vous n'allez pas gérer l'erreur pour préférer INSERT OR IGNORE ou INSERT OR REPLACE i.e. laisser faire le boulot au SGDB.

Citation:

Envoyé par dedalios

et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.

Partez du principe que "not in" fonctionne... (sinon non seulement çà se saurait mais pas grand monde développerait avec Python).
A partir de là, le soucis est dans votre code.
Relisez le autant de fois que nécessaire, ajouter y des "print",.... pour trouver et comprendre pourquoi.

- W

Voici le code d'origine

Code:

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
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=1):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), row[1]))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             '6 ddd\n'
             '15 eeee\n'
             '2 bbb\n'
             '33 qqq\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

et voici le code modifi

Code:

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=2):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
 
 
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists
            actes(code integer, libelle text ,  
            CONSTRAINT code_pk PRIMARY KEY(code));''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        print(records)
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '4 ddd\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Quelles sont les modifications ;

La table sql la notion de

Code:

CONSTRAINT code_pk PRIMARY KEY(code) :

Hors volontairement les donnees inserer contiennent des doubles.

Afin de ne pas charger de données en double dans la liste records j'ai modifié cette classe
Déjà la lecture des données ce fait 1 ligne par 1 ligne .
puis j'ai conditionné le chargement de "records" en cherchant a vérifier si le tuple record existait ou pas dans la liste "records"
Mais visiblement je dommandej l'intégration des données via insert sql me signale qu'il ne pas pas inserer de donnée en doublesur la cle primaire alors que pour moi nous ne devrions pas avoir de donnée en double dans cette liste.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=1):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                if(record(int(row[0]), row[1]) not in records):
                    records.append(record(int(row[0]), row[1]))
                
                
        except StopIteration:
            pass
        except:
            raise
        return records

10/04/2018, 21h05
wiztricks

Citation:

Envoyé par dedalios

Déjà la lecture des données ce fait 1 ligne par 1 ligne .
puis j'ai conditionné le chargement de "records" en cherchant a vérifier si le tuple record existait ou pas dans la liste "records"

Si vous aviez la curiosité de faire un print de records juste avant l'insertion en base, vous verriez que votre modification ne sert à rien car records contient au plus 2 lignes.

Après, la solution (que je préfère plutôt maintenir le tas de records qui ont déjà été écrit) est de regarder ce que sait faire sqlite côté INSERT pour gérer cela i.e. modifier la requête SQL ''insert into actes(code, libelle) values(?,?)''' mais en connaissance de cause (et poser des questions dans un forum base de données).

- W

Solution

Bonjour voici la solution -Est-ce la meilleur ?
je vais tester sur des volumes plus important

Code:

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
record = namedtuple('record', 'code, libelle')
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=3):
        records = []
        try:
            for _ in range(count): #injection par groupe de 3 lignes et vérifier les doublons
                row = next(self._reader)
                # on construit les tuples 
                enregistrement = record(int(row[0]), EstceNull(row[1]))
                # on vérifie les doubles  
                if(enregistrement  not in records):
                    records.append(enregistrement)
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists actes;  ''' 
 
        try:
            cnx.execute(commandesql)   
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()      
 
        commandesql =    '''create table if not exists
                actes(code integer, libelle text ,  
                CONSTRAINT code_pk PRIMARY KEY(code));'''
 
        try:
            cnx.execute(commandesql)  
        except sqlite3.Error as e: 
            print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ commandesql )
            self._cnx.rollback()
        else:
            self._cnx.commit()        
 
 
    def writesmany(self, records):
        with self._cnx:
            try:
                self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                print("\t"  +str(records))
                self._cnx.rollback()
                # dans le cas d'un problème d'injection multipls on repasse à la mono injection au cas par cas
                # et on laisse les mécasnisme de sécurite de la base agir
                self.writemono( records)
            else: 
                self._cnx.commit()
 
    def writemono(self, records):
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute('''insert into actes(code, libelle) values(?,?)''', enregistrement)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
 
                    print("\t"  +str(enregistrement))
                    self._cnx.rollback()
                else: 
                    self._cnx.commit()
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
 
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        print(records)
        if not records: break
        writer.writesmany(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '4 ddd\n'
             '5 eeeeee\n'
             '6 fefeefe\n'
             '3 ccc\n'
             '3 ccc\n'
             '101 xxxx\n'
             '9 NULL\n'
             '111 NULL\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Le résultat des print

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[record(code=1, libelle='aaa'), record(code=2, libelle='bbb'), record(code=3, libelle='ccc')]
[record(code=4, libelle='ddd'), record(code=5, libelle='eeeeee')]
[record(code=6, libelle='fefeefe'), record(code=3, libelle='ccc')]
Problème :UNIQUE constraint failed: actes.code sur commande d'insertion /n
	[record(code=6, libelle='fefeefe'), record(code=3, libelle='ccc')]
Problème :UNIQUE constraint failed: actes.code sur commande d'insertion /n
	record(code=3, libelle='ccc')
[record(code=101, libelle='xxxx'), record(code=9, libelle=None), record(code=111, libelle=None)]
[]
(1, 'aaa')
(2, 'bbb')
(3, 'ccc')
(4, 'ddd')
(5, 'eeeeee')
(6, 'fefeefe')
(9, None)
(101, 'xxxx')
(111, None)

Principe la classe reader charge la liste records de 3 tuples extrait du "fichier" en mémoire.

Code:

def get_records(self, count=3):

Traite et effectue les convertions des données du "fichier" en mémoire en tuple .
Il injecte ce tuple dans la liste "records" en vérifiant sur s'il n'est pas déjà présent.

La classe write s'occuper de la base de donneés
Elle construit et charge la base.
les insertions par defaut sont faite via une commande executemany (writesmany)
mais si la base retour une impossibilité d'insertion
on charge les donnees à l'unite (writemono) avec la même sécurité sur le processus d'insertion

Citation:

Envoyé par dedalios

Bonjour voici la solution -Est-ce la meilleur ?

En ce qui me concerne, je pense vous avoir déjà répondu et suggéré d'ouvrir la documentation de sqlite3 pour étudier les options à ajouter à INSERT dans ce cas.
Ce qui permettrait de traiter les doublons en ne modifiant qu'une seule ligne du code initial.

Après si vous voulez faire çà en testant, s'il y a des doublons (sans le tester sur tous les enregistrements) puis en gérant les IntegrityError de l'INSERT de base (le test précédent ne servant à rien)... c'est comme vous voulez mais c'est pas la peine de demander si c'est "le meilleur".

Pour info:
Code:

1 2 3 4 5 6 7 record = namedtuple('record', 'code, libelle') def EstceNull(src): if src =='NULL': return None else: return src
s'écrit aussi:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> class record(namedtuple('record', 'code, libelle')): ... def __new__(cls, code, libelle): ... if libelle == 'NULL': ... libelle = None ... return super().__new__(cls, code, libelle) ... >>> record(1, 'NULL') record(code=1, libelle=None) >>> record(1, 'NULA') record(code=1, libelle='NULA') >>>
- W

11/04/2018, 13h40
dedalios

SQL et INSERT
A ma connaissance en base de donnée dans une insertion multi enregistrement le rollback invalide l'insertion du bloc complet d'instruction et ne fait pas de différence entre le fait que tout ou partie des enregistrements ne soit valide ou pas.

S'il existe une clé primaire sur code dans la table actes alors
Code:

1 2 3 4 5 6 insert into actes(code, libelle) values( (10,"xxx") , (11,"xxx") , (12,"xxx") , (10,"xxx") , (10,"xxx") );
l'intégralité de la requêtes sql est rejeté pour une anomalie de clé primaire.

Je suppose que concernant l'utilisation d'un fichier , il suffirait de modifier la commande

Code:

load(Reader(StringIO(actes)), writer)

pour

Code:

load(Reader("monfichier.csv" ), writer)

pour autant je me demande comment faire pour ne pas traiter le première enregistrement du fichier csv...
11/04/2018, 14h09
wiztricks
Citation:
Envoyé par dedalios

Code:

1 2 3 4 5 6 insert into actes(code, libelle) values( (10,"xxx") , (11,"xxx") , (12,"xxx") , (10,"xxx") , (10,"xxx") );
Allez je vous redonne la page de la documentation d'INSERT sur sqlite3 à lire (les autres SGDB implémentent cela autrement).

Citation:

Envoyé par dedalios

Je suppose que concernant l'utilisation d'un fichier , il suffirait de modifier la commande

Code:

load(Reader(StringIO(actes)), writer)

pour

Code:

load(Reader("monfichier.csv" ), writer)

pour autant je me demande comment faire pour ne pas traiter le première enregistrement du fichier csv...

Vous pouvez le faire pour tous les fichiers de façon arbitraire; en fonction de votre connaissance du fichier en ajoutant un paramètre genre skip=n qui jette les n premières lignes; ou en réalisant une heuristique qui s'amuse à détecter si la première ligne est une en-tête et alors la sauter...
De toutes façons, puisque vous allez faire des conversions ou des tests d'intégrité vous devez avoir des informations sur le type de donnée de chaque colonne ne serait-ce que pour pousser des tuples correct vis à vis du schéma de la table: s'il y a des colonnes contenant autre chose que des chaînes de caractères, une heuristique basique est facile à réaliser.

Et si vous ne vous en sortez pas, il serait temps d'ouvrir un nouvelle discussion car le sujet de celle-ci étant:

Citation:

Envoyé par dedalios

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

çà fait longtemps qu'on y a répondu.

- W

Curieuse effet

CAS N°1

Code:

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
 
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
record = namedtuple('record', 'code, libelle')
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=5):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), EstceNull( row[1])))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert or ignore into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             '6 ddd\n'
             '15 eeee\n'
             '2 bbb\n'
             '33 qqq\n'
             '15 NULL\n'
             '2 bbb\n'
             '33 qqq\n'
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

CAN°2

Code:

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
# coding: utf-8  
import csv
import sqlite3
from collections import namedtuple
 
def EstceNull(src):
    if src =='NULL':
        return  None
    else:
        return src
 
class record(namedtuple('record', 'code, libelle')):
    def __new__(cls, code, libelle):
        if libelle == 'NULL':
            libelle = None
            return super().__new__(cls, code, libelle)
 
class Reader:
    def __init__(self, file):
        self._reader = csv.reader(file, delimiter=' ')
 
    def get_records(self, count=5):
        records = []
        try:
            for _ in range(count):
                row = next(self._reader)
                records.append(record(int(row[0]), row[1]))
        except StopIteration:
            pass
        except:
            raise
        return records
 
 
class Writer:
    def __init__(self, path=':memory:'):
        cnx = self._cnx = sqlite3.connect(path)
        cnx.execute('''create table if not exists actes(code integer, libelle text);''')
 
    def write(self, records):
        with self._cnx:
            self._cnx.executemany('''insert or ignore into actes(code, libelle) values(?,?)''', records)
 
    def dump(self):
        with self._cnx:
            for row in self._cnx.execute('select * from actes'):
                print (row)
 
def load(reader, writer):
    while 1:
 
        records = reader.get_records()
        if not records: break
        writer.write(records)
 
 
if __name__ == '__main__':
    from io import StringIO
 
    actes = ('1 aaa\n'
             '2 bbb\n'
             '3 ccc\n'
             '4 ddd\n'
             '5 ddd\n'
             '6 ddd\n'
             '15 eeee\n'
             '2 bbb\n'
             '33 qqq\n'
             '15 NULL\n'
             '2 bbb\n'
             '33 qqq\n'
 
 
             )
 
    writer = Writer()
    load(Reader(StringIO(actes)), writer)
    writer.dump()

Si je comprends tes propos le résultat devrait être identique?

la class record ce chargeant de la convertion du texte 'NULL' en valeur None

11/04/2018, 22h35
wiztricks

Je vois que vous vous êtes enfin décidé à ouvrir la documentation de sqlite3...

Citation:

Envoyé par dedalios

Si je comprends tes propos le résultat devrait être identique?

Voilà. Sauf que, vu l'indentation que vous avez mis à la ligne 16 le code n°2 doit se vautrer (ce que vous pourriez signaler)... Et c'est ce qu'il se passe lorsqu'on ne comprends pas le code qu'on recopie.

L'idée est de pousser dehors tout ce qui concerne la construction de "record" à partir de la "row" récupérée par le Reader du CSV. Le boulot du Reader est juste de faire des paquets de "records". Si on l'encombre de ce détail, on aurait autant de Reader que de fichiers CSV. Ce qui n'est pas malin.

Et si vous ne vous en sortez pas, ouvrez une nouvelle discussion.

- W

Oui je vois l'indentation du return est mal placé il se retrouve intégé au IF et donc si le test de la valeur "NULL" n'est pas validé la fonction ne retourne aucune valeur

Code erroné
Code:

1 2 3 4 5 class record(namedtuple('record', 'code, libelle')): def __new__(cls, code, libelle): if libelle == 'NULL': libelle = None return super().__new__(cls, code, libelle)
code correcte
Code:

1 2 3 4 5 class record(namedtuple('record', 'code, libelle')): def __new__(cls, code, libelle): if libelle == 'NULL': libelle = None return super().__new__(cls, code, libelle)
Citation:

Le boulot du Reader est juste de faire des paquets de "records"

par contre il nest pas la pour charger les données d'un fichier extrerne il faut un autre mécanisme