Remarques
Si vous souhaitez extrapoler la formule à d’autres SQL, il faut savoir que sous Access :

• True = -1 donc (Annee MOD 19 IN (5,16)) retourne -1 si vrai;
• L’opérateur ‘\’ de Annee \ 4 retourne seulement la partie entière de la division;
• Attention aussi à la priorité des opérateurs…

Il n’est pas possible non plus de copier directement la formule dans une fonction VBA car elle utilise des opérateurs spécifiques SQL (Between et In).
 
Exemples
Au lancement de la requête, un popup demande de saisir l’année souhaitée.

Si l’année est en dehors de la plage 1900 – 2099, NULL est renvoyé pour chaque colonne.

A noter
La formule pour le calcul des jours ouvrables de la FAQ Access n’est valable que pour la période comprise entre 1982 et 2048.

@+

Philippe

Code de la fonction VBA

 
Exemples d’utilisation
Un collectionneur de modèles réduits, a noté consciencieusement ses achats de lots de voitures sur une feuille quadrillée. Un ami, utilisateur débutant d’Access, a porté ce document dans une table Access sans connaître les formes normales de Codd !

Voici le code pour créér et peupler partiellement la table dont la structure n’est pas à suivre…

Cette table contient 6 colonnes (Marque, Modèle, DateAchat, Couleur des voitures, Nombre de voiture du lot, Prix du lot).
Chaque ligne de la table correspond à l’achat d’un lot de voitures et toutes les voitures d’un lot ont la même couleur.

Le collectionneur souhaite obtenir des infos sur sa collection en concaténant l’information dans une colonne car c’est plus simple à lire…

Quels sont les modèles achetés de la marque Peugeot ?
Comme la colonne pivot ‘Marque’ doit être égale à ‘Peugeot’, on peut écrire la simple requête suivante :

La valeur pivot est ‘Peugeot’, la colonne pivot (ou de regroupement) est ‘Marque’, la colonne à concaténer est ‘Modele’, la table est ‘tConcat’, la clause Where est vide «  », pas de regroupement des lots ayant le même modèle d’où la valeur 0, on retourne les modèles dont le nom est vide ou NULL (False), on souhaite trier par ordre Ascendant les modèles concaténés (True), et le séparateur entre les modèles est une virgule ‘,’.

On obtient donc :

Le collectionneur est satisfait mais il préfère regrouper les modèles communs et ajouter un espace après la ‘,’
La requête devient :

Pour regrouper les modèles, il suffit de passer à 1 au lieu de 0 le paramètre ‘RegrouperCompter’. De plus, le séparateur devient ‘, ‘ au lieu de ‘,’.

On obtient alors :

Il est satisfait mais il perd une information importante qui est le nombre de lots achetés et finalement il se demande si le séparateur ‘ / ‘ ne serait pas mieux…
La solution devient :

Pour afficher le compte par modèle, on passe la valeur du paramètre ‘RegrouperCompter’ à 2, et le séparateur est modifié.

Résultat :

 
Qu’elles sont les dates d’achat de ces lots du plus récent au plus ancien ?

La colonne à concaténer devient ‘DateAchat’ et le paramètre ‘TriAscendant’ devient ‘False’.

Résultat :

 
Quels sont les prix d’achat de ces lots ?

On obtient :

On remarque que le dernier compte (1) est sans valeur. En effet, un prix n’était pas renseigné dans le document…
Le collectionneur me dit alors : ‘Cachez-moi cette erreur que je ne saurais voir…’

La requête devient donc :

Il suffit de mettre à ‘True’ le paramètre ‘PasVideNULL’.

On obtient finalement :

 
Quels sont les prix d’achat, toutes marques confondues ?
Il est normalement nécessaire de renseigner la valeur et la colonne du pivot…
La solution consiste à mettre 0 pour ‘ValeurColonnePivot’ et ‘0’ pour ‘NomColonnePivot’
La requête devient :

et le résultat :

Ca serait possible d’avoir tous les prix unitaires ?
Requête :

On déclare que la colonne concaténée est la division du prix sur le nombre de voiture du lot.
Résultat :

 
Quels sont les modèles de chaque marque ?
Cette fois-ci, il faut utiliser la clause FROM de la requête pour passer en revue l’ensemble des marques :

