Discussion :

[FolDeDol]

Bonsoir à toutes et à tous,

J'essaye de me familiariser avec PyQt et je rencontre quelques problèmes...
J'ai conçu un petit script (ci-dessous) qui affiche les données d'une liste dans une combobox.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
import sys
from Lecture_Consommable import *
 
class Element(QtGui.QDialog):
    def __init__ (self, parent = None) :
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.liste =['Ordinateur Portable', 'Imprimante', 'Ecran Plat', 'Disque Dur']
        self.formulaire()
 
    def formulaire(self):
        for i in self.liste:
            self.ui.comboBox.addItem(i)
 
if __name__=="__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = Element()
    myapp.show()
    sys.exit(app.exec_())

J'essaye d'étendre ce script pour lire les données d'une table, les ajouter dans une liste et les récupérer dans la combobox.

J'ai du mal à aborder la documentation de PyQt mais je pense avoir réussi à établir la connexion avec la base de données. Je bloque toutefois sur la syntaxe pour exécuter la requête "SELECT nom_consommable FROM consommable" dans ma fonction Formulaire. Je n'arrive pas non plus à déterminer si je dois "créer" un curseur pour lire les données ou s'il existe une méthode déjà existante sous PyQt.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
import sys
from Lecture_Consommable import *
from PyQt4 import QtSql, QtGui
 
 
def Connection():
    db = QtSql.QSqlDatabase.addDatabase('QPSQL')
    db.setHostName('localhost')
    db.setDatabaseName('*****')
    db.setUserName('postgres')
    db.setPassword('*****')
    db.open()
 
class Element(QtGui.QDialog):
    def __init__ (self, parent = None) :
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.liste =['Ordinateur Portable', 'Imprimante', 'Ecran Plat', 'Disque Dur']
        self.formulaire()
 
    def formulaire(self):
        for i in self.liste:
            self.ui.comboBox.addItem(i)
 
if __name__=="__main__":
    app = QtGui.QApplication(sys.argv)
    myapp = Element()
    myapp.show()
    sys.exit(app.exec_())

Si quelqu'un peut me proposer une idée ou rectifier la mienne, je suis preneur.

@+

[tyrtamos]

Bonjour,

Voilà un petit code de principe en console (Python 3, PyQt4) qui extrait des données d'une base sous sqlite3:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3, PyQt4
 
import sys
 
from PyQt4 import QtCore, QtSql
 
#============================================================================
# initialisation de la  bibliothèque graphique pour une application en console
app = QtCore.QCoreApplication(sys.argv)
 
#============================================================================
# base de données sqlite3
basesql = "mabase.db3"
 
#============================================================================
# tentative d'ouverture de la base avec le pilote de sqlite3
cnx = QtSql.QSqlDatabase.addDatabase(u"QSQLITE")
cnx.setDatabaseName(basesql)
if not cnx.open():
    print("Erreur d'ouverture de la base de données")
    app.quit()
    sys.exit()
 
#============================================================================
# exécution d'une requête
 
# obtention d'un curseur
query = QtSql.QSqlQuery(cnx)
 
# préparation de la requête d'extraction
req = """
SELECT nations.nation
from nations
"""
# tentative d'exécution de la requête
ok = query.exec_(req)
if not ok:
    print("Erreur d'exécution de la requête")
    app.quit()
    sys.exit()
 
# récupération des données
R = []
while query.next():
    R.append([])  # nouvelle ligne
    j = 0
    while query.value(j):
        # ajout d'une donnée sur la ligne
        R[-1].append(query.value(j))
        j += 1
 
# désactivation du curseur (effacement des données et libération ressources)
query.clear()
 
#============================================================================
# fermeture de la base
cnx.close()
 
#============================================================================
# affichage du résultat
for ligne in R:
    print(ligne)

A adapter à ton contexte!

Pour des requêtes avec transactions, c'est un peu plus complexe, mais ça marche aussi.

Pourtant, dans mes logiciels, je n'utilise le pilote de Qt4 que s'il y a du graphique (visualisation directe dans des widgets comme QTableView avec modèles). Dans tous les autres cas, comme le tien, j'utilise le pilote de Python, qui me semble plus pratique à utiliser. Je n'ai rencontré aucun inconvénient à utiliser les 2 pilotes Python et Qt4 dans un même programme, à condition qu'ils ne soient pas actifs en même temps.

