Modifier une instruction SQL (ou requête), en Visual Basic

Nous allons commencer par écrire une instruction SQL simple, qui ne comportera aucune partie variable.
Prenons par exemple cette requête :

Affichons son code SQL :

En Visual Basic, nous allons concaténer les quatre lignes de texte de l'instruction SQL, pour obtenir :

Le texte de l'instruction SQL est surligné en jaune.
Le pavé bleu clair est un espace, qui a été ajouté pour remplacer le saut de ligne.
L'opérateur de concaténation (&) et le caractère de continuité de ligne (_) sont surlignés en rouge.

On peut conserver les sauts de lignes et ne pas ajouter d'espace.
Il suffit de concaténer la constante vbCrLf

Dim strSQL As String

strSQL = "SELECT Produits.ID, Produits.[Code du produit], Produits.[Nom du produit]" & vbCrLf & _
         "FROM Produits" & vbCrLf & _
         "WHERE (((Produits.Codefournisseur)='EXOLI'))" & vbCrLf & _
         "ORDER BY Produits.[Nom du produit];"

Le code précédent peut aussi être écrit sans caractère de continuité de ligne.

Dim strSQL As String

strSQL = "SELECT Produits.ID, Produits.[Code du produit], Produits.[Nom du produit]" & vbCrLf 
strSQL = strSQL & "FROM Produits" & vbCrLf 
strSQL = strSQL & "WHERE (((Produits.Codefournisseur)='EXOLI'))" & vbCrLf
strSQL = strSQL & "ORDER BY Produits.[Nom du produit];"

Au final, la variable strSQL contient le même code SQL que celui de la requête « Requête1 ».
Toutefois, strSQL n'est pas une requête, car ça n'est pas un objet de la base de données.
C'est une variable texte qui contient une instruction SQL.
Je peux utiliser strSQL pour l'affecter à la propriété d'un objet Visual Basic, ou l'utiliser en tant qu'argument d'une méthode ou d'une fonction.
En gros, partout où l'aide indique que l'on peut utiliser une instruction SQL.

Supposons, sur la base de l'exemple précédent, que l'on veuille que le code fournisseur puisse être modifié et qu'il prenne la valeur d'une variable.
Il s'agit de cette ligne :

         "WHERE (((Produits.Codefournisseur)='EXOLI'))" & vbCrLf & _

On veut que le code fournisseur inscrit « en dur » (EXOLI) puisse être variable.

Pour cela, nous mettrons le code fournisseur (chaîne de caractères) dans la variable déclarée ci-dessous :

Dim strCodeFournisseur As String

Nous allons maintenant découper la chaîne de caractères en trois, de manière à isoler la valeur que l'on souhaite rendre variable.
Ce que j'appelle valeur, est ici, le texte EXOLI.

La ligne ...

qui ne comporte qu'une seule chaîne de caractères, peut s'écrire ...

La valeur (EXOLI) a été isolée dans la deuxième chaîne (surlignée en vert).
Il n'y a plus qu'à remplacer cette chaîne par la variable.

Le code Visual Basic, utilisé pour mettre l'instruction SQL dans la variable strSQL, est désormais :

strSQL = "SELECT Produits.ID, Produits.[Code du produit], Produits.[Nom du produit]" & vbCrLf & _
         "FROM Produits" & vbCrLf & _
         "WHERE (((Produits.Codefournisseur)='" & strCodeFournisseur & "'))" & vbCrLf & _
         "ORDER BY Produits.[Nom du produit];"

Nous avons introduit une partie variable, par l'intermédiaire de la variable strCodeFournisseur.
On peut maintenant, facilement modifier l'instruction SQL contenue dans la variable strSQL, en jouant sur le contenu de la variable strCodeFournisseur.

Voyons maintenant comment mettre tout cela en œuvre à l'aide d'un exemple.
Nous avons un formulaire dont le contenu d'une zone de liste changera dynamiquement.
Ce formulaire contient deux zones de liste indépendantes et une étiquette.