Résultat :

 
Quels sont les marques et modèles pour chaque couleur ?

Résultat :

Puis-je avoir une présentation inversée ?

qui donne :

Enfin, je souhaite afficher séparément les colonnes ‘Marque’ et ‘Modèle’ et ne pas voir les informations pour ‘Citroën’
La requête :

On remarquera l’utilisation du paramètre ‘Filtre’ de la fonction ConcatColonne pour écarter la marque ‘Citroën’ de la concaténation. Dans ce cas précis, l’utilisation du filtre n’est pas indispensable puisque la requête écarte elle-même cette marque (voir clause HAVING).
Résultat attendu :

 
Performance
La fonction (et la requête sous-jacente!) est exécutée pour chaque ligne de la table ce qui ralentit sensiblement la requête principale.
Il faudra donc limiter son usage à une table ou requête peu peuplée (< 10 000 lignes ?) et si possible, indexer avec doublons la colonne pivot.
De plus, pour ne pas dégrader les performances, éviter de réaliser des opérations complémentaires sur la colonne concaténée (Where, Order by, Group by) dans la requête principale.

Lien
Voir ce billet pour réaliser une transposition inverse.

@+

Philippe

Exemple d’utilisation
Recopier la ligne suivante dans la fenêtre ‘Exécution’ de l’éditeur Visual Basic (F11) puis appuyer sur ‘Entrée’ pour l’exécuter.

Explications
Le premier paramètre de la fonction contient la chaine à modifier.
Le deuxième paramètre est un peu particulier car il s’agit d’une suite de paramètres qui sera interprétée comme un tableau de variants. Ce tableau contient l’ensemble des substitutions à réaliser (couple chaine recherchée/chaine de remplacement) et éventuellement un booléen qui indique le type de comparaison (binaire ou textuelle) pour les remplacements suivants.

Par défaut, la fonction effectue une comparaison binaire pour rechercher et remplacer les sous-chaines c’est à dire qu’elle est sensible à la casse des caractères.

Dans notre exemple, on va tout d’abord substituer le caractère ‘_’ par un espace (‘_’,’ ‘) puis réduire le nombre d’espaces contigus en un (‘ ‘,’ ‘). A ce stade on obtient :

Lorsque la chaine de remplacement est plus courte que la chaine recherchée, la fonction réalise une boucle de réduction. Par exemple, 5 espaces contigus seront réduits en un même si la chaine recherchée n’est que de deux espaces.

L’étape suivante (‘ A ‘,’ à ‘) recherche la lettre A en majuscule entourée d’espaces, on remplace ensuite le i accentué par son équivalent sans accent (‘î’,’i’) puis le ‘é’ par ‘er’.

L’étape suivante (True ou tout chiffre différent de 0) indique à la fonction que l’on souhaite réaliser maintenant des comparaisons textuelles (vbTextCompare) donc insensibles à la casse des caractères. L’étape suivante (‘ma’,’La’) remplacera donc le texte ‘ma’ par ‘la’ quel que soit la casse des caractères.

On pourrait ajouter d’autres remplacements et revenir aussi à une comparaison binaire (False ou le chiffre 0).

Remarque
Dans le cas d’une réduction de chaine, on réalise une boucle qui ne s’arrête que si la longueur de la chaine est inchangée (…Loop Until a = b) après la fonction Replace(). Cette méthode est moins efficace que :

mais on risque d’entrer dans une boucle infinie si on souhaite réduire par exemple ‘oe’ en ‘Œ’ avec une comparaison textuelle… En effet, cette ligature est interprétée comme équivalente à ‘oe’ :

Access retourne la valeur 1 bien que l’on s’attend à obtenir 0…

Pour le fun !
Une autre solution pour réduire les espaces :

Ce type de méthode est parfois utilisé dans les requêtes SQL pour s’affranchir d’une fonction personnelle dans la requête :

@+

Philippe

Résultat attendu du jeu de test
Nous remarquons que la période :

