Passe de SQLiite3 a Postgre 10

Version imprimable

Bonjour

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
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
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import csv
import os
import encodings
from collections import namedtuple
from src.convertie import *
 
 
class record(namedtuple('record', 'ACT_CODE, ACT_LIBELLE')):
    def __new__(cls, row):
        if row[0] == 'NULL':
            record.ACT_CODE = 'NULL'
        if   row[1] == 'NULL': 
             record.ACT_LIBELLE = 'NULL'
        return super().__new__(cls, *row)
 
class Writer:
    def __init__(self, path):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists vsl_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 vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_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()            
 
        commandesql = """CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""      
 
        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):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
        with self._cnx:
            try:
                self._cnx.executemany(rq, 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):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
 
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, 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 vsl_actes'):
                print (row)
 
class vsl_acte(object):
    def __init__(self, nomfichier , base):
 
        self.nomfichier = nomfichier
        self.base = base
        print('Injection ' + self.nomfichier +' sur la base ' + self.base  )
        writer = Writer(self.base )
        with open(self.nomfichier   , encoding='utf-8') as file:
            reader = csv.reader(file,'excel-fr')
            reader.__next__() # bypass l'entete du fichier
            packer = Packer(reader, record)
            i = 1
 
            for records in packer.get_records():
                writer.writesmany(records)
                #print(i, records)
                i += 1         
 
if __name__ == '__main__':
    encodage ="utf-8"
    BaseSQL='BaseVSL.db'
    csv.register_dialect('excel-fr', ExcelFr())
    vsl_acte('actes.csv', BaseSQL )
 
 
 
    #writer.dump()

Dans ce programme c'est une base SQLITE qui est charger hors ce type de base me pose des problèmes et ne retourne pas toujours des informations utilisable.

ainsi il est malheureusement possible de creer de type de table ou la cle d'intégrite est par erreur identique pour des tables sans aucun rapport ce qui me pose divers problème .
J'ai du tenter de migrer mes données de sqlite vers postgre pour détecté ces erreurs de codes.

Code:

1
2
3
4
5
6
7
8
9
10
   commandesql = """CREATE TABLE vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE));"""
 
 
   commandesql = """CREATE TABLE vsl_produit(
           pro_CODE TEXT(255),
           pro_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(pro_CODE ));"""

Pour revenir a ce qui m'interesse je cherhe donc un exemple en français de connection à une base postgre local
mais les moteur de reherche ne m'ont retrouvé que des exemples en langue anglaise.

est-ce que quelqu'un disposerait a minimal un exemple de connection python 3.6 / postgre explicite dans note belle langue française?

20/04/2018, 19h00
wiztricks

Salut,

Citation:

Envoyé par dedalios

Dans ce programme c'est une base SQLITE qui est charger hors ce type de base me pose des problèmes et ne retourne pas toujours des informations utilisable.

Le code que vous montrez charge des tables. Utiliser ces informations et dire quelles ne sont pas utilisables mériterait une illustration pour savoir s'il s'agit d'un soucis sqlite3 (que pas mal de monde utilise et aimerait aussi connaître) ou dans une utilisation particulière (qui mériterait d'être illustrée pour comprendre).

Citation:

Envoyé par dedalios

ainsi il est malheureusement possible de creer de type de table ou la cle d'intégrite est par erreur identique pour des tables sans aucun rapport ce qui me pose divers problème .

La contrainte est aussi associée à la table, donc peu importe qu'elle ait le même nom sauf si quelque chose qui m'échappe.

Citation:

Envoyé par dedalios

J'ai du tenter de migrer mes données de sqlite vers postgre pour détecté ces erreurs de codes.

Pour l'instant, je ne vois pas l'erreur sinon dans le "standard" de codage que vous vous imposez "avoir des noms de contraintes de colonuniques".

Citation:

Envoyé par dedalios

Pour revenir a ce qui m'interesse je cherhe donc un exemple en français de connection à une base postgre local mais les moteur de reherche ne m'ont retrouvé que des exemples en langue anglaise.

Désolé, je n'en connais pas.
Mais ce que vous devez trouver, c'est une documentation PostgreSQL en français (çà existe). Puis choisir un pilote (l'équivalent de la bibliothèque sqlite3). C'est lui qui indiquera comment se connecter à la base. Puis l'utiliser sera proche de ce que vous faites déjà avec Sqlite3, car le pilote doit respecter la même API.
Pour les points de détails, c'est dans la documentation de PostgreSQL (en français) que çà se passe.

Ceci dit, si chaque fois que vous rencontrez un soucis vous changez de canasson (alors qu'il n'est pas évident que çà le mérite) vous n'avez pas fini...

- W

Citation:

Envoyé par dedalios

est-ce que quelqu'un disposerait a minimal un exemple de connection python 3.6 / postgre explicite dans note belle langue française?

Bonjour

Moi j'ai un exemple de programme Python (P2 hélas mais bon les différences avec P3 seront je pense minimes) permettant d'exécuter une requête SQL pour une bdd Postgres

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
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
#!/usr/bin/env python
# coding: utf-8
 
# Programme d'exécution de requête sql
 
# Usage: prog [-h host, --host=host] [-p port, --port=port] [-U user, --user=user] [-P password, --password=password] [-dc, --delim=c] [-x, --explain] [-dbname=bdd] [-?]
#	Option -h, --host=host: Connexion sur le serveur host
#	Option -p, --port=port: Connexion sur le port port
#	Option -U, --user=user: Connexion avec l'utilisateur user
#	Option -P, --password=password: Connexion avec le mot de passe
#	Option -dc, --delim=c: Utilisation du délimiteur "c"
#	Option -x, --explain: Explicitation du résultat
#	Option --dbname=bdd: Connexion sur la dbname bdd
#	Option -?, --help: Utilisation de ce programme
 
# Compatibilité python versions futures
from __future__ import print_function		# Instruction "print" devient fct
from __future__ import unicode_literals		# Toutes chaines en unicode
from __future__ import absolute_import		# Les imports sont en absolu
from __future__ import division				# Les divisions sont réelles
 
# Modules Python
import psycopg2								# Accès PostgreSQL
import psycopg2.extras						# Goodies PostgreSQL
import sys									# Paramètres et fonctions systèmes
import os									# Gestion os
import getopt								# Gestion options Posix
import ConfigParser							# Analyse fichier configuration
 
# Fonction de connexion bdd
def connectBdd(
		*args,								# Liste arguments
		**kwargs):							# Association arguments
 
	# Récupération informations de connexion
	parser=ConfigParser.ConfigParser()
	parser.read(
		os.path.join(
			os.path.dirname(os.path.abspath(__file__)),
			"config.ini",
		)
	)
 
	# Paramètres de connexion
	param={}
	for (key, attrib) in (
		("host", ("host", "PGHOST", "")),
		("port", ("port", "PGPORT", "5432")),
		("user", ("user", "PGUSER", os.getenv("LOGNAME"))),
		("password", ("password", "PGPASSWORD", None)),
		("dbname", ("dbname", "PGDATABASE", os.getenv("LOGNAME"))),
	):
		item=kwargs.pop(key, None)
		param[key]=item\
			if item is not None\
			else parser.get("bdd/connexion", attrib[0]).split("#")[0].strip()\
				if parser.has_option("bdd/connexion", attrib[0])\
				else os.getenv(attrib[1]) or attrib[2]
	# for
 
	# Les sorties sql seront en unicode
	psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
	psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)
 
	# Connexion
	bddId=psycopg2.connect(
		cursor_factory=psycopg2.extras.DictCursor,
		**param
	)
 
	# Récupération des types spécifiques à la bdd
	with bddId.cursor() as curs:
		curs.execute(
			"select distinct object_schema, object_name"
			+ " from information_schema.data_type_privileges"
			+ " where object_type='%s'" % "USER-DEFINED TYPE"
		)
		for res in curs.fetchall():
			psycopg2.extras.register_composite(str("%s.%s" % (res[0], res[1])), bddId)
	# with
 
	return bddId
# connectBdd()
 
if __name__ == "__main__":
	# Fonction "usage"
	def usage():
		print("Usage: %s [-h host, --host=host] [-p port, --port=port] [-U user, --user=user] [-P password, --password=password] [--dbname=bdd] [-x, --explain] [-dc, --delim=c] [-?, --help]" % os.path.basename(__file__))
		print("\tOption -h host, --host=host: Connexion sur le serveur host")
		print("\tOption -p port, --port=port: Connexion sur le port port")
		print("\tOption -U user, --user=user: Connexion avec l'utilisateur user")
		print("\tOption -P password, --password=password: Connexion avec le mot de passe passwird")
		print("\tOption --dbname=bdd: Connexion sur la dbname bdd")
		print("\tOption -dc, --delim=c: Utilisation du délimiteur 'c'")
		print("\tOption -x, --explain: Explicitation du résultat")
		print("\tOption -?, --help: Utilisation de ce programme")
	# usage()
 
	# Gestion des options
	optItem={
		"host" : {
			"opt" : {
				"court" : "h",
				"long" : ("host",),
			},
			"arg" : True,
			"value" : "/tmp",
			"fct" : lambda x, y: y,
		},
		"port" : {
			"opt" : {
				"court" : "p",
				"long" : ("port",),
			},
			"arg" : True,
			"value" : "5432",
			"fct" : lambda x, y: y,
		},
		"user" : {
			"opt" : {
				"court" : "U",
				"long" : ("user",),
			},
			"arg" : True,
			"value" : None,
			"fct" : lambda x, y: y,
		},
		"password" : {
			"opt" : {
				"court" : "P",
				"long" : ("password",),
			},
			"arg" : True,
			"value" : None,
			"fct" : lambda x, y: y,
		},
		"delim" : {
			"opt" : {
				"court" : "d",
				"long" : ("delim",),
			},
			"arg" : True,
			"value" : "|",
			"fct" : lambda x, y: y,
		},
		"explain" : {
			"opt" : {
				"court" : "x",
				"long" : ("explain",),
			},
			"arg" : False,
			"value" : False,
			"fct" : lambda x, y: True,
		},
		"dbname" : {
			"opt" : {
				"court" : "",
				"long" : ("dbname",),
			},
			"arg" : True,
			"value" : None,
			"fct" : lambda x, y: y,
		},
		"help" : {
			"opt" : {
				"court" : "?",
				"long" : ("help",),
			},
			"arg" : False,
		},
	}
	try:
		(optList, args)=getopt.getopt(
			sys.argv[1:],
			"".join(
				"%s%s" % (x["opt"]["court"], ":" if x["arg"] else "")
				for x in optItem.viewvalues()
			),
			tuple(
				"%s%s" % (
					x,
					"=" if y["arg"] else "",
				) for y in optItem.viewvalues() for x in y["opt"]["long"]
			),
		)
	except getopt.GetoptError as eClass:
		print("%s: %s" % (os.path.basename(__file__), eClass))
		usage()
		sys.exit(1)
	# try
 
	for (opt, val) in optList:
		if opt in (
			tuple("-%s" % x for x in optItem["help"]["opt"]["court"])
			+ tuple("--%s" % x for x in optItem["help"]["opt"]["long"])
		):
			usage()
			sys.exit(0)
		# if
		for (k, v) in optItem.viewitems():
			if "fct" not in v.viewkeys() or v["fct"] is None or opt not in (
				tuple("-%s" % x for x in v["opt"]["court"])
				+ tuple("--%s" % x for x in v["opt"]["long"])
			): continue
			need=v["fct"](opt, val)
			try:
				optItem[k]["value"].append(need)
			except AttributeError:
				optItem[k]["value"]=need
		# for
	# for
 
	# Suppression des options de la liste des arguments
	sys.argv=(sys.argv[0],) + tuple(args)
 
	# Connexion bdd
	bddId=connectBdd(
		host=optItem["host"]["value"],
		port=optItem["port"]["value"],
		user=optItem["user"]["value"],
		password=optItem["password"]["value"],
		dbname=optItem["dbname"]["value"],
	)
	print("bddId [%s]" % bddId)
	curs=bddId.cursor()
 
	# Requête
	for arg in sys.argv[1:]:
		curs.execute(arg)
		print(
			"[%s]: (%d rows) (%s)" % (
				arg,
				curs.rowcount,
				type(curs),
			)
		)
		try:
			if optItem["explain"]["value"]:
				for (i, res) in enumerate(curs.fetchall(), 1):
					print(
						"row %d/%d (%.02f%%) (%s) (%s)" % (
							i,
							curs.rowcount,
							i * 100.0 / curs.rowcount,
							type(res),
							", ".join(res.iterkeys()),
						)
					)
					for (k, v) in res.iteritems():
						print("\t%s=[%s] (%s)" % (k, v, type(v)))
					print()
				# for
			else:
				for (i, res) in enumerate(curs.fetchall(), 1):
					print(
						"(row %d/%d %.02f%%) [%s] (%s)" % (
							i,
							curs.rowcount,
							i * 100.0 / curs.rowcount,
							optItem["delim"]["value"].join(unicode(x) for x in res),
							type(res),
						)
					)
				# for
			# if
		except psycopg2.ProgrammingError:
			bddId.commit()
		# try
	# for
 
	# Fermeture bdd
	curs.close()
	bddId.close()
# if

Il utilise un fichier de configuration nommé "config.ini" permettant de ne pas rentrer les paramètres à chaque fois qu'on l'invoque

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#
# Fichier de configuration pour les outils de manipulation bdd
# Ce fichier n'est pas utilisé par l'application
# Ce fichier est uniquement à usage des programmeurs
#
 
# Configuration pour la connexion bdd
[bdd/connexion]
host = /tmp									# Serveur (chemin=socket)
port = 5432									# Port
dbname = ici le nom de ta bdd						# Nom bdd
user = postgres 							# Utilisateur bdd
#password = xxx								# Mot de passe utilisateur (danger)

L'utilisation est assez simple: tu l'appelles en lui passant ta requête SQL. Exemple toto.py "select * from tableX". Il te retourne son résultat à l'écran.
Si tu lui rajoutes l'option "-x", alors il te détaille le retour de chaque ligne (avec le nom de chaque champ de la ligne plus sa valeur ainsi que son type).

Tu peux bypasser les valeurs du fichier "config.ini" en rajoutant les options qui vont bien (exemple toto.py -Uxxx "select * from tableX" => utilisera le user "xxx" pour excuter le select et non le user défini dans le fichier de config).

21/04/2018, 09h55
dedalios

Pourquoi passer sqllite a postgres

Bonjour

Les programmes python convertissant les fichiers d'origine et de format divers (fichier csv, fichier plat avec structure hiérarchique), alimentait au début 2 bases Sqlite, une pour csv une pour les fichiers plats avec structure hiérarchique.
Puis pour des analyses dans une seule base j'ai changé les code python pour l'alimenté qu’une seule base.
Aux finales, il y a plus de 40 tables, pour près de 4go de donnée fichiers.

SQLlite n'est plus une option et je dois utiliser les bases autorisent dont la plus simple à mettre en œuvre est Postgre sur un poste local.
Les personnes autour de moi n'utilisent ni Sqllite ni Python mais en l’occurrence : Java, Postgre , Oracle...
Je ne connais pas assez JAVA pour construire la même chose qu'avec Python. Et Python intégrer des add-on plus simple à mettre en oeuvre que Java.

Autre point si la base doit être accessible a d'autres personnes Sqllite n'est pas la solution la plus adaptée.

Citation:

Citation Envoyé par wiztricks
Le code que vous montrez charge des tables. Utiliser ces informations et dire quelles ne sont pas utilisables mériterait une illustration pour savoir s'il s'agit d’un souci sqlite3 (que pas mal de monde utilise et aimerait aussi connaître) ou dans une utilisation particulière (qui mériterait d'être illustrée pour comprendre).

Citation Envoyé par dedalios Voir le message
Ainsi il est malheureusement possible de creer de type de table ou la cle d'intégrite est par erreur identique pour des tables sans aucun rapport ce qui me pose divers problèmes.

J'ai poste ceci https://www.developpez.net/forums/d1...in-incoherent/ resté sans réponse.

Ce cas de comparaisons de données, un « inner join » entre 2 tables, me retourne des valeurs incohérentes. Comment peut-on avoir en comparant 2 tables via un « inner join » en retour quasiment le nombre d'enregistrement de la plus grande des 2 tables ?
Que même un left join monté pour faire une comparaison similaire à un inner join (voir ce meme post) retourne la même chose.
Et qu'un

Code:

select * from a where code in (select code from b)

(voir ce même post) retourne bien des valeurs plus cohérente à savoir un quantification inférieur à la plus petite des deux tables.

Le chargement des 2 tables via python ne déclenche pas même pas de notification de rejet dans les inserts mais voilà quid du résultat des plus curieux. Est-ce les codes python qui pose problème a priori les 2 programmes ne parte pas en défaut ?
Il faut quand même quelque heure pour charge les 40 tables. Je n'ai pas dans les divers codes python externalisé les logs de rejet des inserts mais si je regarde la console de traitement d’Eclipse utiliser pour lancer les programmes je n'ai aucune erreur python.

Je cherche donc à me pencher sur les données or SQllite ne permet pas de réaliser a priori des Explain plan pour analyser le fonctionnement de l'exécution ce type de requête.

J’ai fait d'autre comparaison de certaine de ces tables avec de bon résultat cohérent jusqu'a ce cas de jointure défaillante.

Autre post sur SQLLITE /POSTGRE en rapport avec ma décision de passer à POSTGRE
https://www.developpez.net/forums/d1.../#post10178931

Utilisation de psycopg2 avec python 3.x

La solution de passer par psycopg2

http://initd.org/psycopg/

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Psycopg - Adaptateur de base de données PostgreSQL pour Python  
 
 
Psycopg est l'adaptateur de base de données PostgreSQL le plus populaire pour le langage de programmation Python . Ses principales caractéristiques sont l'implémentation complète de la spécification Python DB API 2.0 et la sécurité des threads (plusieurs threads peuvent partager la même connexion). Il a été conçu pour les applications fortement multithread qui créent et détruisent beaucoup de curseurs et font un grand nombre de INSERT ou UPDATE simultanés.
 
Psycopg 2 est principalement implémenté en C comme un wrapper libpq , ce qui permet d'être à la fois efficace et sécurisé. Il dispose de curseurs côté client et côté serveur , de communications et de notifications asynchrones , de prise en charge COPY . De nombreux types Python sont pris en charge prêts à l'emploi et adaptés aux types de données PostgreSQL correspondants ; l'adaptation peut être étendue et personnalisée grâce à un système d'adaptation d'objets flexible.
 
Psycopg 2 est à la fois Unicode et Python 3 friendly. 
 
Le paquet psycopg2 est l'implémentation mature actuelle de l'adaptateur: il s'agit d'une extension C et en tant que telle, elle n'est compatible qu'avec CPython . Si vous voulez utiliser Psycopg sur une implémentation Python différente (PyPy, Jython, IronPython), il existe un portage expérimental de Psycopg pour Ctypes , mais il n'est pas encore aussi mature que l'implémentation C. 
 
 
L'implémentation actuelle de psycopg2 prend en charge:
 
    Python 2 versions de 2.6 à 2.7
    Python 3 versions de 3.2 à 3.6
    Versions du serveur PostgreSQL de 7.4 à 10
    Version de la bibliothèque du client PostgreSQL à partir de la version 9.1

reste dans ce code la problème de la commande rejeté

Code:

import ConfigParser # Analyse fichier configuration

J'irais donc voir ceci :
https://deusyss.developpez.com/tutor...configuration/

A minima Il faut cette modification en version python 3

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Modules Python dd
import psycopg2                                # Accés PostgreSQL
import psycopg2.extras                        # Goodies PostgreSQL
import sys                                    # Paramêtres et fonctions systêmes
import os                                    # Gestion os
import getopt                                # Gestion options Posix
#import ConfigParser                            # Analyse fichier configuration
import configparser 
# Fonction de connexion bdd
def connectBdd(
        *args,                                # Liste arguments
        **kwargs):                            # Association arguments
 
    # Récupération informations de connexion
    #parser=configparser.ConfigParser()
    parser=configparser.configparser()


    #parse

je vais voir cette solution (utlisation windows10...)

Salut,

Citation:

Envoyé par dedalios

J'ai poste ceci https://www.developpez.net/forums/d1...in-incoherent/ resté sans réponse.

Ce cas de comparaisons de données, un « inner join » entre 2 tables, me retourne des valeurs incohérentes. Comment peut-on avoir en comparant 2 tables via un « inner join » en retour quasiment le nombre d'enregistrement de la plus grande des 2 tables ?

Pour rassurer ce qui utilisent sqlite3, vos deux requêtes produisent des différences parce que le "join" se fait sur une colonne ou les valeurs ne sont pas uniques.
Exemple, je crée et remplis 2 tables t1, t2:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 >>> import sqlite3 >>> >>> cx = sqlite3.connect(':memory:') >>> cx.execute('create table t1(a integer primary key, b text);') <sqlite3.Cursor object at 0x0000000002883420> >>> cx.executemany('insert into t1 values(?, ?)', ... [(1, 'a'), (2, 'b'), (3, 'c')]) <sqlite3.Cursor object at 0x0000000002883490> >>> cx.execute('create table t2(a integer primary key, b text);') <sqlite3.Cursor object at 0x0000000002883420> >>> cx.executemany('insert into t2 values(?, ?)', ... [(1, 'a'), (2, 'a'), (3, 'c'), (4, 'a'), ]) <sqlite3.Cursor object at 0x0000000002883490> >>> cx.commit() >>>
et dans t2 j'ai créé les enregistrements 1, 2 et 4 qui ont même valeur pour la colonne b..
L'inner join retourne:
Code:

1 2 3 4 >>> row = cx.execute( ('select count(*) from t1 x ' ... 'inner join t2 y on x.b = y.b')) >>> row.fetchone() (4,)
et si çà retourne 4, c'est parce que la condition est vraie pour tous ces enregistrements.
Par contre, si j'écris:
Code:

1 2 3 4 5 >>> row = cx.execute( ('select count(*) from t1 x ' ... 'where x.b in (select y.b from t2 y)')) >>> >>> row.fetchone() (2,)
je passe à travers les doublons en comptant les x.b dans le "(select y.b from t2 y)".

Après si vous voulez que le nom des contraintes soit unique pour sqlite3 comme pour PostgreSQL. Il n'y a peut être que PostgreSQL qui a fait ce choix d'implémentation, si vous le préférez pourquoi pas mais ce ne sont pas de bonnes raisons pour faire de faux procès à sqlite3.

- W

21/04/2018, 18h43
Sve@r

Citation:

Envoyé par dedalios

Comment peut-on avoir en comparant 2 tables via un « inner join » en retour quasiment le nombre d'enregistrement de la plus grande des 2 tables ?

Là on quitte le domaine Python pour rentrer dans celui du SQL.

Déjà, question de terminologie, un "inner join" ne sert pas à comparer 2 tables mais à relier deux tables.
Si par exemple tu as une table de personnes (nom, prenom, adresse) et une table de titres (M., Mme, Mlle) alors tu peux relier les deux via un identificateur. L'identificateur de l'occurence unique venant s'intégrer dans l'autre table. Ici, une personne ne peut avoir qu'un seul titre la relation se lit "une personne n'a qu'un titre" et "un titre peut être associé à n personnes" donc l'identifiant du titre (qui est donc unique pour une personne) vient s'intégrer dans la table "personne". Donc "personne" deviendra (nom, prenom, adresse, id_titre).

Ensuite, on ne cherche pas "la plus grande" des deux tables mais "la table de base de la recherche". Si tu veux toutes les personnes (besoin principal), avec leur titre (besoin annexe) ; alors tu feras une requête sur "personne inner join titre". Si maintenant tu veux les titres présents (besoin principal), et les personnes qui en héritent (besoin annexe) ; alors tu feras une requête sur "titre inner join personne".

Bref la requête doit ressembler au langage naturel...

de faux procès à sqlite3

Citation:

mais ce ne sont pas de bonnes raisons pour faire de faux procès à sqlite3.

je ne fais pas defaux procès à sqlite3 , je ne suis plus supposé l'utiliser.

et concernant la comparaison des 2 tables présenté ici , on est loin du cas présenté dans ce post https://www.developpez.net/forums/d1...in-incoherent/

Ces 2 tables ont des similarités ,la premiere est leur clé Primaire .

Donc soit 2 tables T1 et T2 composé d'une clé primaire "a"

donc pour reprendre le code en exemple
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 # coding: utf-8 ''' @author: ''' import csv import sqlite3 import sys import csv import os cx = sqlite3.connect(':memory:') cx.execute('create table t1(a integer primary key, b text);') cx.executemany('insert into t1 values(?, ?)', [(1, 'a'), (2, 'b'), (3, 'c')]) cx.execute('create table t2(a integer primary key, b text);') cx.executemany('insert into t2 values(?, ?)', [(1, 'a'), (2, 'a'), (3, 'c'), (4, 'a'), ]) cx.commit() row = cx.execute( ('select count(*) from t1 x ' 'inner join t2 y on x.a = y.a')) valeur = row.fetchone() print(valeur) row = cx.execute( ('select count(*) from t1 x ' 'inner join t2 y on x.b = y.b')) valeur = row.fetchone()
Si la jointure sur les champs non unique retourne tout logiquement (4,) -- quelque soit la type de base les modalites et langage utiliser pour l'insertion des données. La jointure sur les cle unique retourne elle bien ---> (3,) pas comme dans le cas qui me pose problème .

Autre point qui aurait plus sa place sur l'autre post " Il n'y a PostgreSQL qui a fait ce choix d'implémentation, d'unicite dans le nom des contraintes."

Bonjour

limitation de sqllite3 je vous invite a voir la suite de ce post https://www.developpez.net/forums/d1.../#post10179877

et ce code 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
 
 
# coding: utf-8  
import sqlite3
 
cx = sqlite3.connect(':memory:')
cx.execute('create table t1(a integer primary key, b text);')
 
cx.executemany('insert into t1 values(?, ?)',
             [(1, 'a'), (2, 'b'), (3, 'c')])
 
cx.execute('create table t2(a integer primary key, b text);')
 
cx.executemany('insert into t2 values(?, ?)',
              [(1, 'a'), (2, 'a'), (3, 'c'), (4, 'a'), ])
 
cx.commit()
 
row = cx.execute( ('select count(*) from t1 x '
                   'inner join t2 y on x.a = y.a'))
valeur  = row.fetchone()
 
print(valeur)
 
row = cx.execute( ('select count(*) from t1 x '
                   'inner join t2 y on x.b = y.b'))
valeur  = row.fetchone()
 
print(valeur)
print("----------------------------------")
cx = sqlite3.connect(':memory:')
cx.execute('create table t3(a text(10) primary key, b text n );')
 
 
cx.executemany('insert into t3 values(?, ?)',
             [('G0000000000', 'a'), ('G0000000000ZZZ', 'b'), ('G0000000000QQQ', 'b')])
 
 
cx.commit()
 
row = cx.execute( ('select  lENGTH(a) from t3 ;'   ))
 
valeur  = row.fetchall()
print(valeur)
 
 
row = cx.execute( ('select max( lENGTH(a)) from t3 ;'   ))
 
valeur  = row.fetchall()
print(valeur)
 
 
print("----------------------------------")
 
cx = sqlite3.connect(':memory:')
cx.execute('create table t4(a text(10) primary key, b text n , PRAGMA foreign_keys);')
 
 
cx.executemany('insert into t4 values(?, ?)',
             [('G0000000000', 'a'), ('G0000000000ZZZ', 'b'), ('G0000000000QQQ', 'b')])
 
 
cx.commit()
 
row = cx.execute( ('select  lENGTH(a) from t4 ;'   ))
 
valeur  = row.fetchall()
print(valeur)
 
 
row = cx.execute( ('select max( lENGTH(a)) from t4 ;'   ))
 
valeur  = row.fetchall()
print(valeur)

les résulats

Code:

1
2
3
4
5
6
7
8
9
10
11
 
(3,)
(4,)
----------------------------------
[(11,), (14,), (14,)]
[(14,)]
----------------------------------
Traceback (most recent call last):
  File "C:\Users\serveeric37\eclipse-workspace\vslrecette\src\x.py", line 59, in <module>
    [('G0000000000', 'a'), ('G0000000000ZZZ', 'b'), ('G0000000000QQQ', 'b')])
sqlite3.OperationalError: table t4 has 3 columns but 2 values were supplied

sans cette notion de PRAGMA foreign_keys dans la construction de la cle,
quand on vous laisse entendre que la definition de la table fixe à tel définition

Mais que l'on contaste dans les fait que cela n'est pas le cas ... par que l'enregistre N°100.512 et N°200.052 du fichier csv ne sont pas conforme a ce que l'on a vous dit , ce constat est des plus déplaisant.

Peut être faut-il ajouter un process de controles champ par champ de l'intégrite des donnée dans ce code.
Ou effectivemment utiliser le terme de PRAGMA foreign_keys pour faire de même et exclure les données posant problème pour revoir avec ces définitions.

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
# coding: utf-8  
'''
Created on 23 mars 2018
 
@author: 
'''
import csv
import sqlite3
import sys
import csv
import os
import encodings
from collections import namedtuple
from src.convertie import *
 
 
class record(namedtuple('record', 'ACT_CODE, ACT_LIBELLE')):
    def __new__(cls, row):
        if row[0] == 'NULL':
            record.ACT_CODE = 'NULL'
        if   row[1] == 'NULL': 
             record.ACT_LIBELLE = 'NULL'
        return super().__new__(cls, *row)
 
class Writer:
    def __init__(self, path):
    #def __init__(self, path='mem.db'):    
        cnx = self._cnx = sqlite3.connect(path)
        commandesql = '''drop table if  exists vsl_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 vsl_actes(
            ACT_CODE TEXT(255),
            ACT_LIBELLE TEXT(255),
            CONSTRAINT actes_pk PRIMARY KEY(ACT_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()            
 
        commandesql = """CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""      
 
        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):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
        with self._cnx:
            try:
                self._cnx.executemany(rq, 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):
        rq = """INSERT OR IGNORE INTO vsl_actes
        (ACT_CODE, ACT_LIBELLE)
        VALUES(?, ?);"""
 
        with self._cnx:
            for enregistrement in records:
                try:
                    self._cnx.execute(rq, 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 vsl_actes'):
                print (row)
 
class vsl_acte(object):
    def __init__(self, nomfichier , base):
 
        self.nomfichier = nomfichier
        self.base = base
        print('Injection ' + self.nomfichier +' sur la base ' + self.base  )
        writer = Writer(self.base )
        with open(self.nomfichier   , encoding='utf-8') as file:
            reader = csv.reader(file,'excel-fr')
            reader.__next__() # bypass l'entete du fichier
            packer = Packer(reader, record)
            i = 1
 
            for records in packer.get_records():
                writer.writesmany(records)
                #print(i, records)
                i += 1         
 
if __name__ == '__main__':
    encodage ="utf-8"
    BaseSQL='BaseVSL.db'
    csv.register_dialect('excel-fr', ExcelFr())
    vsl_acte('actes.csv', BaseSQL )
 
    #writer.dump()

22/04/2018, 10h46
wiztricks

Salut,

Vous êtes un acharné vous: essayez sur postgreSQL vous obtiendrez les mêmes résultats (j'ai fait le test!).
Et s'ils ne sont pas conformes à vos attentes, c'est que vous n'avez pas tout compris, ou plutôt l'immense chance d'avoir encore des tas de choses à apprendre et pleins de "premières fois" à expérimenter contrairement à d'autres vieux briscards (dont je fais partie).
C'est comme çà.

Citation:

Envoyé par dedalios

Ou effectivemment utiliser le terme de PRAGMA foreign_keys pour faire de même et exclure les données posant problème pour revoir avec ces définitions.

Bah... vous avez trouvé un autre os à ronger?
Il n'y a même pas de "foreign key" dans la déclaration de vos tables...
Bonne continuation... Il fait beau, allez profiter du soleil, çà vous fera le plus grand bien.

- W
22/04/2018, 22h25
dedalios

Citation:

Envoyé par wiztricks

Salut,
Vous êtes un acharné vous: essayez sur postgreSQL vous obtiendrez les mêmes résultats (j'ai fait le test!).
Et s'ils ne sont pas conformes à vos attentes, c'est que vous n'avez pas tout compris, ou plutôt l'immense chance d'avoir encore des tas de choses à apprendre et pleins de "premières fois" à expérimenter contrairement à d'autres vieux briscards (dont je fais partie)
- W

il ne faut pas crois je suis aussi un vieux briscard mais qui n'a pas code de puis plus de 10 ans
et qui connais d'autre base de données , qui a code en d'autre language non objets.

Et je me prends a tete avec des personnes (je ne parle pas de nos échanges ) qui ne fournissent pas d'information cohérente .
par exemple les premiers fichier csv tranmit ne contenait aucune information sur le contenu ....
23/04/2018, 15h42
dedalios

Citation:

Envoyé par wiztricks

Il n'y a même pas de "foreign key" dans la déclaration de vos tables...
- W

S'il n' a y pas foreign key dans les exemples notés il y en a néammoins dans d'autre tables du projet . Mais j'ai suivi le conseil avisé de m'éloigner de ces ecrans nocifes qui quelquefois non occulte la vériter à trop les regarder.
Et j'ai vue une erreur celle-ci est explicitée dans le post dédié à SQLlTE.

Je dois migrer mes données de SQLite vers Postgres ce n'est pas que SQLite ne soit pas une base interressante elle répond parfaitement , mais ja n'ai pas décidé de ce choix de passer à Postgre