La zone de liste lstFournisseurs contient tous les fournisseurs et la zone de liste lstProduits tous les produits de tous les fournisseurs.

Propriétés des zones de liste :

Nous voyons que la propriété « contenu » des deux zones de liste est une instruction SQL.
Celle-ci est obtenue grâce au générateur de requête, invoqué en cliquant sur le bouton à droite de la ligne de la propriété « contenu ».

Nous allons maintenant faire en sorte que, lorsque la sélection de la zone de liste lstFournisseurs change, la zone de liste lstProduits n'affiche que les produits du fournisseur sélectionné.
Pour cela nous allons utiliser la procédure événementielle « Après MAJ » de la zone de liste lstFournisseurs.
Le code de cette procédure devra modifier l'instruction SQL de la propriété « contenu » de la zone de liste lstProduits.
On va réutiliser le code Visual Basic vu un peu plus tôt avec la requête « Requête1 ».

Private Sub lstFournisseurs_AfterUpdate()
Dim strSQL As String
Dim strCodeFournisseur As String

' Colonne liée = Code Fournisseur (Fournisseurs.CodeFournisseur)
strCodeFournisseur = Me.lstFournisseurs.Value

' Construction instruction SQL de sélection avec concaténation de
' la variable strCodeFournisseur
strSQL = "SELECT Produits.ID, Produits.[Code du produit], Produits.[Nom du produit]" & vbCrLf & _
         "FROM Produits" & vbCrLf & _
         "WHERE (((Produits.CodeFournisseur)=" & strCodeFournisseur & "))" & vbCrLf & _
         "ORDER BY Produits.[Nom du produit];"

' Affectation de la nouvelle instruction SQL à la source
' de la zone de liste lstProduits
Me.lstProduits.RowSource = strSQL

' On copie le contenu de la variable strSQL dans l'étiquette lblSQLlstProduits
Me.lblSQLlstProduits.Caption = strSQL
End Sub

Avec ce simple code, nous avons introduit une partie variable dans l'instruction SQL (requête), source de la zone de liste lstProduits.

Jusqu'ici, nous avons vu comment mettre le code d'une instruction SQL (ou requête) dans une variable Visual Basic de type String, et comment faire qu'une partie de ce code soit variable.
Dans l'exemple utilisé, la partie variable était une valeur de type texte.
Le chapitre suivant va aborder les différents types de valeurs et la façon dont il faut les concaténer.

Les valeurs de type numérique doivent être écrites au format américain.
Le point (.) est le séparateur décimal et il n'y a pas de séparateur pour les milliers.
Deux cent cinquante mille trois cent vingt neuf et trois cent soixante treize millièmes s'écrit : 250329.373

Les nombres entiers ne sont pas concernés puisqu'il n'y a pas de décimales.

En Visual Basic il faut donc convertir des nombres en texte, formatés comme décrit précédemment. Si vous ne le faites pas de manière explicite, Visual Basic le fera pour vous.

Par exemple, ici, je concatène du texte avec un nombre réel double.

Dim strCrit As String
Dim dblPrix As Double

dblPrix = 99.99
strCrit = "Prix = " & dblPrix

Visual Basic va convertir dblPrix en texte avant de le concaténer.
Mais il y a un problème. Comme je suis en France, la virgule est le séparateur décimal dans mes paramètres régionaux.
strCrit va donc contenir :

Prix = 99,99

Le moteur de base de données quant à lui attend :

Prix = 99.99

Solution 1 : Remplacer la virgule par un point, à l'aide de la fonction Visual Basic Replace.

strCrit = "Prix = " & Replace(CStr(dblPrix), ",", ".")

Solution 2 : Utiliser la fonction Str qui met toujours un point.

strCrit = "Prix = " & Str(dblPrix)

