DESCRIPTION.

Etablit un lien entre un mot clé et une classe, qui pourra être appelée pour effectuer un traitement individuel de toutes les lignes.

SYNTAXE.

BDD_Base.create_aggregate ( lien , attributs , classe )

BDD_Base ⇨ objet connexion avec une base de données [ OBLIGATOIRE ]

.create_aggregate ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

lien ⇨ mot de liaison [ OBLIGATOIRE ]

attributs ⇨ nombre de paramètres attendus [ OBLIGATOIRE ]

classe ⇨ classe à instancier [ OBLIGATOIRE ]

REMARQUES. 

lien doit être un str ( ) quelconque.

attributs doit être un int ( ) indiquant combien de paramètres doivent être transmis à fonction. Si la quantité d'attributs est indéterminé ou s'il est variable, attributs prendra la valeur -1.

classe doit être le nom d'une classe personnalisée existante, créée et définie au préalable avec l'instruction class. La paire de parenthèse, après le nom de la fonction, de doivent pas être présentes.

La classe personnalisée appelée par la méthode objet.create_aggregate ( ) doit obligatoirement avoir la forme suivante :

class CLS_Nom :

def __init__ ( self ) :

pass

def step ( self , Qa , Qb , ... ,  Qn ) :

pass

def finalize ( self ) :

return valeur

CLS_Nom est un str ( ) choisi librement désignant classe dans l'appel de la méthode objet.create_aggregate ( ).

def __init__ ( self ) introduit la méthode d'initialisation de la classe. Son seul paramètre doit être self. L'instruction pass sera remplacée, si besoin, par une séquence de code utile à l'initialisation de la classe. Par exemple, pour initialiser un compteur ou donner une valeur de départ à une variable qui sera retournée en fin de traitement.

def step ( self , Qa , Qb , ... ,  Qn ) : introduit la méthode de traitement des données fournies par la table. En plus du paramètre obligatoire, en première position, self, sa définition devra attendre un nombre de paramètres égal à attributs et correspondant à chacun d'eux, la gestion des valeurs NULL devra être appréhendée par le programme. L'instruction pass sera remplacée par le code utile au traitement personnalisé des données transférées depuis la table. Cette méthode sera appelée par tous les enregistrements, fiches, lignes, de la la table associée à la requête contenue dans l'appel de la méthode objet.create_aggregate ( ).

def finalize ( self ) : introduit la méthode terminale du traitement. Son seul paramètre doit être self. Elle sera invoquée à la suite du traitement du dernier enregistrement fourni par la table. Elle devra se terminée par l'instruction return avec une valeur de retour du type attendu par le programme. Cette valeur sera consultable, généralement, à l'aide de curseur.fetchone ( ) ou, plus rarement avec curseur.fetchmany ( ) ou curseur.fetchall ( ). 

Si attributs est égal à 1, c'est-à-dire si la valeur d'un seul champ est transmis à la méthode classe.step ( ), on pourra préfixer le nom du champ de la commande SQL : 

- ALL, valeur par défaut, pour que toutes les valeurs soit transmises, même si une valeur égale a déjà était traitée ;

- DISTINCT, pour qu'une valeur soit transmise, uniquement si précédemment aucune valeur égale n'a était traitée.

Par exemple, si les valeurs à passer à la méthode classe.step ( ) sont : G ; G ; N ; G ; P ; N ; G ; P ; G ; N.

- sans préfixe, équivaut avec le préfixe par défaut, c'est-à-dire ALL ;

- avec ALL, elle sera appelée 10 fois pour traiter G ; G ; N ; G ; P ; N ; G ; P ; G ; N , soit 5 fois G, 3 fois N et 2 fois P ;

- avec DISTINCT, elle sera appelée 3 fois pour traiter G ; N ; P , soit 1 fois G, 1 fois N et 1 fois P.

La création d'un objet curseur est facultative. Toutes les méthodes de la classe sqlite3.Cursor ( ) : curseur.execute ( ), curseur.fetchall ( ), ... , peuvent être appelées anonymement. Dans ce cas Python crée un objet curseur éphémère, utilise la méthode appelée, directement, de cette objet curseur éphémère, puis ferme cette objet curseur éphémère. Toutefois la création d'un objet curseur avec la méthode CUR_Curseur = BDD_Basse.cursor ( ) est vivement conseillée. 

Voir la classe sqlite3.Cursor ( ) pour plus d'information sur les objets curseur.

EXEMPLE. 

import sqlite3

# --- Définition de la classe d'agrégation ---

class CLS_Calculs :

# --- Constructeur de classe --- 

def __init__ ( self ) :

self.somme = None

self.fiches = 0

self.valeurs = " : "

# --- Traitement individuel de chaque fiche de la table ou de la sélection --- 

def step ( self , Q ) :

print ( f"Le double de { Q } est { Q * 2 } et son triple est { Q * 3 }." )

print ( f"Le carré de { Q } est { Q ** 2 } et son cube est { Q ** 3 }." )

print ( f"La racine carrée de { Q } est { Q ** .5 } et sa racine cubique est { Q ** ( 1 / 3 ) }.\n" )

if self.somme : self.somme = self.somme + Q

else : self.somme = Q

self.fiches += 1

self.valeurs += f"{ Q }"

# --- Actions à effectuer une fois après avoir traité toutes les fiches --- 

def finalize ( self ) :

print ( f"\nValeurs des fiches traitées { self.valeurs }.\nSoit { self.fiches } fiches." )

return f"La somme totale de toutes les fiches est { self.somme }."

# --- Fin de définition de la classe d'agrégation ---

LST_Premiers = [ ( 1 , 1 ) , ( 2 , 4 ) , ( 3 , 9 ) , ( 5 , 25 ) , ( 7 , 49 ) ]

BDD_Connexion = sqlite3.Connection ( ":memory:" )

BDD_Connexion.create_aggregate ( "calcul" , 1 , CLS_Calculs ) # si une requête contient le mot calcul, instancier CLS_Calculs

BDD_Connexion.execute ( " CREATE TABLE IF NOT EXISTS Premiers ( Nombre INTEGER , Carre INTEGER ) " )

BDD_Connexion.executemany ( " INSERT INTO Premiers ( Nombre , Carre ) VALUES ( ? , ? ) " , LST_Premiers )

BDD_Connexion.commit ( )

# instancier CLS_Calculs, pour chaque fiche exécuter sa méthode step, puis 1 fois sa méthode finalize après la dernière fiche

kselection = BDD_Connexion.execute ( " SELECT calcul ( Nombre ) FROM Premiers " )

# affichage de la valeur unique retournée par la méthode finalize après la dernière fiche

print ( kselection.fetchall ( ) ) 

BDD_Connexion.close ( )