[Jiyuu]

La solution de Tyrtamos doit bien convenir à ton besoin, c'est d'ailleurs une solution similaire que j'utilisais avant d'être lassé de me demander systématiquement à quelle position dans la liste était l'information que je cherchais... Pour palier à ceci l'astuce consiste à passer par un dictionnaire qui sera, pour une ligne donnée, de la forme :

Code :

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

dic = {"titre_col1":"val_col1", "titre_coln":"val_coln"}

Pour cela tu as au moins deux façons de faire.

Méthode 1 :
Dans ton code tu ajoutes une liste qui correspondra à chaque champs de ta BDD et tu t'en sers pour créer ton dictionnaire.

Méthode 2 :
Tu passe par la fonction SQL PRAGMA qui te permettra de récupérer les entêtes des colonnes.
J'ai un exemple ici . C'est du QML (Qt Déclaratif) mais la requête SQL devrait te guider.

Il existe peut-être une chose similaire avec QSqlQuery, mais je n'en suis pas sûr.

@+

J

[tyrtamos]

Bonjour Jiyuu,

J'ai déjà utilisé cela, mais tant qu'à faire, il faut utiliser un dictionnaire ordonné (OrderedDict du module collections): en conservant l'ordre initial des champs, cela permet à tout moment de refabriquer une liste pour, par exemple, créer un fichier csv destiné à Excel.

[FolDeDol]

Bonjour,

Merci pour vos réponses.

@Tyrtamos : J'ai légèrement adapté ton code pour le tester. Celui-ci fonctionne mais... je me retrouve avec une erreur (voir ci-dessous). Je n'ai malheureusement pas encore eu trop le temps de chercher et approfondir cette erreur.
D'après ce que j'en déduis, il va falloir que je trouve un moyen de compter le nombre de colonnes dans la table pour définir une limite dans la boucle Python. Peut-être que je me trompe ?

Code :

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

1
2
3
4
5
6
7
8
9
 
QPSQLResult::data: column 1 out of range
['Ordinateur Portable']
['Imprimante']
['Ecran Plat']
['Disque Dur']
QPSQLResult::data: column 1 out of range
QPSQLResult::data: column 1 out of range
QPSQLResult::data: column 1 out of range

@Jiyuu : merci pour les informations, il va me falloir un peu de temps pour les digérer
Il me reste beaucoup de travail pour assimiler Python et PyQt... mais je ne désespère pas.

@+

[tyrtamos]

Bonjour,

J'avais essayé mon code avant, et il fonctionnait sans erreur dans mon contexte (sqlite3). Cependant, en épluchant la doc, je m'aperçois que les différents SGBDR ne donnent pas forcément le même résultat aux mêmes requêtes.

Voilà une astuce permettant de calculer le nombre de colonnes d'une table (cnx étant une connexion ouverte):

Code :

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

1
2
3
4
table = "nomdelatable"
query = QtSql.QSqlQuery("SELECT * FROM %s;" % (table,), cnx)
rec = query.record()
print(rec.count())

Il n'y a apparemment aucun moyen de récupérer les noms des champs. Mais si on les a par ailleurs, on peut calculer leurs index avec query.record().indexOf("nomduchamp")

Bizarrement, il est déconseillé d'utiliser un "SELECT * FROM table" parce que les champs renvoyés ne sont pas forcément dans le bon ordre.

Dans le code que j'ai proposé, query.next() permet d'accéder à la ligne suivante de la table, et pour une même ligne, query.value(j) permet d'accéder au champ d'index j. Cet index j commence à 0 pour aller jusqu'à ce qu'il soit trop grand.

Pour l'erreur que tu as trouvé, je te suggère de regarder ce que renvoie query.value(j) pour un index j qui dépasse le nombre de champ. Chez moi, ça renvoie None. Si c'est ça aussi chez toi, on peut essayer le code suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
R = []
while query.next():
    R.append([])  # nouvelle ligne
    j = 0
    while True:
        val = query.value(j) # valeur du champ d'index j
        if val == None:
            break # l'index dépasse le nombre de champs demandés dans la requête 
        # ajout d'une donnée sur la ligne
        R[-1].append(val)
        j += 1