Il y a une double contrainte dans l'écriture de valeurs de type Date.
Elles sont écrites au format date américain et elles sont délimitées (encadrées) par le caractère dièse (#).

Le format date américain est mois/jour/année.
En Visual Basic on pourra utiliser la fonction Format pour convertir une donnée Date/Time en texte.

Tout comme avec un nombre, si on laisse Visual Basic effectuer la conversion Date/Time en texte, on s'expose au problème des paramètres régionaux.
Visual Basic va convertir la date en texte, et la formater selon la configuration des paramètres régionaux.
En France on aura le jour avant le mois, et le moteur de base de données interprétera mal la date puisqu'il va la lire comme si le mois était avant le jour.

Exemple :

Dim strCrit As String
Dim dtCmde As Date

dtCmde = DateSerial(2009,3,10) ' 10 mars 2009
strCrit = "[Date Commande] = #" & dtCmde & "#"

strCrit contient

[Date Commande] = #10/03/2009#

Le moteur de base de données va lire 3 octobre 2009, alors qu'on voulait le 10 mars 2009.

Solution : utiliser la fonction Format.

strCrit = "[Date Commande] = #" & Format(dtCmde, "mm\/dd\/yyyy") & "#"

Les champs de type Date dans Access, contiennent à la fois la date et l'heure.
Si on les utilise sans préciser l'heure, cette dernière est par défaut 00:00:00 .
Dans l'exemple précédent, #10/03/2009# est en fait l'écriture réduite de #10/03/2009 00:00:00# .

Cet exemple crée un critère sur le champ dateHeure, pour extraire les valeurs entre le 11 mars 09 10:00:00 et le 16 mars 09 18:00:00 .

Dim strCrit As String
Dim date1 As Date, date2 As Date

date1 = DateSerial(2009, 3, 11) + TimeSerial(10, 0, 0) ' 11 mars 09 10:00:00
date2 = DateSerial(2009, 3, 16) + TimeSerial(16, 0, 0) ' 16 mars 09 16:00:00

strCrit = "[dateHeure] BETWEEN " & _
          "#" & Format(date1, "mm\/dd\/yyyy h\:n\:s") & "# AND " & _
          "#" & Format(date2, "mm\/dd\/yyyy h\:n\:s") & "#"

Pour en savoir plus sur les dates, je vous invite à consulter Les Fonctions Date/Heure rédigé par Par Maxence Hubiche.

Les valeurs de type booléen s'écrivent en langue anglaise.
True/False ou Yes/No pour Vrai/Faux.

Lors de la conversion en texte, nous avons le même souci, lié à la langue, qu'avec les dates : la conversion s'appuie sur les paramètres régionaux.

Dim strCrit As String
Dim blnRupture As Boolean

blnRupture = False
strCrit = "[Rupture de stock] = " & blnRupture

strCrit contient :

[Rupture de stock] = Faux

Ne reconnaissant le mot Faux, le moteur de base de données va l'interpréter comme étant un paramètre.

Dans Visual Basic les variables booléennes sont stockées sous forme d'entiers 16-bits : -1/0 pour Vrai/Faux.
On peut utiliser -1/0 en lieu et place de True/False dans une expression SQL Jet.

strCrit = "[Rupture de stock] = " & CInt(blnRupture)

Il y a un petit désavantage. Le code SQL est moins lisible qu'avec True/False où on reconnait tout de suite qu'il s'agit de valeurs booléennes.

Autre solution avec IIf :

strCrit = "[Rupture de stock] = " & IIf(blnRupture, "True", "False")

Dans le SQL d'Access, les valeurs de type texte (chaînes de caractères) sont délimitées (encadrées) par des guillemets doubles (") ou simples (').
On peut utiliser indifféremment l'un ou l'autre.
Visual Basic, quant à lui, ne reconnait que le guillemet double en tant que délimiteur de chaînes de caractères.

