Les bases – Real Python

Création d'une connexion à la base de données

La connexion de vos applications à une base de données SQL physique est une étape importante dans le processus de développement d'applications de base de données avec PyQt. Pour réussir cette étape, vous avez besoin d'informations générales sur la configuration de votre base de données.

Par exemple, vous devez savoir sur quel système de gestion de base de données votre base de données est construite, et vous devrez peut-être également avoir un nom d'utilisateur, un mot de passe, un nom d'hôte, etc.

Dans ce didacticiel, vous utiliserez SQLite 3, un système de base de données bien testé avec une prise en charge sur toutes les plates-formes et des exigences de configuration minimales. SQLite vous permet de lire et d'écrire directement dans les bases de données de votre disque local sans avoir besoin d'un processus serveur distinct. Cela en fait une option conviviale pour l'apprentissage du développement d'applications de base de données.

Un autre avantage de l'utilisation de SQLite est que la bibliothèque est livrée avec Python et aussi avec PyQt, vous n'avez donc pas besoin d'installer quoi que ce soit d'autre pour commencer à travailler avec.

Dans PyQt, vous pouvez créer une connexion à la base de données en utilisant le QSqlDatabase classe. Cette classe représente une connexion et fournit une interface pour accéder à la base de données. Pour créer une connexion, il suffit d'appeler .addDatabase () sur QSqlDatabase. Cette méthode statique prend un pilote SQL et un nom de connexion facultatif comme arguments et renvoie une connexion à la base de données:

QSqlDatabase.addDatabase(
    chauffeur, connectionName=QSqlDatabase.defaultConnection
)

Le premier argument, chauffeur, est un argument obligatoire contenant une chaîne contenant le nom d'un pilote SQL pris en charge par PyQt. Le deuxième argument, connectionName, est un argument facultatif contenant une chaîne avec le nom de la connexion. connectionName par défaut QSqlDatabase.defaultConnection, qui contient normalement la chaîne "qt_sql_default_connection".

Si vous avez déjà une connexion appelée connectionName, puis cette connexion est supprimée et remplacée par une nouvelle connexion, et .addDatabase () renvoie la connexion à la base de données nouvellement ajoutée à l'appelant.

Un appel à .addDatabase () ajoute une connexion de base de données à une liste de connexions disponibles. Cette liste est un registre mondial que PyQt maintient dans les coulisses pour garder une trace des connexions disponibles dans une application. Enregistrer vos connexions avec un connectionName vous permettra de gérer plusieurs connexions dans une application de base de données.

Une fois que vous avez créé une connexion, vous devrez peut-être définir plusieurs attributs dessus. L'ensemble spécifique d'attributs dépendra du pilote que vous utilisez. En général, vous devrez définir des attributs tels que le nom de la base de données, le nom d'utilisateur et le mot de passe pour accéder à la base de données.

Voici un résumé des méthodes de définition que vous pouvez utiliser pour définir les attributs ou propriétés les plus couramment utilisés d'une connexion à une base de données:

Notez que le mot de passe que vous passez en argument .setPassword () est stocké en texte brut et peut être récupéré plus tard en appelant .mot de passe(). C'est un sérieux risque de sécurité que vous devez éviter d'introduire dans vos applications de base de données. Vous apprendrez une approche plus sûre dans la section Ouverture d'une connexion à une base de données plus loin dans ce didacticiel.

Pour créer une connexion à une base de données SQLite à l'aide de QSqlDatabase, ouvrez une session interactive Python et saisissez le code suivant:

>>> de PyQt5.QtSql importer QSqlDatabase

>>> con = QSqlDatabase.addDatabase("QSQLITE")
>>> con.setDatabaseName("contacts.sqlite")

>>> con


>>> con.nom de la base de données()
'contacts.sqlite'

>>> con.connectionName()
'qt_sql_default_connection'

Ce code créera un objet de connexion à la base de données en utilisant "QSQLITE" comme pilote de la connexion et "contacts.sqlite" comme nom de base de données de la connexion. Puisque vous ne transmettez pas de nom de connexion à .addDatabase (), la connexion nouvellement créée devient votre connexion par défaut, dont le nom est "qt_sql_default_connection".

Dans le cas des bases de données SQLite, le nom de la base de données est normalement un nom de fichier ou un chemin qui inclut le nom de fichier de la base de données. Vous pouvez également utiliser le nom spécial ":Mémoire:" pour une base de données en mémoire.

Gestion de plusieurs connexions

Il peut y avoir des situations dans lesquelles vous devez utiliser plusieurs connexions à une seule base de données. Par exemple, vous souhaiterez peut-être enregistrer les interactions des utilisateurs avec la base de données en utilisant une connexion spécifique pour chaque utilisateur.

Dans d'autres situations, vous devrez peut-être connecter votre application à plusieurs bases de données. Par exemple, vous souhaiterez peut-être vous connecter à plusieurs bases de données distantes afin de collecter des données pour alimenter ou mettre à jour une base de données locale.

Pour gérer ces situations, vous pouvez fournir des noms spécifiques pour vos différentes connexions et référencer chaque connexion par son nom. Si vous voulez donner un nom à votre connexion à la base de données, transmettez ce nom comme deuxième argument à .addDatabase ():

>>> de PyQt5.QtSql importer QSqlDatabase