Si chez toi query.value(j) pour j trop grand donne un autre résultat (une exception?), il faut modifier le code en conséquence.

Attention: les index permis sont seulement ceux qui correspondent au résultat de la requête: si on demande 2 champs comme dans "SELECT nom, prenom FROM annuaire", les index permis sont seulement 0 et 1.

Il y a peut-être encore d'autres subtilités à lire dans la doc et spécifiques à ton SGBDR!

Sincèrement, ça me conforte dans ce que je fais: je n'utilise jamais ce code Qt s'il n'y a pas de graphique! Je préfère nettement le pilote Python.

[wiztricks]

Salut,

Cependant, en épluchant la doc, je m'aperçois que les différents SGBDR ne donnent pas forcément le même résultat aux mêmes requêtes.

Bizarrement, il est déconseillé d'utiliser un "SELECT * FROM table" parce que les champs renvoyés ne sont pas forcément dans le bon ordre.

"SELECT * FROM table" retournera une liste de tuple dans l'ordre qui arrangera le SGDB (un peu comme l'ordre des clés d'un dict Python, rien ne garanti qu'il soit le même d'un SGDB à l'autre).
Mais si on veut de l'ordre on peut faire "SELECT * FROM table ORDER BY column" et précisé si on veut ascending ou descending.

Dans le cas SQLite3 "column" peut être le rowid qui est un indice ajouté "automagiquement" à chaque record.
Cependant, si la table n'a pas été déclarée avec une colonne de type "INTEGER PRIMARY KEY" ou "PRIMARY KEY AUTOINCREMENT", SQlite3 pourra les recycler. Les détails sont dans la documentation de SQLite3.

- W

[tyrtamos]

Bonjour wiztricks et merci,

Je suis d'accord avec les requêtes pour obtenir les lignes dans le bon ordre, mais je m'intéressais plutôt à l'ordre des colonnes.

En effet, si je comprends bien la doc de Qt (extrait: "Using SELECT * is not recommended because the order of the fields in the query is undefined."):

• si j'ai SELECT nom, prenom FROM table, alors j'ai bien l'ordre nom, prenom restitué dans le résultat
• mais si j'ai SELECT * from table, il est possible que j'obtienne le prénom avant le nom!

Ça, ce n'est pas chouette!

Il y a par contre une solution plus sûre si on a déjà la liste des noms de champs. Encore faut-il savoir comment la récupérer.

Avec sqlite3, on peut construire une petite fonction qui retourne cette liste de nom de champs:

Code :

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

1
2
3
4
5
6
7
8
9
def listechamps(cnx, table):
    """Retourne la liste des noms de champ de la table 'table' de
       la base de données ouverte cnx
    """
    cur = cnx.cursor()
    cur.execute("PRAGMA table_info(%s);" % (table,))
    liste = [elem[1] for elem in cur.fetchall()]
    cur.close()
    return liste

On peut d'ailleurs récupérer par le même moyen: le type de chaque données ainsi que la valeur par défaut: c'est très pratique!

Mais le PO utilise Postgresql: peut-être qu'une solution équivalente existe?

[wiztricks]

Salut,

Je suis d'accord avec les requêtes pour obtenir les lignes dans le bon ordre, mais je m'intéressais plutôt à l'ordre des colonnes.

En effet, si je comprends bien la doc de Qt (extrait: "Using SELECT * is not recommended because the order of the fields in the query is undefined."):

Ooops, pardon, je n'avais pas imaginé ce cas là.
En fait SELECT *, c'est juste bon pour les tutos et les ennuis.
Dans la pratique, votre code dépend non seulement de l'ordre des colonnes mais aussi de leur existence.

Et si vous ne visualisez pas cette dépendance de façon explicite, vous avez des soucis de maintenance.
Que se passera-t-il si vous devez ajouter une colonne? Avec le "*" on sait pas si on fout la grouille ou pas, avec les noms explicites, on a un indicateur côté risques lorsqu'on envisage de se lancer dans la mise à jour du schéma.