Rappel : à l'intérieur d'une chaîne de caractères Visual Basic, le caractère guillemet double doit être doublé, pour être interprété comme un caractère et non un délimiteur.
Par exemple, pour affecter à ma variable maVarTexte, le texte « il ne faut pas de "s" à chaque »

maVarTexte = "il ne faut pas de ""s"" à chaque"

Cette même règle s'applique au SQL d'Access.
Il faut doubler le délimiteur de chaîne de caractères, si celui-ci est un caractère à l'intérieur de la chaîne.
Nous allons voir des exemples SQL, de clause WHERE, où nous reprendrons l'exemple de texte précédent plus celui-ci : « Utilisation non valide de '.', '!', ou '()'. »

Si on utilise " comme délimiteur :

WHERE MonChampTexte = "pas de ""s"" à chaque"

WHERE MonChampTexte = "Utilisation non valide de '.', '!', ou '()'."

Si on utilise ' comme délimiteur :

WHERE MonChampTexte = 'pas de "s" à chaque'

WHERE MonChampTexte = 'Utilisation non valide de ''. '', ''! '', ou ''()''.'

Voyons maintenant comment mettre tout cela dans une variable Visual Basic de type String.
La difficulté est de "jongler" avec les délimiteurs de texte Visual Basic et SQL.
Dans les exemples de code, nous n'écrirons que le critère portant sur le champ MonChampTexte.

Si on utilise " comme délimiteur :

strCrit = "MonChampTexte = ""pas de """"s"""" à chaque"""

strCrit = "MonChampTexte = ""Utilisation non valide de '.', '!', ou '()'.""

Si on utilise ' comme délimiteur :

strCrit = "MonChampTexte = 'pas de ""s"" à chaque'"

strCrit = "MonChampTexte = 'Utilisation non valide de ''.'', ''!'', ou ''()''.'"

Nous allons encore corser les choses, en mettant le texte à comparer au champ MonChampTexte, dans deux variables.

Dim strCrit As String
Dim strTexte1 As String, strTexte2 As String

' Texte : pas de "s" à chaque
strTexte1 = "pas de ""s"" à chaque"

' Texte : Utilisation non valide de '.', '!', ou '()'. 
strTexte2 = "Utilisation non valide de '.', '!', ou '()'."

Comme nous sommes en Visual Basic, j'ai doublé les guillemets doubles autour du s car ils sont à l'intérieur d'une chaîne de caractères VB.

Si on utilise " comme délimiteur :

