Comment parcourir toutes les lignes d'une table ?

Version imprimable

31/08/2011, 02h03
ithryam

Comment parcourir toutes les lignes d'une table ?

Salut tt le monde:
comment parcourir toutes les lignes d'une table et récupérer les valeurs d'une seul colonne?
Explication:
maTable:
........col1 ..col2 ....col3
lin1.....4......5..........6
lin2.....3......5..........4
lin3.....2......1..........1
lin4.....4......3..........5

JE veux afficher la somme de ma colonne col2 (=5+5+1+3) dans un QLabel par example

Merci
31/08/2011, 15h47
tyrtamos
Bonjour,

A priori, il suffit d'exécuter l'instruction SQL:
Code:

1 2 select sum(col2) from maTable
et d'en récupérer le résultat (ici, 14).

Dis s'il t'en faut plus.
02/09/2011, 00h56
ithryam

J'ai pensé à cette instruction SQL, mais le problème est comment puis-je récupérer le résultat? pour le mettre dans un QLabel par exemple.

Bonjour,

Comme je ne sais pas où tu en es, j'ai fait un petit code PyQt4/QtSql en console (non graphique!) pour obtenir le résultat cherché. Il est pour Python 2.7 et pour une base sous sqlite (pilote QSQLITE):

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# python 2.7
 
import sys
from PyQt4 import QtCore, QtSql
 
#############################################################################
def litbaseqt(query):
    """retourne la liste des enregistrements lus dans la base ouverte pour qt
       toutes les valeurs sont retournées sous forme de chaine de caractères
    """
    R = []
    while query.next():
        R.append([])
        j = 0
        while query.value(j).isValid():
            R[-1].append(unicode(query.value(j).toString()))
            j += 1
    return R
 
#############################################################################
if __name__ == "__main__":
 
    app = QtCore.QCoreApplication(sys.argv)  # quand il n'y a pas de graphique
 
    #------------------------------------------------------------------------
    # ouvrir la base mabase.db
    cnx = QtSql.QSqlDatabase.addDatabase(u"QSQLITE")
    cnx.setDatabaseName(u"mabase.db")
    if not cnx.open():
        print u"Echec de l'ouverture de la base"
        sys.exit()
 
    # obtenir un curseur
    query = QtSql.QSqlQuery(cnx)
 
    # pilote QSQLITE: activer les contraintes de clé étrangère
    query.exec_("PRAGMA foreign_keys=on")
 
    # obtenir la somme du champ col2 de la table matable
    req = """
          select sum(col2)
          from matable
          """        
    if query.exec_(req):
        result = litbaseqt(query)
        print int(result[0][0]) # valeur cherchée = 1er champ de la 1ère ligne
    else:
        print u"Erreur d'extraction : %s" % (unicode(query.lastError().text()),)
 
    #------------------------------------------------------------------------
    # fermer la base
    cnx.close()

Commentaires:

- la bibliothèque actuelle de sqlite nécessite qu'on active les contraintes de clé étrangère à l'ouverture de la base, sinon elles ne sont pas considérées (ce qui est dommage pour une base de données relationnelle!).

- la fonction litbaseqt(query) lit le résultat renvoyé par la requête sous forme de liste de listes: [[ligne1],[ligne2],...,[dernière ligne]], chaque sous-liste donnant la liste des valeurs des champs de la ligne: [champ1, champ2, ..., dernier champ]. Ici, on obtiendra: [['14']].

A noter qu'on peut tenir compte des types de chaque champ pour convertir "à la volée" et renvoyer les valeurs selon le bon type python. Voilà un exemple pour le pilote QSQLITE:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def litbaseqt(query):
    """retourne la liste des enregistrements lus dans la base ouverte pour qt
       les valeurs des champs sont dans le bon type (valable pour QSQLITE)
    """
    R = []
    while query.next():
        R.append([])
        j = 0
        while query.value(j).isValid():
            typ = query.value(j).type()
            if typ == 4:
                R[-1].append(query.value(j).toInt()[0])
            elif typ == 6:
                R[-1].append(query.value(j).toDouble()[0])
            elif typ == 10:
                R[-1].append(unicode(query.value(j).toString()))
            elif typ == 12:
                R[-1].append(buffer(query.value(j).toByteArray()))
            else:
                R[-1].append(unicode(query.value(j).toString()))
            j += 1
    return R

- Dans un programme graphique avec la table de la base affichée dans un QTableView par l'intermédiaire d'un modèle QSqlRelationalTableModel, on peut aussi exécuter des instructions SQL et afficher la table obtenue, mais dans le cas qui nous occupe, c'est dommage d'afficher une table composée d'une seule valeur (=14): donne plus d'infos sur ce que tu veux faire si ce qui précède ne te suffit pas.

Une fois la valeur obtenue, il ne reste plus qu'à la placer dans un QLabel.

Ok?

03/09/2011, 14h05
ithryam