- W

[tyrtamos]

Pour trouver les noms de champs avec postgresql, il faudrait essayer quelque chose comme:

Code SQL :

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

select column_name from information_schema.columns where table_name = 'myTable';

J'ai vu ça quelque part sur le web.

[Nico_tournai]

Bonjour

pour apporter ma modeste pierre à l'édifice (si je suis pas HS), avec QtSql:

pour connaitre les champs d'une table..

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# -*- coding: utf-8 -*-
from PyQt4 import QtGui, QtCore, QtSql
import os
import sys
 
app = QtGui.QApplication(sys.argv)
 
db = QtSql.QSqlDatabase.addDatabase("QMYSQL","mysql")
db.setHostName("192.168.10.211")
db.setDatabaseName("maDB")
db.setUserName("root")
db.setPassword("")
 
print db.open()
 
rec = db.record("maTable")
for i in range(rec.count()):
  print rec.fieldName(i)

[tyrtamos]

Bonjour,

Bravo Nico_tournai, ça marche et c'est très simple! J'aime bien ce genre de solution.

Je ne l'ai essayé que sur sqlite3, mais si ça marche aussi sur MySql, ça devrait marcher aussi sur PostgreSql.

[Jiyuu]

Nico.

Cela remplace très facilement la fonction SQL PRAGMA et, pour ma part, permet d'apporter une bonne solution à la création des dictionnaires comme je l'ai mis dans mon précédent message.

Merci.


J

[tyrtamos]

Bonjour,

Application: voilà une fonction (Python 3, PyQt4) qui va retourner toute une table sous forme de "liste de listes", en étant sûr que l'ordre des champs est correct:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def chargetableqt(cnx, table):
    """charge la table en mémoire et retourne la liste de listes
       cnx: variable de connexion sur la base de données
       en cas d'erreur: retourne None
    """
    # trouver tous les noms de champs
    rec = cnx.record(table)
    noms = [rec.fieldName(i) for i in range(0, rec.count())]
 
    # charger la table
    query = QtSql.QSqlQuery(cnx)
    if not query.exec_("SELECT * FROM %s" % table):
        return None  # echec d'exécution de la requête
    LL = []
    while query.next():
        ligne = [query.value(rec.indexOf(nom)) for nom in noms]
        LL.append(ligne)
    query.clear()
    return LL

Et pour aller dans le sens de Jiyuu, voilà la même, mais qui renvoie une "liste de dictionnaires" (en plus: dictionnaires ordonnés):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from collections import OrderedDict
 
def chargetableqtdico(cnx, table):
    """charge la table en mémoire et retourne la liste de dictionnaires ordonnés
       cnx: variable de connexion sur la base de données
       en cas d'erreur: retourne None
    """
    # trouver tous les noms de champs
    rec = cnx.record(table)
    noms = [rec.fieldName(i) for i in range(0, rec.count())]
 
    # charger la table
    query = QtSql.QSqlQuery(cnx)
    if not query.exec_("SELECT * FROM %s" % table):
        return None  # echec d'exécution de la requête
    LD = []
    while query.next():
        dicoligne = OrderedDict()
        for nom in noms:
            dicoligne[nom] = query.value(rec.indexOf(nom))  # ajout champ
        LD.append(dicoligne)  # ajout ligne
    query.clear()
    return LD

[FolDeDol]

Bonjour,

Je vous remercie pour vos réponses.
N'ayant pas d'ordinateur ce week-end, je vais devoir attendre lundi pour tester vos morceaux de code.
J'ai déjà quelques questions en tête...

Bon journée à vous toutes et tous et bonne fin de semaine.

@+

[FolDeDol]

Bonsoir,

J'arrive enfin à récupérer l'ensemble d'une table ou d'une colonne avec l'aide de vos scripts.
Je n'ai, toutefois, pas trouvé sur le net quelque chose de réellement pertinent concernant l'erreur suivante :

Code :

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

1
2
3
 
QPSQLResult::data: column 2 out of range
...

Ce n'est pas grave, cela m'a permis de "comprendre" un peu mieux le fonctionnement de PyQt et Python.

@+