'PRESENTATION DU MODULE SQLITE3.

Le module sqlite3 permet de générer, de modifier, d'afficher des bases de données non distantes.

sqlite3 est un module de la bibliothèque standard de Python 3. Il est donc toujours disponible.

GENERALITES SUR LES BASES DONNEES. 

On appelle base données un ensemble d'informations organisées dans des structures. Une base de données stockée et accessible depuis un système informatique sera gérée et controlée par l'intermédiaire d'un Système de Gestion de Base de Données, généralement désigné par DBMS, ou SGBD en français, via des applications dédiées à cette pratique.

Grossièrement, une base de donnée moderne, sera composée de tables, tableaux. Une table regroupera des enregistrements, fiches, lignes, entrées. Un enregistrement comportera des champs pour saisir, renseigner, puis mémoriser, enregistrer ses caractéristiques propres. Une table peut être représentée par une grille, où chaque ligne est un enregistrement et chaque colonne un champ de saisie. 

Plusieurs tables, d"une même base de données, peuvent avoir un champs de saisie commun, grâce auquel elles pourront associer certaines de leurs informations pour créer des tables temporaires et les restituer à l'utilisateur qui aura soumis une requête à la base de données.

Pour plus de détails sur les SGBD (Système de Gestion des Bases de Données) consultez le site officiel de SQLite.

UTILISATION DU MODULE SQLITE3. 

Comme toujours, la première chose a faire est d'importer le module sqlite3 en début de script pour pouvoir utiliser toutes ses méthodes.

import sqlite3 # importation des classes et méthodes du module sqlite3

CONNEXION A UNE BASE DE DONNEES.

Ensuite, il vous faudra créer un objet connexion, qui vous permettra de dialoguer avec une base de données spécifique, grâce à la méthode sqlite3.connect ( ), en utilisant la syntaxe générale :

 objet = sqlite3.connect ( VotreBase ), où : 

- objet permettra d'identifier la connexion dans le script durant la vie de celle-ci ;

- sqlite3.connect ( ), appel de la méthode qui créer et initialise objet ;

- VotreBase est la désignation de la base de données liée à objet.

Par défaut, l'appel de la méthode sqlite3.connect ( ) va créer un objet en invoquant le constructeur de classe sqlite3.Connection ( ). et retournera les valeurs des données dans des tuple ( ). Il est cependant tout a fait possible d'utiliser d'autres types d'objets, valides et compatibles, en le modifiant le l'attribut factory = NouveauType lors de l'appel, voir ci dessous pour plus de détails.

La méthode  sqlite3.connect ( ) attend comme argument le nom du fichier contenant la base de données. Le nom de fichier peut être relatif, dans le répertoire de travail actuel, ou absolu, dans un autre répertoire et/ou sur un autre lecteur. Si le fichier n'existe pas, à l'emplacement indiqué, il sera créé automatiquement. Vous disposez aussi de la possibilité de travailler avec une base de données éphémère, en mémoire vive, en donnant la valeur ":memory:" à la place d'un nom de fichier. Dans ce cas, la base de données sera détruite, perdue) à la fermeture du programme.

import sqlite3 

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" ) # création d'un objet connexion lié à la base de données

Pour briser le lien entre la base de données et son objet-connexion, et ainsi préserver la base de données de dégradations, il faut utiliser la méthode objet.close ( ). Une bonne pratique est d’appeler cette méthode, dès maintenant cette méthode pour préparer une fermeture propre de la base de données. En cas d'erreur, par exemple durant la phase de conception et de tests de votre script, votre fichier ne subira pas, trop graves, de dommages en cas de déconnexion imprévue.

import sqlite3 

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" ) 

# --- 

# --- 

# --- 

BDD_Test.close ( ) # déconnexion de la basse de données avec son objet connexion

CREATION D'UN CURSEUR.

Pour interagir physiquement avec la base de données, connectée à un l'objet-connexion, il faut créer un, ou plusieurs, objet-curseur en utilisant la syntaxe générale curseur = objet.cursor ( ), où : 

- curseur permettra d'identifier le curseur de objet durant la vie de celui-ci ;

- objet est l'objet-connexion qui utilisera curseur ;

- sqlite3.cursor ( ), appel de la méthode qui créer et initialise curseur.

Il faudra ensuite faire appel à la méthode curseur.execute ( ) pour effectuer les commandes SQL. 