super,!!, ta fonction fait largement l'affaire :) Merci.
peut être il serai intéressant d'afficher le résultat dans un QTableView, mais ce que je voulais c'est l' afficher dans un QLable. (ex: actualiser le total des prix des achats chaque fois qu'un achat s’effectue) ce que fais ta fonction avec succé:).
Merci

Bonjour,

A titre de bonus, voilà le même calcul fait dans un contexte graphique.

Il s'agit de créer une fenêtre dans laquelle une grille QTableView visualise la table de la base de données. Ici, cette fenêtre fait en plus le calcul de la somme de la colonne col2 et l'affiche dans un label en bas à gauche.

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python 2.7
 
import sys, os
from PyQt4 import QtCore, QtGui, QtSql
 
#############################################################################
def litbaseqt(query):
    """retourne la liste des enregistrements lus dans la base ouverte pour qt
       toutes les valeurs sont retournées sous forme de chaine de caractères
    """
    R = []
    while query.next():
        R.append([])
        j = 0
        while query.value(j).isValid():
            R[-1].append(unicode(query.value(j).toString()))
            j += 1
    return R
 
#############################################################################
class Vuetable(QtGui.QWidget):
 
    #========================================================================
    def __init__(self, cnx, table, parent=None):
        super(Vuetable, self).__init__(parent)
 
        # connexion à la base de données
        self.cnx = cnx
        # nom de la table à afficher
        self.table = table
 
        # création de la grille d'affichage
        self.vuetable = QtGui.QTableView(self)
        self.vuetable.setSortingEnabled(True)
 
        # Création du modèle de relation entre la base et la grille d'affichage
        self.modele = QtSql.QSqlRelationalTableModel(self, self.cnx)
        self.modele.setTable(self.table)
        self.modele.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
        self.modele.select()
 
        # Etablissement de la relation entre la base et la grille d'affichage 
        self.vuetable.setModel(self.modele)
        self.vuetable.setItemDelegate(QtSql.QSqlRelationalDelegate(self.vuetable))
 
        # création du label
        self.label = QtGui.QLabel(self)
 
        # positionnement des widgets dans la fenêtre
        posit = QtGui.QGridLayout()
        posit.addWidget(self.vuetable, 0, 0)
        posit.addWidget(self.label, 1, 0)
        self.setLayout(posit)
 
        # calcul et affichage de la somme de la colonne col2
        query = QtSql.QSqlQuery(self.cnx)
        req = """
              select sum(col2)
              from matable
              """        
        if query.exec_(req):
            result = unicode(litbaseqt(query)[0][0])
            self.label.setText(result)
        else:
            QtGui.QMessageBox.critical(self,
                u"Attention",
                u"Erreur d'extraction : %s" % (unicode(query.lastError().text()),)
                )
        query.finish() # désactiver le curseur         
 
    #========================================================================
    def closeEvent(self, event):
        """méthode exécutée à chaque demande de fermeture de la fenêtre"""
        # fermeture de la base
        self.cnx.close()
        # acceptation de la fermeture de la fenêtre
        event.accept()
 
#############################################################################
if __name__ == "__main__":
 
    # initialisation du graphique
    app = QtGui.QApplication(sys.argv)
 
    # ouverture de la base de données
    cnx = QtSql.QSqlDatabase.addDatabase("QSQLITE")
    basesql = u"mabase.db"
    cnx.setDatabaseName(basesql)
    if not cnx.open():
        QtGui.QMessageBox.critical(None, 
          u"Ouverture de la base de données",
          u"Erreur d'ouverture de la base de données")
        sys.exit(app.quit())
    # spécifique à sqlite: activer les contraites de clé étrangère
    query = QtSql.QSqlQuery(cnx)
    query.exec_("PRAGMA foreign_keys=on")
    query.finish() # désactiver le curseur        
 
    # définition de la table à afficher
    table = u"matable"  # nom de la table à afficher
 
    # affichage de la fenêtre
    fen = Vuetable(cnx, table)
    fen.show()
    sys.exit(app.exec_())

Comme la fenêtre est appelée avec 2 arguments (la connexion et la table à afficher), on peut:

- afficher n'importe quel table de la base de données (en tenant compte ou pas des contraintes de clé étrangère!), et même en afficher plusieurs en même temps.

- afficher une table crée provisoirement à la suite d'un select par "create view" (et l'effacer après).

- trier les données selon n'importe quelle colonne (descendant/ascendant) comme dans un tableur.

On peut aussi, en ajoutant du code et des widgets:

- permettre des modifications de valeurs ainsi que d'ajout/destruction d'enregistrements et mettre à jour l'affichage

- ajouter des filtres par instructions SQL et mettre à jour l'affichage.

- faire une exportation du résultat obtenu par fichier csv (récupérable sous Excel).

- Etc...

Une fois qu'on a compris le mécanisme, c'est très pratique et très puissant!