• de la 1ère ligne [03/01/2012-03/01/2012] est chevauchée par celle de la 2ème [20/12/2011-04/01/2012]
• de la 3ème ligne [04/01/2012-07/01/2012] chevauche celle de la 2ème [20/12/2011-04/01/2012]
• de la 4ème ligne [06/01/2012-10/01/2012] chevauche celle de la 3ème [04/01/2012-07/01/2012]

Après regroupement, l’étendue de cette première période va du 20/12/2011 au 10/01/2012

La ligne n°5 (01/05/2012-01/05/2012) n’est chevauchée par aucune autre période et les 4 dernières lignes donnent une période du 02/05/2012 au 10/05/2012.

Le résultat attendu est :

• 20/12/2012 – 10/01/2012
• 01/05/2012 – 01/05/2012
• 02/05/2012 – 10/05/2012

La requête
Il existe plusieurs méthodes pour arriver au résultat mais voici la requête la plus performante sous MS Access (et cerise sur le gâteau, visible dans l’éditeur de requête !) :

Explications
La première sous-requête de la clause FROM (SELECT DateDebut…) retourne la date minimale des périodes chevauchées. En effet, la clause WHERE de cette sous-requête ne conserve que les dates de début qui sont inférieures ou égales aux périodes qui les chevauchent éventuellement.
Prenons par exemple la ligne n°1 (03/01/2012). Sa date de début est-elle <= à la date de début de la période qui la chevauche ? La réponse est non puisque la date de début de la période du 20/12/2011 au 04/01/2012 est inférieure. La date du 03/01/2012 est donc retirée et ainsi de suite pour chaque ligne de la table.
Le 'Group By DateDebut' permet, au cas où, de regrouper les lignes qui ont une même date de début.

La deuxième sous-requête de la clause FROM (SELECT DateFin …) applique le même principe mais pour la date de fin.

A ce niveau là, on a visiblement pas de lien entre la date de début et la date de fin des périodes regroupées… d’autant plus que l’on réalise une jointure croisée entre les dates pour que la requête soit visible dans l’éditeur.

Pour s’en sortir, on retire dans un premier temps les lignes incohérentes qui ont une date de fin < à la date de début (…WHERE t1.DateDebut <= t2.DateFin…)
Et la finesse finale qui consiste à dire que la date de fin de chaque regroupement de périodes est celle qui est la plus petite puisque nous avons retiré dans la clause WHERE précédente les périodes incohérentes et que les périodes restantes ne peuvent se chevaucher.
On ajoute un GROUP BY sur la date de début pour permettre l'utilisation de la fonction MIN() sur la date de fin.

Test de performance
Voici une petite fonction qui va générer 2000 lignes dans la table pour tester la performance de la requête

@+

Philippe

On part donc de :

…pour arriver à :


Générer la table et ses lignes
Cette fontion génère la table tTransposition qui est peuplée de 10 000 lignes de textes aléatoires.
Pour l’utiliser, copier l’ensemble du code dans un module VBA, placer le focus dans la fonction ‘CreationTableTransposition()’ puis appuyer sur ‘F5‘ pour l’exécuter.

La trousse à outils VBA
Pour chaque ligne de la table, il faudra compter les occurrences du séparateur « @ », déterminer ainsi le nombre de sous-chaînes (nombre de séparateurs + 1) qui seront enfin séparées et extraites.

Par chance, on a déjà présenté dans ce blog deux fonctions personnelles qui remplissent ces tâches :

et

Comment créer des lignes qui n’existent pas ?
En effet, la colonne contient entre une et huit sous-chaînes selon la ligne. Comment générer une ligne par sous-chaîne à partir d’une ligne source dans la requête SQL ?
Pour ce faire, on s’appuie sur le fait qu’une relation 1-n entre deux tables génère n lignes dans une requête.

Connaissant le nombre de sous-chaîne, il nous faut donc créer une table de chiffres que l’on mettra en relation avec ce nombre pour générer les lignes.

Cette fonction créée pour vous la table tChiffres et ajoute une ligne par chiffre (0 à 9)

Par exemple, la requête SQL suivante génére tous les nombres entre 0 et 999 :

Dans notre cas, nous avons au maximum 8 sous-chaînes, donc la première partie de notre requête s’écrira :