Allez à présentation des commandes SQL.

import sqlite3 

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" ) 

CUR_Test = BDD_Test.cursor ( ) # création d'un objet curseur pour interagir avec la base de données ---

# --- 

# --- 

# --- 

BDD_Test.close ( ) 

Il est aussi possible d'invoquer directement les constructeurs des classes sqlite3.Connection ( ) et sqlite3.Cursor ( ) indépendantes, pour travailler sur une base de données. A Noter que dans ce cas, les méthodes feront appel aux classes instanciées, mais que les syntaxes reste identiques, sauf qu'il faudra aussi fermer l'objet-curseur avant la deconnexion de l'objet-connexion. Par exemple de la façon suivante :

import sqlite3 

BDD_Test = sqlite3.Connection ( "ON - sgbd 01.db" ) # création d'un objet connexion lié à la base de données

CUR_Test = sqlite3.Cursor ( BDD_Test ) # création d'un objet curseur pour interagir avec la base de données

# --- 

# --- 

# --- 

CUR_Test.close ( ) # déconnexion de la basse de données avec son objet curseur

BDD_Test.close ( ) # déconnexion de la basse de données avec son objet connexion

ou :

import sqlite3

BDD_Test = sqlite3.Connection ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.Cursor ( )

# --- 

# --- 

# --- 

CUR_Test.close ( )

BDD_Test.close ( )

Pour travaillez sur plusieurs tables, provenant de la même base de données, et pour lier ces différentes tables grâces à des clés étrangères, il faut le précisez après la création de l'objet-curseur avec la commande SQL : " PRAGMA FOREIGN_KEYS = ON ".

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " PRAGMA FOREIGN_KEYS = ON " ) # définition de liaisons par clés étrangères

# --- 

# --- 

# --- 

BDD_Test.close ( )

CREATION DES TABLES DE LA BASES DE DONNEES.

Si une nouvelle base de données est créée lors de l'appel de la méthode sqlite3.connect ( ), il faut commencer par la création des tables (tableaux) qui lui seront utiles. Pour créer de nouvelles tables, avec leurs champs respectifs, dans une base de données on fera appel à la commande SQL : CREATE TABLE avec le schéma :

" CREATE TABLE IF NOT EXISTS nomdelatable ( champ1 type1, champ2 type2, ... , champn typen ) " 

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

# création d'une table MomCarnet et de ses champs

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " ) 

# création d'une table LesPrix et de ses champs

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " ) # création d'une table LesPrix et de ses champs

BDD_Test.close ( )

ENREGISTRER DES NOUVELLES ENTREES INDIVIDUELLEMENT.

Pour ajouter de nouvelles entrées on utilisera la commande SQL : INSERT avec le schéma :

" INSERT INTO nomdelatable ( champ1 , champ2 , ... , champn ) VALUES ( ? , ? , ... , ? ) " , valeurs 

où valeurs est un tuple ( ) contenant les valeurs des champs de la nouvelle fiche. Ces valeurs doivent être présentées dans le même ordre que celui donné par ( champ1 , champ2 , ... , champn ).

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kcliente = ( "Marie" , 158.5 , 58 ) # valeurs des données d'une fiche pour la table MonCarnet

# ajout d'une fiche dans la table MonCarnet avec les donnée de kcliente

CUR_Test.execute ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kcliente ) 

karticle = ( "Robe de soirée" , 119.99 , 20.3 ) # valeurs des données d'une fiche pour la table LesPrix

# ajout d'une fiche dans la table MonCarnet avec les donnée de kcliente

CUR_Test.execute ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticle )

BDD_Test.close ( )

Les commandes SQL faites dans un objet-curseur ne sont jamais prise en compte, sauvegardées, automatiquement par Python et son module sqlite3. Il faut donc utiliser l'appel de la méthode objet.commit ( ) après chaque modification d'une base de données ou d'un de ses éléments, sinon tous changements apportés resteront dans le tampon de l'objet-curseur et seront perdus après l'arrêt du programme.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kcliente = ( "Marie" , 158.5 , 58 ) 

CUR_Test.execute ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kcliente ) 

BDD_Test.commit ( ) # sauvegarde de toutes les modifications faites à la base de données

karticle = ( "Robe de soirée" , 119.99 , 20.3 ) 

CUR_Test.execute ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticle )

BDD_Test.commit ( ) # sauvegarde de toutes les modifications faites à la base de données

BDD_Test.close ( )

ENREGISTRER DES NOUVELLES ENTREES COLLECTIVEMENT.

La méthode curseur.executemany ( ) de l'objet-curseur permet d'ajouter plusieurs nouveaux enregistrements dans une basse de données. Dans ce cas, il faut fournir une list ( ) où chaque élément est un tuple ( ) contenant les valeurs des données de chaque nouvelle fiche. Sans oublier de toujours suivre cet appel par l'utilisation de la méthode objet.commit ( ) pour sauvegarder les modifications.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

# valeurs des données de trois nouvelles fiches pour la table MonCarnet

kclientes = [ ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) ]

# ajout de trois nouvelles fiches dans la table MonCarnet avec les donnée de kclientes

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

# valeurs des données de trois nouvelles fiches pour la table LesPrix

karticles = [ ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

# ajout de trois nouvelles fiches dans la table LesPrix avec les donnée de karticles

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

BDD_Test.close ( )

PARCOURIR UNE TABLE D'UNE BASE DE DONNEES.

La commande SQL :  SELECT FROM avec le schéma :

" SELECT * FROM nomdelatable "

transfère dans la pile des résultats tous les enregistrements d'une table.

La méthode curseur.fetchall ( ) permet de récupérer, depuis cette pile, tous ces enregistrements dans une list ( ) composée de tuple ( ). Chaque tuple ( ) représente un enregistrement de la table, et les éléments d'un tuple ( ) retournent la valeur du champ correspondant. Si la pile des résultats est vide, la méthode curseur.fetchall ( )  retourne une list ( ) vide, [ ],

Après chaque appel de la méthode curseur.fetchall ( ), la pile des résultats est entièrement vidée, purgée, et il faudra utiliser une nouvelle requête, commande, pour obtenir de nouveaux enregistrements dans la pile des résultats. C'est pourquoi il est vivement conseillé de toujours affecter à une variable le contenue de la list ( ) retournée pour la méthode curseur.fetchall ( ), puis travaillez avec celle-ci comme n'importe quelle list ( ) de Python.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kclientes = [ ( "Marie" , 158.5 , 58 ) , ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) ]

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

CUR_Test.execute ( " SELECT * FROM MonCarnet " ) # transfère tous les entées de MonCarnet dans le pile des résultats

print ( CUR_Test.fetchall ( ) ) # affiche tous les fiches présentes dans la pile des résultats

print ( CUR_Test.fetchall ( ) ) # affiche une list ( ) vide car la pile des résultats a été purgée par l'appel précédent

print ( type ( CUR_Test.fetchall ( ) ) ) # affiche le type de l'objet contenu dans la pile des résultats

CUR_Test.execute ( " SELECT * FROM LesPrix " ) # transfère tous les entées de LesPrix dans le pile des résultats

LST_Prix =  CUR_Test.fetchall ( ) # transfère tous les fiches de la pile des résultats dans la list ( ) LST_Prix

for kprix in LST_Prix :  # parcourt tous les éléments de LST_Prix

print ( f"Article : { kprix [ 0 ] } - Désignation : { kprix [ 1 ] } - Prix Hors Taxe : { kprix [ 2 ] } - Taux de T.V.A. à appliquer : { kprix [ 3 ] }" ) # affiche les caractéristiques de chaque fiche dans une expression formatée

BDD_Test.close ( )

Il est aussi possible de récupérer les enregistrements un par un, en utilisant plusieurs fois la méthode curseur.fetchone ( ) à la place curseur.fetchall ( ). Dans ce cas, un unique tuple ( ) est retourné, contenant uniquement les valeurs de la fiche au dessus de la pile des résultats. 

La fiche retournée par l'appel de la curseur.fetchone ( ) est retirée de la pile des résultats, et ses données ne seront plus accessibles, sans nouvelle requête, si on ne les a pas affectées à un nom de variable. Si la pile des résultats est vide, la méthode curseur.fetchone ( )  retourne un tuple ( ) vide, ( ),

Si cela peut être utile pour connaitre rapidement, les valeurs de la première fiche présente dans la pile des résultats, par exemple après un tri, cette pratique montre vite ses limites, et n'est donc pas conseillée sauf dans le cas où l'on souhaite aussi récupérer les noms des colonnes (voir plus bas).

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kclientes = [ ( "Marie" , 158.5 , 58 ) , ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) ]

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