>>> # Première connexion
>>> con1 = QSqlDatabase.addDatabase("QSQLITE", "con1")
>>> con1.setDatabaseName("contacts.sqlite")

>>> # Deuxième connexion
>>> con2 = QSqlDatabase.addDatabase("QSQLITE", "con2")
>>> con2.setDatabaseName("contacts.sqlite")

>>> con1

>>> con2


>>> con1.nom de la base de données()
'contacts.sqlite'
>>> con2.nom de la base de données()
'contacts.sqlite'

>>> con1.connectionName()
'con1'
>>> con2.connectionName()
'con2'

Ici, vous créez deux connexions différentes à la même base de données, contacts.sqlite. Chaque connexion a son propre nom de connexion. Vous pouvez utiliser le nom de la connexion pour obtenir une référence à une connexion spécifique à tout moment ultérieurement dans votre code en fonction de vos besoins. Pour ce faire, vous pouvez appeler .base de données() avec un nom de connexion:

>>> de PyQt5.QtSql importer QSqlDatabase

>>> db = QSqlDatabase.base de données("con1", ouvert=Faux)

>>> db.nom de la base de données()
'contacts.sqlite'
>>> db.connectionName()
'con1'

Dans cet exemple, vous voyez que .base de données() prend deux arguments:

1. connectionName contient le nom de connexion que vous devez utiliser. Si vous ne transmettez pas de nom de connexion, la connexion par défaut sera utilisée.
2. ouvert contient une valeur booléenne qui indique .base de données() si vous souhaitez ouvrir automatiquement la connexion ou non. Si ouvert est Vrai (valeur par défaut) et que la connexion n'est pas ouverte, la connexion est ouverte automatiquement.

La valeur de retour de .base de données() est une référence à l'objet de connexion appelé connectionName. Vous pouvez utiliser différents noms de connexion pour obtenir des références à des objets de connexion spécifiques, puis les utiliser pour gérer votre base de données.

Utilisation de différents SQL Divers

Jusqu'à présent, vous avez appris à créer une connexion à une base de données à l'aide de Pilote SQLite. Ce n’est pas le seul pilote disponible dans PyQt. La bibliothèque fournit un ensemble complet de pilotes SQL qui vous permettent d'utiliser différents types de systèmes de gestion de base de données en fonction de vos besoins spécifiques:

La colonne Nom du pilote contient le chaînes d'identifiant que vous devez passer à .addDatabase () comme premier argument pour utiliser le pilote associé. Contrairement au pilote SQLite, lorsque vous utilisez un pilote différent, vous devrez peut-être définir plusieurs attributs, tels que nom de la base de données, hostName , Nom d'utilisateur, et mot de passe, pour que la connexion fonctionne correctement.

Les pilotes de base de données sont dérivés de QSqlDriver. Vous pouvez créer vos propres pilotes de base de données en sous-classant QSqlDriver, mais ce sujet dépasse le cadre de ce didacticiel. Si vous souhaitez créer vos propres pilotes de base de données, consultez Comment écrire votre propre pilote de base de données pour plus de détails.

Ouverture d'une connexion à une base de données

Une fois que vous avez une connexion à la base de données, vous devez ouvrir cette connexion pour pouvoir interagir avec votre base de données. Pour faire ça, tu appelles .ouvert() sur l'objet de connexion. .ouvert() a les deux variantes suivantes:

1. .ouvert() ouvre une connexion à la base de données en utilisant les valeurs de connexion actuelles.
2. .open (nom d'utilisateur, mot de passe) ouvre une connexion à la base de données à l'aide du Nom d'utilisateur et mot de passe.

Les deux variantes reviennent Vrai si la connexion réussit. Sinon, ils reviennent Faux. Si la connexion ne peut pas être établie, vous pouvez appeler .lastError () pour obtenir des informations sur ce qui s'est passé. Cette fonction renvoie des informations sur la dernière erreur signalée par la base de données.

Voici un exemple d’ouverture d’une connexion à une base de données SQLite à l’aide de la première variante de .ouvert():

>>> de PyQt5.QtSql importer QSqlDatabase

>>> # Créer la connexion
>>> con = QSqlDatabase.addDatabase("QSQLITE")
>>> con.setDatabaseName("contacts.sqlite")

>>> # Ouvrez la connexion
>>> con.ouvert()
Vrai
>>> con.est ouvert()
Vrai

Dans l'exemple ci-dessus, vous créez d'abord une connexion à votre base de données SQLite et ouvrez cette connexion à l'aide de .ouvert(). Depuis .ouvert() Retour Vrai, la connexion est réussie. À ce stade, vous pouvez vérifier la connexion en utilisant .est ouvert(), qui renvoie Vrai si la connexion est ouverte et Faux autrement.

Dans les applications du monde réel, vous devez vous assurer que vous disposez d'une connexion valide à votre base de données avant d'essayer d'effectuer des opérations sur vos données. Sinon, votre application peut tomber en panne et échouer. Par exemple, que se passe-t-il si vous ne disposez pas des autorisations d'écriture pour le répertoire dans lequel vous essayez de créer ce fichier de base de données? Vous devez vous assurer que vous gérez toute erreur pouvant survenir lors de l'ouverture d'une connexion.

Une façon courante d'appeler .ouvert() est de l'envelopper dans une instruction conditionnelle. Cela vous permet de gérer les erreurs qui peuvent survenir lors de l'ouverture de la connexion:

>>> importer sys
>>> de PyQt5.QtSql importer QSqlDatabase

>>> # Créer la connexion
>>> con = QSqlDatabase.addDatabase("QSQLITE")
>>> con.setDatabaseName("contacts.sqlite")

>>> # Ouvrez la connexion et gérez les erreurs
>>> si ne pas con.ouvert():
...     impression("Impossible de se connecter à la base de données")
...     sys.sortie(1)

Conclure l'appel à .ouvert() dans une instruction conditionnelle vous permet de gérer toute erreur qui se produit lorsque vous ouvrez la connexion. De cette façon, vous pouvez informer vos utilisateurs de tout problème avant l'exécution de l'application. Notez que l'application se termine avec un statut de sortie de 1, qui est habituellement utilisé pour indiquer un échec du programme.

Dans l'exemple ci-dessus, vous utilisez .ouvert() dans une session interactive, donc vous utilisez impression() pour présenter des messages d'erreur aux utilisateurs. Cependant, dans les applications GUI, au lieu d'utiliser impression(), vous utilisez normalement un QMessageBox objet. Avec QMessageBox, vous pouvez créer de petites boîtes de dialogue pour présenter des informations à vos utilisateurs.

Voici un exemple d’application GUI qui illustre un moyen de gérer les erreurs de connexion:

    1importer sys
    2
    3de PyQt5.QtSql importer QSqlDatabase
    4de PyQt5.QtWidgets importer QApplication, QMessageBox, QLabel
    5
    6# Créer la connexion
    septcon = QSqlDatabase.addDatabase("QSQLITE")
    8con.setDatabaseName("/home/contacts.sqlite")
    9
dix# Créer l'application
11app = QApplication(sys.argv)
12
13# Essayez d'ouvrir la connexion et de gérer les erreurs possibles
14si ne pas con.ouvert():
15    QMessageBox.critique(
16        Aucun,
17        "Nom de l'application - Erreur!",
18        "Erreur de la base de données: % s" % con.lastError().databaseText(),
19    )
20    sys.sortie(1)
21
22# Créer la fenêtre de l'application
23gagner = QLabel("Connexion ouverte avec succès!")
24gagner.setWindowTitle("Nom de l'application")
25gagner.redimensionner(200, 100)
26gagner.montrer()
27sys.sortie(app.exec_())

le si l'instruction à la ligne 14 vérifie si la connexion a échoué. Si la /domicile/ le répertoire n’existe pas ou si vous n’avez pas la permission d’y écrire, alors l’appel à .ouvert() échoue car le fichier de base de données ne peut pas être créé. Dans cette situation, le flux d'exécution entre le si bloc de code d'instruction et affiche un message à l'écran.

Si vous modifiez le chemin vers un autre répertoire dans lequel vous pouvez écrire, l'appel à .ouvert() réussira et vous verrez une fenêtre affichant le message Connexion ouverte avec succès! Vous aurez également un nouveau fichier de base de données appelé contacts.sqlite dans le répertoire sélectionné.

Notez que vous passez Aucun comme le message parent car, au moment de l’affichage du message, vous n’avez pas encore créé de fenêtre. Vous n’avez donc pas de parent viable pour la boîte de message.

Exécution de requêtes SQL statiques

Pour commencer à créer et exécuter des requêtes avec PyQt, vous allez lancer votre éditeur de code ou IDE préféré et créer un script Python appelé queries.py. Enregistrez le script et ajoutez-y le code suivant:

    1importer sys
    2
    3de PyQt5.QtSql importer QSqlDatabase, QSqlQuery
    4
    5# Créer la connexion
    6con = QSqlDatabase.addDatabase("QSQLITE")
    septcon.setDatabaseName("contacts.sqlite")
    8
    9# Ouvrez la connexion
dixsi ne pas con.ouvert():
11    impression("Erreur de la base de données: % s" % con.lastError().databaseText())
12    sys.sortie(1)
13
14# Créez une requête et exécutez-la tout de suite en utilisant .exec ()
15createTableQuery = QSqlQuery()
16createTableQuery.exec(
17    "" "
18                CREATE TABLE contacts (
19                                id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NON NULL,
20                                nom VARCHAR (40) NOT NULL,
21                                emploi VARCHAR (50),
22                                email VARCHAR (40) NOT NULL
23                )
24                "" "
25)
26
27impression(con.les tables())

Dans ce script, vous commencez par importer les modules et les classes avec lesquels vous allez travailler. Ensuite, vous créez une connexion à la base de données en utilisant .addDatabase () avec le pilote SQLite. Vous définissez le nom de la base de données sur "contacts.sqlite" et ouvrez la connexion.

Pour créer votre première requête, vous instanciez QSqlQuery sans aucun argument. Avec l'objet de requête en place, vous appelez .exec (), en passant une requête SQL basée sur une chaîne comme argument. Ce type de requête est appelé requête statique car il n'obtient aucun paramètre extérieur à la requête.

La requête SQL ci-dessus crée une nouvelle table appelée Contacts dans votre base de données. Ce tableau comportera les quatre colonnes suivantes:

La dernière ligne du script ci-dessus imprime la liste des tables contenues dans votre base de données. Si vous exécutez le script, vous noterez qu’un nouveau fichier de base de données appelé contacts.sqlite est créé dans votre répertoire actuel. Vous obtiendrez également quelque chose comme ['contacts', 'sqlite_sequence'] imprimé sur votre écran. Cette liste contient les noms des tables de votre base de données.

Appel .exec () sur un QSqlQuery object est un moyen courant d'exécuter immédiatement des requêtes SQL basées sur des chaînes sur vos bases de données, mais que se passe-t-il si vous souhaitez préparer vos requêtes à l'avance pour une exécution ultérieure? C'est le sujet de la section suivante.

Exécution de requêtes dynamiques: formatage de chaîne

Jusqu'à présent, vous avez appris à exécuter des requêtes statiques sur une base de données. Les requêtes statiques sont celles qui n'acceptent pas paramètres, donc la requête s'exécute telle quelle. Même si ces requêtes sont assez utiles, vous devez parfois créer des requêtes qui récupèrent des données en réponse à certains paramètres d'entrée.

Les requêtes qui acceptent des paramètres au moment de l'exécution sont appelées requêtes dynamiques. L'utilisation de paramètres vous permet d'affiner la requête et de récupérer des données en réponse à des valeurs de paramètres spécifiques. Des valeurs différentes produiront des résultats différents. Vous pouvez prendre des paramètres d'entrée dans une requête en utilisant l'une des deux approches suivantes:

1. Créez la requête de manière dynamique, en utilisant la mise en forme de chaîne pour interpoler les valeurs des paramètres.
2. Préparez la requête à l'aide de paramètres d'espace réservé, puis liez des valeurs spécifiques à des paramètres.

La première approche vous permet de créer rapidement des requêtes dynamiques. Cependant, pour utiliser cette approche en toute sécurité, vous devez vous assurer que les valeurs de vos paramètres proviennent d'une source fiable. Sinon, vous risquez de faire face à des attaques par injection SQL.

Voici un exemple d'utilisation de la mise en forme de chaîne pour créer des requêtes dynamiques dans PyQt:

>>> de PyQt5.QtSql importer QSqlQuery, QSqlDatabase

>>> con = QSqlDatabase.addDatabase("QSQLITE")
>>> con.setDatabaseName("contacts.sqlite")
>>> con.ouvert()
Vrai

>>> Nom = «Linda»
>>> emploi = "Responsable technique"
>>> email = "linda@example.com"

>>> requete = QSqlQuery()
>>> requete.exec(
...     F"" "INSÉRER DANS les contacts (nom, travail, e-mail)
...                 VALEURS ('Nom','emploi','email') "" "
... )
Vrai

Dans cet exemple, vous utilisez une chaîne f pour créer une requête dynamique en interpolant des valeurs spécifiques dans une requête SQL basée sur une chaîne. La requête finale insère des données dans votre Contacts table, qui contient désormais des données sur Linda.

Notez que pour que ce type de requête dynamique fonctionne, vous devez vous assurer que les valeurs à insérer ont le bon type de données. Ainsi, vous utilisez des guillemets simples autour de l'espace réservé dans la chaîne f car ces valeurs doivent être des chaînes.

Exécution de requêtes dynamiques: paramètres d'espace réservé

La deuxième approche pour exécuter des requêtes dynamiques vous oblige à préparer vos requêtes au préalable à l'aide d'un modèle avec espaces réservés pour les paramètres. PyQt prend en charge deux styles d'espace réservé de paramètre:

1. Style Oracle utilise des espaces réservés nommés tels que :Nom ou :email.
2. Style ODBC utilise un point d'interrogation (?) en tant qu'espace réservé de position.

Notez que ces styles ne peuvent pas être mélangés dans la même requête. Vous pouvez consulter Approches to Binding Values ​​pour obtenir des exemples supplémentaires sur l'utilisation des espaces réservés.

Pour créer ce type de requête dynamique dans PyQt, vous créez d'abord un modèle avec un espace réservé pour chaque paramètre de requête, puis passez ce modèle en tant qu'argument à .préparer(), qui analyse, compile et prépare le modèle de requête pour l'exécution. Si le modèle a des problèmes, tels qu'une erreur de syntaxe SQL, alors .préparer() ne parvient pas à compiler le modèle et retourne Faux.

Si le processus de préparation réussit, alors préparer() Retour Vrai. Après cela, vous pouvez transmettre une valeur spécifique à chaque paramètre en utilisant .bindValue () avec des paramètres nommés ou positionnels ou en utilisant .addBindValue () avec des paramètres de position. .bindValue () a les deux variantes suivantes:

1. .bindValue (espace réservé, val)
2. .bindValue (pos, val)

Dans la première variante, espace réservé représente un espace réservé de style Oracle. Dans la deuxième variante, pos représente un nombre entier de base zéro avec la position d'un paramètre dans la requête. Dans les deux variantes, val contient la valeur à lier à un paramètre spécifique.

.addBindValue () ajoute une valeur à la liste des espaces réservés à l'aide de la liaison positionnelle. Cela signifie que l'ordre des appels à .addBindValue () détermine quelle valeur sera liée à chaque paramètre d'espace réservé dans la requête préparée.

Pour commencer à utiliser des requêtes préparées, vous pouvez préparer un INSÉRER DANS Instruction SQL pour remplir votre base de données avec des exemples de données. Revenez au script que vous avez créé dans la section Exécution de requêtes SQL statiques et ajoutez le code suivant juste après l'appel à impression():

28# Création d'une requête pour une exécution ultérieure en utilisant .prepare ()
29insertDataQuery = QSqlQuery()
30insertDataQuery.préparer(
31    "" "
32                INSÉRER DANS les contacts (
33                                Nom,
34                                emploi,
35                                email
36                )
37                VALEURS (?, ?, ?)
38                "" "
39)
40
41# Exemple de données
42Les données = [[[[
43    («Joe», "Développeur Web Senior", "joe@example.com"),
44    («Lara», "Gestionnaire de projet", "lara@example.com"),
45    («David», "Analyste de données", "david@example.com"),
46    ("Jeanne", "Développeur Python senior", "jane@example.com"),
47]
48
49# Utilisez .addBindValue () pour insérer des données
50pour Nom, emploi, email dans Les données:
51    insertDataQuery.addBindValue(Nom)
52    insertDataQuery.addBindValue(emploi)
53    insertDataQuery.addBindValue(email)
54    insertDataQuery.exec()

La première étape consiste à créer un QSqlQuery objet. Alors tu appelles .préparer() sur l'objet de requête. Dans ce cas, vous utilisez le style ODBC pour les espaces réservés. Votre requête prendra des valeurs pour votre contact Nom, emploi, et email, vous avez donc besoin de trois espaces réservés. Depuis le id column est un nombre entier auto-incrémenté, vous n'avez pas besoin de lui fournir de valeurs.

Ensuite, vous créez des exemples de données pour remplir la base de données. Les données contient une liste de tuples et chaque tuple contient trois éléments: le nom, le travail et l'adresse e-mail de chaque contact.

La dernière étape consiste à lier les valeurs que vous souhaitez transmettre à chaque espace réservé, puis à appeler .exec () pour exécuter la requête. Pour ce faire, vous utilisez un pour boucle. L'en-tête de boucle décompresse chaque tuple dans Les données en trois variables distinctes avec des noms pratiques. Alors tu appelles .addBindValue () sur l'objet de requête pour lier les valeurs aux espaces réservés.

Notez que vous utilisez espaces réservés de position, donc l'ordre dans lequel vous appelez .addBindValue () définira l'ordre dans lequel chaque valeur est passée à l'espace réservé correspondant.

Cette approche de création de requêtes dynamiques est pratique lorsque vous souhaitez personnaliser vos requêtes à l'aide de valeurs provenant de l'entrée de votre utilisateur. Chaque fois que vous utilisez l'entrée de l'utilisateur pour effectuer une requête sur une base de données, vous êtes confronté au risque de sécurité de l'injection SQL.

Dans PyQt, combiner .préparer(), .bindValue (), et .addBindValue () vous protège entièrement contre les attaques par injection SQL, c'est donc la voie à suivre lorsque vous prenez des entrées non fiables pour terminer vos requêtes.

Parcourir les enregistrements dans une requête

Si vous exécutez un SÉLECTIONNER déclaration, alors votre QSqlQuery object récupérera zéro ou plusieurs enregistrements d'une ou plusieurs tables de votre base de données. La requête contiendra des enregistrements contenant des données correspondant aux critères de la requête. Si aucune donnée ne correspond aux critères, votre requête sera vide.

QSqlQuery fournit un ensemble de méthodes de navigation que vous pouvez utiliser pour vous déplacer dans les enregistrements dans un résultat de requête:

Toutes ces méthodes positionnent l'objet de requête sur l'enregistrement extrait si cet enregistrement est disponible. La plupart de ces méthodes ont des règles spécifiques qui s'appliquent lors de leur utilisation. Avec ces méthodes, vous pouvez avancer, reculer ou arbitrairement dans les enregistrements d'un résultat de requête. Puisqu'ils reviennent tous soit Vrai ou Faux, vous pouvez les utiliser dans un tandis que boucle pour parcourir tous les enregistrements en une seule fois.

Ces méthodes fonctionnent avec requêtes actives. Une requête est active lorsque vous l'avez exécutée avec succès .exec () dessus, mais la requête n’est pas encore terminée. Une fois qu'une requête active se trouve sur un enregistrement valide, vous pouvez récupérer les données de cet enregistrement en utilisant .value (index). Cette méthode prend un nombre entier de base zéro, indiceet renvoie la valeur à cet index (colonne) dans l'enregistrement en cours.

Vous trouverez ci-dessous quelques exemples d'utilisation de certaines des méthodes de navigation pour vous déplacer dans une requête. Mais d'abord, vous devez créer une connexion à votre base de données:

>>> de PyQt5.QtSql importer QSqlDatabase, QSqlQuery

>>> con = QSqlDatabase.addDatabase("QSQLITE")
>>> con.setDatabaseName("contacts.sqlite")
>>> con.ouvert()
Vrai

Ici, vous créez et ouvrez une nouvelle connexion à contacts.sqlite. Si vous avez suivi ce didacticiel jusqu'à présent, cette base de données contient déjà des exemples de données. Vous pouvez maintenant créer un QSqlQuery objet et exécutez-le sur ces données:

>>> # Créer et exécuter une requête
>>> requete = QSqlQuery()
>>> requete.exec("CHOISIR le nom, le poste, l'e-mail FROM contacts")
Vrai

Cette requête récupère des données sur Nom, emploi, et email de tous les contacts stockés dans le Contacts table. Depuis .exec () revenu Vrai, la requête a réussi et est maintenant une requête active. Vous pouvez parcourir les enregistrements de cette requête à l'aide de l'une des méthodes de navigation que vous avez vues auparavant. Vous pouvez également récupérer les données dans n'importe quelle colonne d'un enregistrement en utilisant .valeur():

>>> # Premier enregistrement
>>> requete.première()
Vrai

>>> # Index nommés pour la lisibilité
>>> Nom, emploi, email = intervalle(3)

>>> # Récupérer les données du premier enregistrement
>>> requete.valeur(Nom)
«Linda»

>>> # Enregistrement suivant
>>> requete.prochain()
Vrai
>>> requete.valeur(emploi)
'Développeur Web senior'

>>> # Dernier enregistrement
>>> requete.dernier()
Vrai
>>> requete.valeur(email)
«jane@example.com»

Avec les méthodes de navigation, vous pouvez vous déplacer dans le résultat de la requête. Avec .valeur(), vous pouvez récupérer les données dans n'importe quelle colonne d'un enregistrement donné.

Vous pouvez également parcourir tous les enregistrements de votre requête à l'aide d'un tandis que boucle avec .prochain():

>>> requete.exec()
Vrai

>>> tandis que requete.prochain():
...     impression(requete.valeur(Nom), requete.valeur(emploi), requete.valeur(email))
...
Linda Responsable technique linda@example.com
Joe Développeur Web senior joe@example.com
...

Avec .prochain(), vous parcourez tous les enregistrements dans un résultat de requête. .prochain() fonctionne de manière similaire au protocole itérateur en Python. Une fois que vous avez parcouru les enregistrements dans un résultat de requête, .prochain() commence à revenir Faux jusqu'à ce que vous couriez .exec () encore. Un appel à .exec () récupère les données d'une base de données et place le pointeur interne de l'objet de requête une position avant le premier enregistrement, donc lorsque vous appelez .prochain(), vous obtenez à nouveau le premier enregistrement.

Vous pouvez également effectuer une boucle dans l'ordre inverse en utilisant .précédent():

>>> tandis que requete.précédent():
...     impression(requete.valeur(Nom), requete.valeur(emploi), requete.valeur(email))
...
Jane Développeur Python senior jane@example.com
David Data Analyst david@example.com
...

.précédent() fonctionne comme .prochain(), mais l'itération se fait dans l'ordre inverse. En d’autres termes, la boucle va de la position du pointeur de requête au premier enregistrement.

Parfois, vous souhaiterez peut-être obtenir l'index qui identifie une colonne donnée dans une table en utilisant le nom de cette colonne. Pour ce faire, vous pouvez appeler .Indice de() sur la valeur de retour de .record():

>>> requete.première()
Vrai

>>> # Récupère l'index du nom
>>> Nom = requete.record().Indice de("Nom")

>>> requete.valeur(Nom)
«Linda»

>>> # Terminez l'objet de requête si cela n'est pas nécessaire
>>> requete.terminer()
>>> requete.c'est actif()
Faux

L'appel à .Indice de() sur le résultat de .record() renvoie l'index du "Nom" colonne. Si "Nom" n'existe pas, alors .Indice de() Retour -1. Ceci est pratique lorsque vous utilisez un SÉLECTIONNER * instruction dans laquelle l'ordre des colonnes est inconnu. Enfin, si vous en avez terminé avec un objet de requête, vous pouvez le désactiver en appelant .terminer(). Cela libérera la mémoire système associée à l'objet de requête en question.

Comprendre l'architecture Model-View de PyQt

Le modèle de conception Model-View-Controller (MVC) est un modèle logiciel général destiné à diviser le code d’une application en trois couches générales, chacune ayant un rôle différent.

le modèle prend en charge la logique métier de l'application, le vue fournit des représentations à l'écran et le manette relie le modèle et la vue pour faire fonctionner l'application.

Qt fournit une variante personnalisée de MVC. Ils l'appellent l'architecture Model-View, et elle est également disponible pour PyQt. Le modèle sépare également la logique en trois composants:

1. Des modèles communiquer et accéder aux données. Ils définissent également une interface qui est utilisée par les vues et les délégués pour accéder aux données. Tous les modèles sont basés sur QAbstractItemModel. Certains modèles couramment utilisés incluent QStandardItemModel, QFileSystemModelet les modèles liés à SQL.

2. Vues sont responsables de l'affichage des données à l'utilisateur. Ils ont également des fonctionnalités similaires à celles du contrôleur dans le modèle MVC. Toutes les vues sont basées sur QAbstractItemView. Certaines vues couramment utilisées sont QListView, QTableView, et QTreeView.

3. Délégués peignez les éléments de vue et fournissez des widgets d'édition pour modifier les éléments. Ils communiquent également avec le modèle si un élément a été modifié. La classe de base est QAbstractItemDelegate.

La séparation des classes en ces trois composants implique que les modifications apportées aux modèles seront automatiquement répercutées sur les vues ou widgets associés, et les modifications apportées aux vues ou aux widgets via des délégués mettront à jour automatiquement le modèle sous-jacent.

De plus, vous pouvez afficher les mêmes données dans différentes vues sans avoir besoin de plusieurs modèles.

Utilisation des classes de widgets standard

PyQt fournit un tas de widgets standard pour afficher et modifier les données dans vos applications GUI. Ces widgets standard fournissent des vues telles que des tables, des arborescences et des listes. Ils fournissent également un conteneur interne pour stocker les données et des délégués pratiques pour éditer les données. Toutes ces fonctionnalités sont regroupées dans une seule classe.

Voici trois de ces classes standard:

QTableWidget est sans doute le widget le plus populaire pour l'affichage et l'édition de données. Il crée un tableau 2D de QTableWidgetItem objets. Chaque élément contient une valeur individuelle sous forme de chaîne. Toutes ces valeurs sont affichées et organisées dans un tableau de lignes et de colonnes.

Vous pouvez effectuer au moins les opérations suivantes sur un QTableWidget objet:

Voici un exemple d'application qui montre comment utiliser un QTableWidget objet pour afficher les données dans une interface graphique. L'application utilise la base de données que vous avez créée et remplie dans les sections précédentes, donc si vous souhaitez l'exécuter, vous devez enregistrer le code dans le même répertoire dans lequel vous avez le contacts.sqlite base de données:

Si vous double-cliquez sur une cellule du tableau, vous pourrez modifier le contenu de la cellule. Cependant, vos modifications ne seront pas enregistrées dans votre base de données.

Voici le code de votre application:

    1importer sys
    2
    3de PyQt5.QtSql importer QSqlDatabase, QSqlQuery
    4de PyQt5.QtWidgets importer (
    5    QApplication,
    6    QMainWindow,
    sept    QMessageBox,
    8    QTableWidget,
    9    QTableWidgetItem,
dix)
11
12classe Contacts(QMainWindow):
13    def __init__(soi, parent=Aucun):
14        super().__init__(parent)
15        soi.setWindowTitle("Exemple QTableView")
16        soi.redimensionner(450, 250)
17        # Configurer la vue et charger les données
18        soi.vue = QTableWidget()
19        soi.vue.setColumnCount(4)
20        soi.vue.setHorizontalHeaderLabels([[[["ID", "Nom", "Emploi", "Email"])
21        requete = QSqlQuery("CHOISIR l'identifiant, le nom, le poste, l'e-mail FROM contacts")
22        tandis que requete.prochain():
23            Lignes = soi.vue.rowCount()
24            soi.vue.setRowCount(Lignes + 1)
25            soi.vue.setItem(Lignes, 0, QTableWidgetItem(str(requete.valeur(0))))
26            soi.vue.setItem(Lignes, 1, QTableWidgetItem(requete.valeur(1)))
27            soi.vue.setItem(Lignes, 2, QTableWidgetItem(requete.valeur(2)))
28            soi.vue.setItem(Lignes, 3, QTableWidgetItem(requete.valeur(3)))
29        soi.vue.resizeColumnsToContents()
30        soi.setCentralWidget(soi.vue)
31
32def createConnection():
33    con = QSqlDatabase.addDatabase("QSQLITE")
34    con.setDatabaseName("contacts.sqlite")
35    si ne pas con.ouvert():
36        QMessageBox.critique(
37            Aucun,
38            "Exemple QTableView - Erreur!",
39            "Erreur de la base de données: % s" % con.lastError().databaseText(),
40        )
41        revenir Faux
42    revenir Vrai
43
44app = QApplication(sys.argv)
45si ne pas createConnection():
46    sys.sortie(1)
47gagner = Contacts()
48gagner.montrer()
49sys.sortie(app.exec_())

Voici ce qui se passe dans cet exemple:

• Lignes 18 à 20 créer un QTableWidget objet, définissez le nombre de colonnes sur 4et définissez des libellés conviviaux pour l'en-tête de chaque colonne.
• Ligne 21 crée et exécute un SÉLECTIONNER Requête SQL sur votre base de données pour obtenir toutes les données du Contacts table.
• Ligne 22 commence un tandis que boucle pour parcourir les enregistrements dans le résultat de la requête en utilisant .prochain().
• Ligne 24 incrémente le nombre de lignes du tableau de 1 en utilisant .setRowCount ().
• Lignes 25 à 28 ajouter des éléments de données à votre tableau en utilisant .setItem (). Notez que puisque les valeurs du id les colonnes sont des nombres entiers, vous devez les convertir en chaînes pour pouvoir les stocker dans un QTableWidgetItem objet.

.setItem () prend trois arguments:

1. rangée contient un entier de base zéro qui représente l'index d'une ligne donnée dans la table.
2. colonne contient un entier de base zéro qui représente l'index d'une colonne donnée dans la table.
3. article détient le QTableWidgetItem objet que vous devez placer dans une cellule donnée du tableau.

Enfin, vous appelez .resizeColumnsToContents () sur votre vue pour ajuster la taille des colonnes à leur contenu et offrir un meilleur rendu des données.

L'affichage et la modification des tables de base de données à l'aide de widgets standard peuvent devenir une tâche difficile. C'est parce que vous aurez deux copies des mêmes données. En d'autres termes, vous disposerez d'une copie des données à deux emplacements:

1. En dehors du widget, dans votre base de données
2. À l'intérieur du widget, dans les conteneurs internes du widget

Vous êtes responsable de la synchronisation manuelle des deux copies de vos données, ce qui peut être une opération ennuyeuse et sujette à des erreurs. Heureusement, vous pouvez utiliser l'architecture Model-View de PyQt pour éviter la plupart de ces problèmes, comme vous le verrez dans la section suivante.

Utilisation des classes de vue et de modèle

Les classes Model-View de PyQt éliminent les problèmes de duplication et de synchronisation des données qui peuvent survenir lorsque vous utilisez des classes de widget standard pour créer des applications de base de données. L'architecture Model-View vous permet d'utiliser plusieurs vues pour afficher les mêmes données car vous pouvez transmettre un modèle à plusieurs vues.

Les classes de modèle fournissent une interface de programmation d'application (API) que vous pouvez utiliser pour manipuler des données. Les classes View fournissent des objets délégués pratiques que vous pouvez utiliser pour modifier directement les données dans la vue. Pour connecter une vue à un module donné, vous devez appeler .setModel () sur l'objet de vue.

PyQt propose un ensemble de classes de vue qui prennent en charge l'architecture Model-View:

Vous pouvez utiliser ces classes de vue avec des classes de modèle pour créer vos applications de base de données. Cela rendra vos applications plus robustes, plus rapides à coder et moins sujettes aux erreurs.

Voici quelques-unes des classes de modèle fournies par PyQt pour travailler avec des bases de données SQL:

Une fois que vous avez connecté l'un de ces modèles à une table ou une requête de base de données physique, vous pouvez les utiliser pour remplir vos vues. Les vues fournissent des objets délégués qui vous permettent de modifier les données directement dans la vue. Le modèle connecté à la vue mettra à jour les données de votre base de données pour refléter tout changement dans la vue. Notez que vous n'avez pas à mettre à jour manuellement les données de la base de données. Le modèle le fera pour vous.

Voici un exemple qui montre les bases de l’utilisation d’un QTableView objet et un QSqlTableModel objet ensemble pour créer une application de base de données à l'aide de l'architecture Model-View de PyQt:

Pour modifier les données dans une cellule du tableau, vous pouvez double-cliquer sur la cellule. Un widget délégué pratique s'affichera dans la cellule, vous permettant de modifier son contenu. Ensuite, vous pouvez frapper Entrer pour enregistrer les modifications.

La possibilité de gérer et d’enregistrer automatiquement les modifications des données est l’un des avantages les plus importants de l’utilisation des classes Model-View de PyQt. L'architecture Model-View améliorera votre productivité et réduira les erreurs qui peuvent apparaître lorsque vous devez écrire vous-même du code de manipulation de données.

Voici le code pour créer l'application:

    1importer sys
    2
    3de PyQt5.QtCore importer Qt
    4de PyQt5.QtSql importer QSqlDatabase, QSqlTableModel
    5de PyQt5.QtWidgets importer (
    6    QApplication,
    sept    QMainWindow,
    8    QMessageBox,
    9    QTableView,
dix)
11
12classe Contacts(QMainWindow):
13    def __init__(soi, parent=Aucun):
14        super().__init__(parent)
15        soi.setWindowTitle("Exemple QTableView")
16        soi.redimensionner(415, 200)
17        # Configurer le modèle
18        soi.modèle = QSqlTableModel(soi)
19        soi.modèle.setTable("Contacts")
20        soi.modèle.setEditStrategy(QSqlTableModel.OnFieldChange)
21        soi.modèle.setHeaderData(0, Qt.Horizontal, "ID")
22        soi.modèle.setHeaderData(1, Qt.Horizontal, "Nom")
23        soi.modèle.setHeaderData(2, Qt.Horizontal, "Emploi")
24        soi.modèle.setHeaderData(3, Qt.Horizontal, "Email")
25        soi.modèle.sélectionner()
26        # Configurer la vue
27        soi.vue = QTableView()
28        soi.vue.setModel(soi.modèle)
29        soi.vue.resizeColumnsToContents()
30        soi.setCentralWidget(soi.vue)
31
32def createConnection():
33    con = QSqlDatabase.addDatabase("QSQLITE")
34    con.setDatabaseName("contacts.sqlite")
35    si ne pas con.ouvert():
36        QMessageBox.critique(
37            Aucun,
38            "Exemple QTableView - Erreur!",
39            "Erreur de la base de données: % s" % con.lastError().databaseText(),
40        )
41        revenir Faux
42    revenir Vrai
43
44app = QApplication(sys.argv)
45si ne pas createConnection():
46    sys.sortie(1)
47gagner = Contacts()
48gagner.montrer()
49sys.sortie(app.exec_())

Voici ce qui se passe dans ce code:

• Ligne 18 crée un modifiable QSqlTableModel objet.
• Ligne 19 connecte votre modèle avec le Contacts table dans votre base de données en utilisant .setTable ().
• Ligne 20 définit la stratégie d'édition du modèle sur OnFieldChange. Cette stratégie permet au modèle de mettre à jour automatiquement les données de votre base de données si l'utilisateur modifie l'une des données directement dans la vue.
• Lignes 21 à 24 définir des étiquettes conviviales sur les en-têtes horizontaux du modèle en utilisant .setHeaderData ().
• Ligne 25 charge les données de votre base de données et remplit le modèle en appelant .sélectionner().
• Ligne 27 crée l'objet de vue de table pour afficher les données contenues dans le modèle.
• Ligne 28 connecte la vue au modèle en appelant .setModel () sur la vue avec votre modèle de données comme argument.
• Ligne 29 appels .resizeColumnsToContents () sur l'objet de vue pour ajuster le tableau à son contenu.

C'est ça! Vous disposez désormais d'une application de base de données entièrement fonctionnelle.