Ceci permettra d’associer un chiffre à chaque sous-chaîne extraite.

Extraire les sous-chaînes
La fonction Token(…) a pour argument le numéro (1 à x) de la sous-chaîne à extraire. Il faut donc ajouter 1 aux chiffres retournés par la relation précédente.
La clause FROM de notre requête est maintenant formée :

Requête finale
Finalement, on réalise un regroupement sur les chaînes et un comptage décroissant :

Pour ne pas plomber la vitesse d’exécution de la requête, l’enregistrer, quitter l’application Access, la redémarrer puis lancer la requête SQL sans ouvrir auparavant l’éditeur VBA.
En moins de 2 secondes, le résultat de la requête devrait s’afficher.
A noter que le texte des lignes est généré aléatoirement d’où certainement des écarts entre les comptages de la capture d’écran et les vôtres.

Requête SQL sans UDF
Si le coeur vous en dit, la requête suivante réalise le même travail sans utiliser une fonction personnelle.
Mis à part les fonctions VBA déjà décrites dans ce blog, on utilise la fonction StrReverse() pour supprimer les séparateurs postérieurs à la sous-chaîne à extraire et déterminer ainsi sa longueur.

Lien
Voir ce billet pour réaliser une transposition inverse.

@+

Philippe

• La table contient 100 000 lignes : Va falloir être performant sur le coup !
• La colonne de texte ne contient aucun NULL : Tant mieux, une source de problèmes en moins…
• Les séparateurs du token sont toujours présents : Nickel, on évite des tests supplémentaires…
• Il peut y avoir plus de deux séparateurs dans le texte, dans ce cas, prendre la sous-chaine entourée par les séparateurs extrêmes : Il faudra trouver une méthode pour faire abstraction des séparateurs parasites…
• Les séparateurs sont ‘[‘ et ‘]’ : Bien, on va pouvoir faire des comparaisons binaires qui sont les plus performantes…
• Les deux délimiteurs peuvent être côte à côte : Ok, faudra vérifier ce cas particulier avec l’algorithme.
• Le nombre de caractères dans le texte est variable ainsi que la position des séparateurs : Ben, Il faudra les rechercher…
• Version 2007 d’Access : Reconnaît les fonctions VBA ‘modernes’

Exemples suite au cahier des charges

 
Création de la table et des lignes
Cette fonction créée la table tToken et 100 000 lignes. Peut prendre plusieurs secondes selon le système.
La table possède une colonne LenToken qui permettra de vérifier, via une requête, la qualité des résultats.

Pour l’utiliser, copier l’ensemble du code dans un module VBA, placer le focus dans la fonction ‘CreationTableToken()’ puis appuyer sur ‘F5′ pour l’exécuter.

 
La trousse à outils VBA
Rapide inventaire des fonctions VBA qui permettent d’extraire une sous-chaîne :

• Left(Texte, Longueur) et Right(…) : Permettent d’extraire la partie gauche ou droite d’un texte.
• Mid(Texte, Début, Longueur) : Permet d’extraire une partie quelconque d’un texte
• Split(Texte, séparateur,…) : Retourne dans un tableau de base zéro le texte scindé par le séparateur .
• Replace(Texte, Recherche, Remplacement,…) : Ce n’est pas son usage habituel mais si on connait le texte à retirer, on peut le remplacer par une chaîne vide et ne conserver que la sous-chaîne désirée…

La fonction Len(…) permet de compter les caractères d’une chaîne.

Les fonctions VBA pour déterminer la position d’une sous-chaîne :

• InStr([Début],Texte, Recherche,…) : Renvoie la position de la première occurrence de Recherche à partir du début du Texte
• InStrRev(Texte, Recherche,…) : Renvoie la première occurrence de Recherche à partir de la fin du Texte.

Remarque
Certaines fonctions existent avec $ en suffixe de leur nom (Left$(),…) : Ceci veut dire qu’elles vont retourner une variable de type String (chaîne de caractères) et non un Variant qui peut être NULL ou typé (String, Date).