CUR_Test.execute ( " SELECT * FROM MonCarnet " )

print ( CUR_Test.fetchone ( ) ) # affiche la fiches au dessus de la pile des résultats et la sort de la pile des résultat

print ( CUR_Test.fetchone ( ) ) # affiche la fiches au dessus de la pile des résultats et la sort de la pile des résultat

print ( CUR_Test.fetchone ( ) ) # affiche la fiches au dessus de la pile des résultats et la sort de la pile des résultat 

print ( CUR_Test.fetchone ( ) ) # affiche la fiches au dessus de la pile des résultats et la sort de la pile des résultat

CUR_Test.execute ( " SELECT * FROM LesPrix " )

karticle = CUR_Test.fetchone ( ) # transfère la fiches au dessus de la pile des résultats dans karticle et la sort de la pile

while karticle : # répète la séquence tant que karticle n'est pas un tuple ( ) vide

    print ( karticle )

    karticle = CUR_Test.fetchone ( ) # affiche la fiches au dessus de la pile des résultats et la sort de la pile des résultat

BDD_Test.close ( )

La méthode curseur.fetchmany ( ) retourne le nombre de fiches précisé par le script, ou l'utilisateur, suivantes dans la pile de résultats. Si la quantité d'enregistrements demandée est supérieurs aux éléments présents dans la pile des résultats, seuls ceux-ci seront retournés dans la list ( ). De même, si la pile des résultats est vide, la méthode curseur.fetchmany ( ) retournera une une list ( ) vide, [ ]. Si aucune quantité n'est donnée lors de l'appel la méthode la méthode curseur.fetchmany ( ) seule la fiche suivante dans la pile des résultats sera transmise.

Cette technique permet de "tronçonner" la liste des fiches présentes dans une table de grande taille afin de mieux en faire les traitements ou une présentation adaptée aux besoins de l'utilisateur.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kclientes = [ ( "Marie" , 158.5 , 58 ) , ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) ]

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

CUR_Test.execute ( " SELECT * FROM MonCarnet " )

print ( CUR_Test.fetchone ( ) )

print ( CUR_Test.fetchmany ( 2 ) ) # affiche 2 fiches du dessus de la pile des résultats dans karticle et les sorts de la pile

print ( CUR_Test.fetchone ( ) )

BDD_Test.close ( )

MODIFIER LE TYPE DES OBJETS RETOURNES PAR UN CURSEUR.

Pour connaitre les entêtes des colonnes, ou noms des champs, il faut associer à l'attribut curseur.row_factory l'objet-ligne : sqlite3.Row. Les enregistrements retournées par le méthodes curseur.fetchall ( ),  curseur.fetchone ( ) et curseur.fetchmany ( ), ne seront plus des tuple ( ) avec la valeurs du champs des objets-ligne.

Un objet-ligne contient autant d'éléments, ayant la forme champ : valeur, qu'une la fiche de la table contient de champs. Bien qu'un objet-ligne ne soit pas un dict ( ), on pourra consulter ses éléments avec le mêmes protocoles de base. Par exemple, la méthode sqlite3.Row ( ).keys ( ) d'un objet-ligne retourne une list ( ) contenant toutes les clés des colonnes, c'est-à-dire les intitulés des champs de la table. On pourra ensuite, utiliser les éléments de cette list ( ) ou ses index pour retourner la valeur affectée à un champs de l'enregistrement.

La forme curseur.row_factory = None rétablit la forme par défaut de l'objet-curseur, qui retournera de nouveau des tuple ( ).

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Standard = BDD_Test.cursor ( )

CUR_Modifie = BDD_Test.cursor ( )

CUR_Complet = BDD_Test.cursor ( )

CUR_Modifie.row_factory = sqlite3.Row # modifie le type des objets retournés par les l'objet curseur

CUR_Complet.row_factory = sqlite3.Row # modifie le type des objets retournés par les l'objet curseur

CUR_Standard.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Standard.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

print ( "Avec le retour standard dans des tuple ( )" )

CUR_Standard.execute ( " SELECT * FROM LesPrix " )

kligne = CUR_Standard.fetchone ( )

print ( type ( kligne ) ) # affiche le type de l'objet retourné

print ( kligne ) # affiche le identification de l'objet retourné

print ( )