strCrit = "MonChampTexte = """ & strTexte1 & """"

strCrit = "MonChampTexte = """ & strTexte2 & """"

Cela ne fonctionne que pour le deuxième exemple. Pourquoi ? Parce que la variable strTexte1, dans le premier exemple, contient des caractères guillemets doubles, et qu'ils ne sont pas doublés. On va obtenir ceci dans la variable strCrit :

Ce n'est pas du SQL correct.
J'ai surligné en bleu le délimiteur de début de chaîne, et en gris le délimiteur de fin de chaîne.
Le moteur de base de données voit deux chaînes de caractères. Je les ai surlignées en jaune.

La solution la plus rapide consiste à doubler les éventuels guillemets doubles, avec la fonction Visual Basic Replace.

strCrit = "MonChampTexte = """ & Replace(strTexte1, """", """""") & """"

strCrit = "MonChampTexte = """ & Replace(strTexte2, """", """""") & """"

Si on utilise ' comme délimiteur :

strCrit = "MonChampTexte = '" & strTexte1 & "'"

strCrit = "MonChampTexte = '" & strTexte2 & "'"

Cette fois-ci, c'est la deuxième ligne qui ne fonctionne pas, parce que les guillemets simples n'ont pas été doublés.
La variable strCrit va contenir :

Nous pouvons, encore une fois, utiliser la fonction Replace pour doubler les guillemets simples.

strCrit = "MonChampTexte = '" & Replace(strTexte1, "'", "''") & "'"

strCrit = "MonChampTexte = '" & Replace(strTexte2, "'", "''") & "'"

De tout cela, il se dégage une chose : utiliser des guillemets simples, comme délimiteurs de chaîne de caractères SQL, est un peu plus simple et plus lisible.

Nous avons vu que l'écriture de valeurs littérales en SQL Access est soumise à certaines règles.
En voici un résumé :

L'onglet « Commandes » comporte une zone de liste lstCmdesClient dont la fonction est de lister un résumé des commandes du client.
Le bouton « Créer liste » (cmdCreerLstCmdesClient) réalise cette tâche, en créant dynamiquement une instruction SQL, et en l'affectant à la source de la zone de liste.

Voici le code de l'événement « sur clic » du bouton :

Private Sub cmdCreerLstCmdesClient_Click()
Dim strSociete As String

strSociete = Nz(Me.Société, "")
If Len(strSociete) > 0 Then
   Me.lstCmdesClient.RowSource = Me.CreerInstSqlCmdesClient(strSociete)
   Me.lblSQLlstCmdesClient.Caption = Me.lstCmdesClient.RowSource
End If
End Sub

Pour ceux qui ne connaissent pas la fonction Access Nzfonction Nz, son rôle est de remplacer la valeur Null par une expression de son choix.
On peut ainsi, éviter l'erreur utilisation  incorrecte  de  NullErreur d'exécution 94, et la propagation de la valeur Null dans une expression.
La conséquence d'une propagation de Null dans une expression, est que le résultat de cette dernière est lui-même Null.

L'instruction SQL, utilisée comme source de la zone de liste, a été créée en faisant un copier/coller du code SQL de cette requête :

SELECT Commandes.[Réf commande], Commandes.[Réf client], Clients.Société, 
   Count([Détails commande].[Réf produit]) AS Articles, 
   Sum([Prix unitaire]*[Quantité]*(1-[Remise])) AS [Montant Commande]
FROM (Clients INNER JOIN Commandes ON Clients.ID = Commandes.[Réf client])
   INNER JOIN [Détails commande] ON Commandes.[Réf commande] = [Détails commande].[Réf commande]
WHERE (((Clients.Société)='Nom Société'))
GROUP BY Commandes.[Réf commande], Commandes.[Réf client], Clients.Société;

La partie variable de l'instruction SQL portera sur le critère de la clause WHERE.
Le champ Société étant de type texte il faudra concaténer une valeur littérale texte.
On fait le choix d'utiliser le guillemet simple comme délimiteur de texte SQL.

La fonction CreerInstSqlCmdesClient crée le texte de l'instruction SQL, en y insérant la partie variable, fournie en argument.

Function CreerInstSqlCmdesClient(strSociete As String) As String
Dim strSQL As String
Dim strSQLSELECT As String
Dim strSQLWHERE As String
Dim strSQLGROUPBY As String

On met tout le texte de "SELECT" jusqu'à "WHERE" dans la variable strSQLSELECT.

strSQLSELECT = _
"SELECT Commandes.[Réf commande], Commandes.[Réf client], " & _
"Clients.Société, Count([Détails commande].[Réf produit]) AS Articles, " & _
"Sum([Prix unitaire]*[Quantité]*(1-[Remise])) AS [Montant Commande]" & vbCrLf & _
"FROM (Clients INNER JOIN Commandes ON Clients.ID = Commandes.[Réf client]) " & _
"INNER JOIN [Détails commande] " & _
"ON Commandes.[Réf commande] = [Détails commande].[Réf commande]"

On met tout le texte de la clause GROUP BY dans la variable strSQLGROUPBY

strSQLGROUPBY = _
"GROUP BY Commandes.[Réf commande], Commandes.[Réf client], Clients.Société;"

On crée le texte de la clause WHERE en concaténant les parties fixes et la variable strSociete.
Comme strSociete peut contenir des guillemets simples ('), et que ce caractère est utilisé ici comme délimiteur de texte dans l'instruction SQL, on ne concatène pas la variable directement.
On utilise la fonction Replace pour doubler les guillemets simples.

strSQLWHERE = "WHERE (((Clients.Société)='" & _
              Replace(strSociete, "'", "''") & "'))"

Enfin, on assemble toutes les parties de l'instruction SQL dans la variable strSQL.

strSQL = strSQLSELECT & vbCrLf & _
         strSQLWHERE & vbCrLf & _
         strSQLGROUPBY
         
CreerInstSqlCmdesClient = strSQL
End Function

Bouton « Créer requête »
Le code de l'événement « sur clic » du bouton « Créer requête » fait presque la même chose que celui du bouton « Créer liste ».
Mais au lieu d'affecter l'instruction SQL générée, à la source d'une zone de liste, il va la sauver dans une requête de la base de données.
Le code utilise la bibliothèque DAO, sur laquelle Christophe Warin a écrit un article de référence : Définition et manipulation de données avec DAODAO.
Voir la partie 4.7. L'objet QueryDefL'objet QueryDef pour ce qui concerne la manipulation de requêtes en tant qu'objets de base de données Access.

Private Sub cmdCreerRequeteCmdesClient_Click()
Dim db As DAO.Database, qd As DAO.QueryDef
Dim strRequete As String, strSQL As String
Dim strSociete As String
' Nom requête à modifier ou créer
strRequete = "reqCmdesUnClient"
' Nom société
strSociete = Nz(Me.Société, "")
If Len(strSociete) > 0 Then
   Set db = CurrentDb
   ' Crée le code SQL et le met dans la variable strSQL
   strSQL = CreerInstSqlCmdesClient(strSociete)
   ' On s'assure que la requête n'est pas ouverte.
   DoCmd.Close acQuery, strRequete
   ' Tente d'obtenir l'objet QueryDef correspondant à
   ' la requête. Si elle n'existe pas une erreur se produit
   On Error Resume Next
   Set qd = db.QueryDefs(strRequete)
   On Error GoTo 0
   If qd Is Nothing Then
      ' Si la requête n'existe pas, on la crée avec
      ' son code SQL
      Set qd = db.CreateQueryDef(strRequete, strSQL)
   Else
      ' Affecte le nouveau code SQL de la requête
      qd.SQL = strSQL
   End If
   qd.Close
   Set db = Nothing
   ' Ouvre la requête en mode feuille de données
   DoCmd.OpenQuery strRequete
   Me.SetFocus
End If
End Sub

Dans l'onglet « Autres infos » il y a deux parties que je nommerai zone 1 et zone 2.

V-B-1. Zone 1▲

INSERT INTO TableDestination
(ChampDest1, ChampDest2, ...)
VALUES(Valeur1, Valeur2, ...)

Sub CreerInstrSql1()
Dim strRefCmde As String
Dim strTbl As String, strSQL As String, strVal As String

strTbl = "tblCommandes"
strRefCmde = CStr(Nz(Me.Réf_commande, 0))

If strRefCmde = "0" Then Exit Sub

strSQL = "INSERT INTO [" & strTbl & "] " & vbCrLf & _
         "([Réf commande], " & _
         "[Réf employé], [Société], [Date de commande], " & _
         "[Date d'expédition], MontantTotal, " & _
         "NbreArticles, Remise)" & vbCrLf & _
         "VALUES ("

strSQL = strSQL & strRefCmde & ", "

strSQL = strSQL & Nz(Me.Réf_employé, "Null") & ", "

strVal = Nz(Me.Société, "Null")
strSQL = strSQL & "'" & Replace(strVal, "'", "''") & "', "

strSQL = strSQL & "#" & _
         Format(Me.Date_de_commande, "m\/d\/yyyy") & "#, "

If IsNull(Me.Date_d_expédition) Then
   strSQL = strSQL & "Null, "
Else
   strVal = Format(Me.Date_d_expédition, "m\/d\/yyyy")
   strSQL = strSQL & "#" & strVal & "#, "
End If

strVal = Str(Nz(DSum("MontantLigne", "reqDetCmde", "[Réf commande]=" & strRefCmde), 0))
strSQL = strSQL & strVal & ", "

strVal = DCount("*", "reqDetCmde", "[Réf commande]=" & strRefCmde)
strSQL = strSQL & strVal & ", "

If Nz(DSum("Remise", "reqDetCmde", "[Réf commande]=" & strRefCmde), 0) > 0 Then
   strVal = "True"
Else
   strVal = "False"
End If

strSQL = strSQL & strVal & ")"

Me.lblSQLinsert.Caption = strSQL
End Sub

V-B-2. Zone 2▲

DCount(Expr As String, Domain As String, [Criteria])

Public Function CLittSql(expr As Variant, TypeSql As TypeSqlLitteral)
Dim strRet As String

If IsNull(expr) Then
   strRet = "Null"
ElseIf IsEmpty(expr) Then
   strRet = "Null"
Else
   Select Case TypeSql
       Case TypeSqlLitteral.sqlNombre
            strRet = Trim(Str(expr))
       Case TypeSqlLitteral.sqlDate
            strRet = "#" & Format(expr, "m\/d\/yyyy") & "#"
       Case TypeSqlLitteral.sqlDateheure
            strRet = "#" & Format(expr, "m\/d\/yyyy hh\:nn\:ss") & "#"
       Case TypeSqlLitteral.sqlBooleen
            If (expr = True) Then strRet = "True" Else strRet = "False"
       Case TypeSqlLitteral.sqlTexte
            strRet = "'" & Replace(expr, "'", "''") & "'"
   End Select
End If
CLittSql = strRet
End Function

Public Enum TypeSqlLitteral
    sqlNombre
    sqlDate
    sqlDateheure
    sqlBooleen
    sqlTexte
End Enum

Private Sub cmdNbCmdesMemeDate_Click()
Dim strCrit As String

strCrit = "[Date de commande]=" & CLittSql(Me.Date_de_commande, sqlDate)
Me.txtNbCmdesMemeDate = DCount("*", "Commandes", strCrit)

End Sub

Private Sub cmdNbCmdesPays_Click()
Dim strCrit As String

If Not IsNull(Me.cboPays) Then
   strCrit = "[Pays/région d'expédition]=" & CLittSql(Me.cboPays, sqlTexte)
   Me.txtNbCmdesPays = DCount("*", "Commandes", strCrit)
Else
   Me.txtNbCmdesPays = DCount("*", "Commandes")
End If

End Sub

Private Sub cmdNbCmdesPaysMemeDate_Click()
Dim strCrit As String

strCrit = "[Date de commande]=" & CLittSql(Me.Date_de_commande, sqlDate)
If Not IsNull(Me.cboPays2) Then
   strCrit = strCrit & " AND " & _
          "[Pays/région d'expédition]=" & CLittSql(Me.cboPays2, sqlTexte)
End If
Me.txtNbCmdesPaysMemeDate = DCount("*", "Commandes", strCrit)

End Sub

Private Sub cmdNbCmdesMemeDateExp_Click()
Dim strCrit As String

strCrit = "[Date d'expédition]"
' Choix opérateur de comparaison
If IsNull(Me.Date_d_expédition) Then
   strCrit = strCrit & " Is "
Else
   strCrit = strCrit & "="
End If
' Concatène valeur de comparaison
strCrit = strCrit & CLittSql(Me.Date_d_expédition, sqlDate)

Me.txtNbCmdesMemeDateExp = DCount("*", "Commandes", strCrit)

End Sub