Liste des fonctions qui retournent un type String (parfois, elles ont un argument String au lieu de Variant) :

 
Comment choisir entre $ ou non ?
Si on souhaite propager un NULL ou retourner un variant de type Date (fonction Time(), Date()) il faudra donc utiliser la version sans $.
Par contre, si on recherche la performance ET que l’on ne passe pas un NULL à la fonction$ (une erreur est levée dans ce cas) ET que l’on souhaite récupérer une variable de type caractère, il est préférable d’utiliser les fonctions avec $. Le gain de rapidité de fonction$() peut atteindre 40% par rapport à son équivalent !

Construction de la fonction VBA
D’après le cahier des charges, la colonne de la table ne contient pas de NULL, donc on peut écrire une fonction qui aura en paramètre un type String et retournera aussi un type String (performance meilleure).
Dans ce cas, on pourra utiliser les fonctions équivalentes Fonction$() pour un gain de performance.

On ne pourra pas utiliser Split() car il faut seulement prendre les séparateurs extrêmes si il en existe plusieurs. Split() couperait la chaîne autant de fois qu’il y a de séparateurs…
Il faudra donc utiliser une fois InStr() pour trouver le premier séparateur et InStrRev() pour positionner le dernier.

Les séparateurs peuvent être n’importe où dans le texte, la seule fonction qui permette de récupérer une sous-chaîne dans ce cas est Mid().

La fonction ‘spécifique’ à la demande est :