print ( "Avec le retour modifié pour obtenir des objets-lignes" )

CUR_Modifie.execute ( " SELECT * FROM LesPrix " )

kligne = CUR_Modifie.fetchone ( )

print ( type ( kligne ) ) # affiche le type de l'objet retourné

print ( kligne ) # affiche le identification de l'objet retourné

print ( kligne.keys ( ) ) # affiche dans une list ( ) tous les intitulés des champs

print ( kligne.keys ( ) [ 1 ] ) # affiche l'intitulé du deuxième champ, à l'index 1 dans la list ()

print ( kligne [ "Article" ] ) # affiche la valeur affectée au champ Article pour cet enregistrement

print ( )

for kintitule in kligne.keys ( ) : # pour toutes les clé présente dans l'objet-ligne

print ( "Le champ" , kintitule , "a pour valeur" , kligne [ kintitule ] ) # affiche pour chaque champ son intitulé et sa valeur

print ( )

print ( "Récupération de tous les enregistrement dans des objets_lignes" )

CUR_Complet.execute ( " SELECT * FROM LesPrix " )

klignes = CUR_Complet.fetchall ( )

for kligne in klignes : # pour toutes les clé présente dans l'objet-ligne

print ( "\nEnregistrement : " , kligne )

for kintitule in kligne.keys ( ) : # pour toutes les clé présente dans l'objet-ligne

print ( "Le champ" , kintitule , "a pour valeur" , kligne [ kintitule ] )

BDD_Test.close ( )

MODIFIER DES FICHES EXISTANTES.

Pour modifier une fiche, on invoque la commande SQL : UPDATE avec le schéma :

" UPDATE nomdelatable SET champ = nouvellevaleur WHERE champ = valeuractuelle "

où champ est le nom d'un champ présent dans la table et où nouvellevaleur et valeuractuelle sont de même type que celui défini lors de la création du champ. Rappel : les modifications ne seront pérennes qu'après l'appel de la méthode  objet.commit ( ) de l'objet-connexion qui inscrit les modifications apportées de la mémoire tampon vers le support physique de la base de données.

import sqlite3

def FNC_Lecture ( ) :

CUR_Test.execute ( " SELECT * FROM LesPrix " )

kmestarifs =  CUR_Test.fetchall ( )

for kprix in kmestarifs :

print ( f"{ kprix [ 0 ] } { kprix [ 1 ] } à { kprix [ 2 ] } (TVA { kprix [ 3 ] }%)" )

print ( )

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

print ( "Après la création" )

FNC_Lecture ( )

# dans la table LesPrix, si la valeur du champs PrixHT est 79.99, la modifier en 69,99

CUR_Test.execute ( " UPDATE LesPrix SET PrixHT = 69.99 WHERE PrixHT = 79.99 " ) 

BDD_Test.commit ( )

print ( "Après la modification" )

FNC_Lecture ( )

BDD_Test.close ( )

SUPPRIMER DES FICHES.

Pour supprimer une fiche, on utilisera la commande SQL : DELETE avec le schéma :

" DELETE FROM nomdelatable WHERE champ = valeuractuelle "

où champ est le nom d'un champ présent dans la table et où valeuractuelle est de même type que celui défini lors de la création du champ.

import sqlite3

def FNC_Lecture ( ) :

CUR_Test.execute ( " SELECT * FROM LesPrix " )

kmestarifs =  CUR_Test.fetchall ( )

print ( "Mes articles." )

for kprix in kmestarifs :

print ( f"{ kprix [ 0 ] } { kprix [ 1 ] } à { kprix [ 2 ] } (TVA { kprix [ 3 ] }%)" )

print ( )

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

karticles = [ ( "Robe de soirée" , 119.99 , 20.3 ) , ( "Escarpins blancs" , 79.99 , 17.25 ) , ( "Etole satin" , 189.99 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

print ( "Après la création" )

FNC_Lecture ( )

# dans la table LesPrix, retirer les fiches dont la valeur du champs PrixHT est 79.99

CUR_Test.execute ( " DELETE FROM LesPrix WHERE PrixHT = 79.99 " )

BDD_Test.commit ( )

print ( "Après la suppression" )

FNC_Lecture ( )

BDD_Test.close ( )

SELECTIONNER DES FICHES.

Pour effectuer une sélection parmi les fiches de la table, on fera appel à la commande SQL : SELECT avec le schéma :

" SELECT * FROM nomdelatable  WHERE champ = ? , valeurs "

où champ est le nom d'un champ présent dans la table et valeurs est un tuple ( ), contenant les valeurs recherchées. Note : les valeurs recherchées doivent être du même types que celle défini à la création du champ.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

kclientes = [ ( "Marie" , 158.5 , 58 ) , ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) , ( "Marion" , 166.0 , 64 ) , ( "Bird" , 168 , 64 ) ]

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

CUR_Test.execute ( " SELECT * FROM MonCarnet " )

kmesclientes = CUR_Test.fetchall ( )

print ( "Toutes mes clientes." )

for kcliente in kmesclientes :

print ( f"{ kcliente [ 1 ] } { kcliente [ 2 ] } cm pour { kcliente [ 3 ] } kg." )

print ( )

krecherche = ( 64 , )

# sélectionne uniquement les fiches de la table MonCarnet donc la valeur pour le champ Poids est 64

CUR_Test.execute ( " SELECT * FROM MonCarnet WHERE Poids = ? " , krecherche ) 

kselection = CUR_Test.fetchall ( )

print ( "Mes clientes sélectionnées." )

for kcliente in kselection :

print ( f"{ kcliente [ 1 ] } { kcliente [ 2 ] } cm pour { kcliente [ 3 ] } kg." )

BDD_Test.close ( )

TRIER LES FICHES SELECTIONNEES.

Pour effectuer un tri des fiches sélectionnées, on utilise la commande SQL : SELECT ... ORDER BY avec le schéma :

" SELECT * FROM nomdelatable  WHERE champ1 =  ? ORDER BY champx " 

où champx est le nom du champ qui sera pris en compte pour le tri des enregistrements retournés. champ1 et champx peuvent être le même champ ou des champs différents.

Le tri, de tout ou partie, des fiches d'une table, ne modifie pas l'ordonnancement des enregistrements dans la table elle-même.

import sqlite3

BDD_Test = sqlite3.connect ( "ON - sgbd 01.db" )

CUR_Test = BDD_Test.cursor ( )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS MonCarnet ( Id integer primary key autoincrement unique , Nom text not null , Taille real , Poids integer ) " )

CUR_Test.execute ( " CREATE TABLE IF NOT EXISTS LesPrix ( Id integer primary key autoincrement unique , Article text not null , PrixHT real , Taux real ) " )

kclientes = [ ( "Marie" , 158.5 , 58 ) , ( "Emanuelle" , 160 , 52 ) , ( "Parker" , 176.3 , 64 ) , ( "Cécile" , 171 , 62 ) , ( "Marion" , 166.0 , 64 ) , ( "Bird" , 168 , 64 ) ]

CUR_Test.executemany ( " INSERT INTO MonCarnet ( Nom , Taille , Poids ) VALUES ( ? , ? , ? ) " , kclientes )

BDD_Test.commit ( )

karticles = [ ( "Robe de soirée" , 64 , 20.3 ) , ( "Escarpins blancs" , 64 , 17.25 ) , ( "Etole satin" , 64 , 33.33 ) ] 

CUR_Test.executemany ( " INSERT INTO LesPrix ( Article , PrixHT , Taux ) VALUES ( ? , ? , ? ) " , karticles )

BDD_Test.commit ( )

# retourne toutes les fiches de la table MonCarnet après les avoir triées de la taille la plus petite à la plus grande

CUR_Test.execute ( " SELECT * FROM MonCarnet ORDER BY taille " )

kmesclientes = CUR_Test.fetchall ( )

print ( "Toutes mes clientes." )

for kcliente in kmesclientes :

print ( f"{ kcliente [ 1 ] } { kcliente [ 2 ] } cm pour { kcliente [ 3 ] } kg." )

print ( )

krecherche = ( 64 , )

# sélectionne les fiches de la table MonCarnet donc la valeur pour Poids est 64 et les tries alphabétiquement par nom

CUR_Test.execute ( " SELECT * FROM MonCarnet WHERE Poids = ? ORDER BY nom " , krecherche )

kselection = CUR_Test.fetchall ( )

print ( "Mes clientes sélectionnées." )

for kcliente in kselection :

print ( f"{ kcliente [ 1 ] } { kcliente [ 2 ] } cm pour { kcliente [ 3 ] } kg." )

BDD_Test.close ( )