On affecte à la variable x la position du séparateur ‘[‘ le plus à gauche dans la chaîne. On lui ajoute 1 car ceci évite deux additions par la suite.
On remarque que InStr est utilisé ici dans sa version ‘longue’ (InStr(Depart, Texte, Recherche, Comparaison)) car on impose le type de comparaison. Si on ne l’impose pas on peut écrire InStr(Texte, Recherche).
La ligne suivante va extraire la sous-chaîne du Texte grâce à l’utilisation de la fonction Mid$().
Le deuxième argument (x) de Mid() détermine le point de départ de la sous-chaîne (position du séparateur gauche + 1).
Le troisième argument est une longueur, il nous faut donc déterminer la position du séparateur à droite de la sous-chaîne en utilisant InStrRev() et retrancher la position de départ (x).

Ci-dessous la même fonction mais plus polyvalente car gère l’absence d’un ou des séparateurs et le cas des chaînes vides :

 
Enfin, la même fonction mais avec un argument et une valeur retournée de type Variant pour propager les NULL.

On remarquera l’utilisation de la fonction Nz() qui retourne une valeur de notre choix si son argument est NULL.
Pour info, InStr() ne lève pas d’erreur si Texte est NULL contrairement à InStrRev…

et pour finir, la requête SQL via l’UDF MyToken():

 
Fonction directement dans le SQL
Le principe repose sur l’utilisation de la fonction Mid() et intuitivement on peut écrire le template de la fonction : Mid(Texte, InStr(), InStrRev() - InStr()).
Le reproche qui saute aux yeux est qu’on utilise deux fois la fonction InStr(). Bien que plus performante que InStrRev(), elle est tout de même plus consommatrice de temps CPU que Left(), Right() Mid().
Pour se débarrasser de ce deuxième InStr(), on peut s’appuyer sur une particularité de Mid(). En effet, le troisième paramètre de Mid() est optionnel. Si on ne renseigne pas la longueur de la chaîne retournée, Mid() retourne toute la chaîne à partir du point de départ.
Il faut donc dans le premier argument de Mid() passer une chaîne déjà limitée à droite.
Voici le nouveau template de notre fonction : Mid(LEFT(Texte,InStrRev()),InStr()).

Ensuite, il faut travailler sur la performance car on utilise tout de même 4 fonctions au lieu de 3 dans MyToken(). Dans le cas exposé ici, on utilisera les fonctions avec $ et on imposera la comparaison binaire.

La requête SQL est :

 
Performance et qualité
Avant de tester les performances, quitter normalement l’application Access puis la relancer sans ouvrir l’éditeur VBA pour ne pas pénaliser la requête avec l’UDF.

Les requêtes suivantes retournent les lignes dont la longueur théorique du token est différente de la longueur calculée (aucune ligne retournée normalement !).

La requête via l’UDF MyToken (plus performante a priori…)

 
Et la même requête avec la fonction directement dans le code SQL :

 
Lien
Voir ce billet pour extraire des token délimités par un seul séparateur.
 
@+

Philippe

La technique via UDF
La fonction VBA utilise la fonction standard Split() qui génère un tableau (de base 0) de chaînes de caractères à partir d’un texte en le découpant via un séparateur à définir.
On peut définir le comportement de Split() en fonction de la casse des caractères grâce à son dernier paramètre optionnel :

• vbBinaryCompare (valeur = 0) : Comparaison binaire des caractères donc sensible à la casse
• vbTextCompare (valeur = 1) : Comparaison textuelle donc insensible à la casse des caractères
• vbDatabaseCompare (valeur = 2) : Comparaison en fonction de la configuration locale de windows

Seules les valeurs 0 et 1 sont reproductibles d’un système à l’autre.

l’UDF :

Cette fonction demande 3 paramètres dont le dernier est optionnel.
Le ‘Texte’ dans lequel on souhaite compter le nombre de sous-chaîne ‘Chaine’ et la méthode de comparaison qui est binaire par défaut.
La 1ère ligne du code retourne le plus grand indice de la dimension du tableau généré qui correspond donc au nombre d’occurrences de la chaine. En effet, le texte ‘A-B-C’ découpé sur ‘-‘ aura ‘A’ en indice 0 du tableau généré, ‘B’ en indice 1 et ‘C’ en indice 2. L’indice le plus grand est 2 ce qui correspond bien au nombre d’occurrences de ‘-‘.
Que se passe t’il si aucune occurrence n’est trouvée ou si Chaine= » » ? Split() retourne alors un tableau ayant qu’un seul indice égal à 0, donc pas de problème.
Que se passe t’il si le texte est vide Texte= » » ? Dans ce cas, Split() retourne un tableau particulier avec un indice le plus grand égal à -1 qui est inférieur à l’indice le plus petit du tableau (LBound() = 0)… C’est pour cette raison que l’on teste si ‘Texte’ est différent d’une chaîne vide (If Texte <> vbNullString Then …). Dans ce cas la fonction retournera 0.

On remarquera que Texte et Chaine sont de type String, la fonction n’appréciera donc pas une valeur NULL… Lorsque le cas peut se présenter, je passe en paramètre Texte & «  » et le problème du NULL est réglé ! Pas très beau pour les puristes mais efficace. Une autre solution serait de définir Texte et Chaine en tant que Variant et de vérifier s’ils sont différents de NULL ou bien encore, utiliser la fonction Nz() pour convertir les NULL en texte.

La requête SQL est dans ce cas :

La requête a deux paramètres : Le texte recherché et le type de comparaison de texte (0 ou 1).
La clause WHERE permet de ne retourner que les textes qui possèdent au moins une occurrence et ORDER BY tri les résultats par ordre décroissant du nombre d’occurrences.

La technique directe dans le SQL
On utilise bien sûr des fonctions VBA mais elles sont appelées directement dans la requête.
Par contre, On n’utilise plus Split() et Ubound() car elles ne peuvent pas être appelées directement du SQL.

La technique retenue consiste à remplacer dans le Texte chaque occurrence de la chaine recherchée par une chaine vide. En connaissant aussi la longueur initiale du Texte et la longueur de la chaine recherchée on peut facilement déterminer le compte des occurrences.
Reprenons notre exemple ‘A-B-C’. La longueur initiale est 5, la longueur de la chaîne recherchée est 1 (‘-‘) et la longueur du texte après avoir retiré les chaînes recherchées est 3 (‘ABC’)
Donc (5 – 3) / 1 = 2 occurrences.
On utilise la fonction Len() pour déterminer la longueur des chaînes de caractères et la fonction Replace() pour remplacer les chaînes recherchées par une chaîne vide et pour gérer le type de comparaison (binaire ou texte).

La requête est :

On remarquera que l’on passe [Texte] & «  » à la fonction Replace() pour éviter le problème des valeurs NULL (même chose pour le texte recherché).

Utilisation des requêtes
La requête exige deux paramètres. Le texte recherché doit contenir au moins un caractère et le type de comparaison (0 pour binaire ou 1 pour texte).

Performance
Pour comparer la performance des deux méthodes, il est nécessaire tout d’abord de fermer l’application Access puis de la réouvrir pour que la requête avec la fonction VBA soit performante.

@+

Philippe

Analyse du problème
A priori, la requête semble aisée : Il suffit d’extraire les dates de naissance dont le mois et le jour sont dans la période de l’année définie.
Exemple pour la période entre le 15/05 et le 10/07 :
Une erreur souvent commise est de filtrer indépendamment les mois et les jours des dates de naissance
... WHERE (MONTH([DateNaissance]) BETWEEN 5 AND 7) AND (DAY([DateNaissance]) BETWEEN 10 AND 15)
On obtient que les dates de naissance entre le 10 et le 15 des mois de mai, juin et juillet ce qui n’est pas l’objectif recherché.

Pour récupérer toutes les dates sur cette période on peut écrire en condition de filtre de la requête :
...WHERE (MONTH([DateNaissance])*100+DAY([DateNaissance])) BETWEEN 515 AND 710
515 et 710 correspondent au [n° du mois] * 100 + [le jour du mois] de la période étudiée.

Et voilà le tour est joué… mais pas complétement !
En effet, que se passe t’il sur une période entre le 10/07 et le 15/05?
...WHERE (MONTH([DateNaissance])*100+DAY([DateNaissance])) BETWEEN 710 AND 515
Access retourne toutes les dates de naissances entre 515 et 710 soit exactement l’inverse de ce que l’on souhaite mis à part nos deux bornes.

Une solution universelle
Graphiquement, la période du 10/07 au 15/05 est

Ce qui est équivalent sur l’échelle d’une année :

A l’échelle d’une année, on remarque que la date de fin période est antérieure à la date de début de période lorsque la période s’étale sur ‘deux années’
En résumé, si D:MMJJ du début de période est plus grand que F:MMJJ de fin de période il suffit d’écrire la clause WHERE suivante :
...(MONTH([DateNaissance])*100+DAY([DateNaissance])) NOT BETWEEN 515 + 1 AND 710 - 1
On obtient donc toutes les dates qui ne sont pas entre le 16/05 et le 09/07

Finalement, si Début période <= à Fin période alors on veut les dates entre Début et Fin sinon on veut les dates qui ne sont pas entre Fin + 1 et Début – 1.

La requête paramétrée

Lorsque la requete demande les paramètres, écrire 515 pour le 15 mai et 710 pour le 10 juillet.

Autres requêtes paramétrées sur les anniversaires
On souhaite une requete qui nous retourne les dates de naissance dans x jours et sur une période de y jours.
Potentiellement, on peut regretter que la solution précédente teste deux fois le début période par rapport à la fin de période :
(Si debut <= fin Et ... ) OU (Si debut > fin Et ...)
Pour ne tester qu’une fois, on peut s’appuyer sur la fonction IIF() de VBA qui correspond à Si,alors,sinon.

De plus la formule avec MONTH()x100 + DAY() pourrait être simplifieé en utilisant la fonction format(Date,’mmdd’). Il faut utiliser « mmdd » et non « mdd » car la fonction format retourne un string et non un numérique et ‘0515′ (15 mai) est bien < ‘1015’ (15 octobre) mais ‘515’ est > ‘1015’ !

Voici la requête avec IIf() seulement :

Et la requête avec IIF() et Format() :

Remarques
La période s’étale du jour Date() + X à Date() + X + Y – 1 car on inclut les bornes et on limite la longueur de la période à seulement Y jours.

Donc, ‘Dans x jours’ doit être >= à 0 et ‘Sur y jours’ doit être >= à 1

On remarquera que si une date de naissance est NULL, la deuxième requête avec Format() la retourne si la période passe par le 1er janvier (car une chaine vide n’est pas dans la période entre « F:mmdd » et « D:mmdd »). On peut s’affranchir de cet artefact en ajoutant dans la clause where une condition supplémentaire qui écarte les dates de naissance NULL.

Performance
La performance des différentes requêtes est excellente.
Pour la tester, voici une fonction qui ajoute 100 000 lignes à la table :

Bon anniversaire !

Philippe

 
Résultat attendu

Id Nom
11 Albert
12 Albert
13 Albert
14 Albert
15 Albert
11 Bernard
12 Bernard
…

 
La requête SQL
Une solution possible est :

SELECT * 
FROM   ttop2 AS T1 
WHERE  id > ALL (SELECT TOP 10 id 
                 FROM   ttop2 T 
                 WHERE  T.nom = T1.nom 
                 ORDER  BY id) 
       AND id <= ANY (SELECT TOP 15 id 
                      FROM   ttop2 T 
                      WHERE  T.nom = T1.nom 
                      ORDER  BY id) 
ORDER  BY nom, 
          id

 
Explications
La clause Where va filtrer les lignes sur deux critères complémentaires :
Toutes les lignes retournées doivent avoir un Id > à tous les Id du TOP 10 du même NOM ET un Id <= à au moins un Id du TOP 15 du même NOM.
Finalement, seules les Id du TOP 11 à 15 répondent aux deux critères et les lignes correspondantes sont retournées.

Autre solution
Il est possible de substituer >ALL et <=Any par Not In et In :

SELECT *
    FROM tTop2 AS T1
    WHERE id NOT IN  (
    SELECT TOP 10 Id 
        FROM tTop2 T 
        WHERE T.Nom=T1.Nom 
        ORDER BY Id) 
        AND id IN (
    SELECT TOP 15 Id 
        FROM tTop2 T 
        WHERE T.Nom=T1.Nom 
        ORDER BY Id)
    ORDER BY Nom, id;
 

Performance
Il est recommandé d’indexer sans doublons la colonne ‘Nom’ sur laquelle porte la clause Where.
Compte-tenu de la présence de 2 sous-requêtes, cette requête est adaptée pour une table possédant moins de 1000 lignes…

Si vous avez d’autres solutions, n’hésitez pas à les placer en commentaire.

@+

Philippe

Difficultés
La première difficulté est d’obtenir un top 3 pour chaque Nom. Une solution consiste à filtrer les enregistrements en imposant les Id par Nom grâce à une sous-requête corrélée (WHERE T.Nom=T1.Nom) dans la clause IN :

Le problème du Top 3 par Nom étant résolu, le plus compliqué reste à faire… Comment obtenir aléatoirement des Id pour chaque Nom ?
En effet, on souhaite suffisamment d’aléatoire pour que la liste des Id différe d’un appel à l’autre de la requête mais pas trop non plus pour que la sous-requête sorte la même liste des Id pour chaque T1.Id.
L’idée de base est d’utiliser la fonction RND(T.Id) dans la clause ORDER BY pour trier aléatoirement les enregistrements en sachant que T.Id est unique :

Comme vous pouvez le constater, on perd la notion de Top 3 par Nom car pour chaque T1.Id, la sous-requête recalcule une liste d’Id différente…

La requête SQL finale

Explications
On s’appuie sur deux particularités d’Access :

La première est que si l’on passe un nombre négatif en argument à la fonction Rnd(), elle retourne toujours le même nombre aléatoire. Ceci permet d’avoir une liste constante d’Id pour chaque Nom.

La deuxième va nous permettre d’obtenir une liste différente d’Id entre chaque appel de la requête principale. Pour ajouter un zeste d’aléatoire on utilise la fonction Timer() en argument de la fonction Rnd(). Heureusement, Access ne met pas à jour le timer() pendant tout le temps d’exécution de la requête. La valeur du timer au démarrage de la requête est conservé jusqu’à la fin de son exécution ou de sa prochaine actualisation (dans un formulaire prendre un recordset avec snapshot pour éviter une mise à jour via modification du jeu d’enregistrements sous-jacent).

Remarques
L’ajout d’une deuxième colonne de tri (T.Id) dans la sous-requête permet de s’assurer que le top 3 retournera toujours que 3 lignes au maximum même si des ex-aequo subsistent après ORDER BY RND(-(T.Id+Timer())).

La présence de la sous-requête entraîne un temps d’exécution long de la requête qui sera donc réservée pour des tables ayant peu de lignes (~1000).
@+

Philippe