Les requêtes Access ne sont pas sensibles à la casse. Mais la fonction Instr() a un argument de définition de la méthode de comparaison.

Select * from XXX where instr(1,Nom,'tOtO', 0)<>0

Pour faire un VRAI paramètre, il y a deux étapes :

1/ Aller dans Requêtes/Paramètres... et définir le paramètre

Par exemple :
Nom du paramètre : Choisir Année
Type de données : Entier

2/ L'utiliser en l'inscrivant entre crochets.
Exemple :

... WHERE [Choisir Année] = ...

Parameters [Entrez une valeur numérique :] integer;
Select * From LATABLE
Where MONCHAMP =  [Entrez une valeur numérique :];

Ainsi, si vous saisissez 'blablabla' un message d'erreur vous indiquera que la valeur saisie est incorrecte et vous invitera à recommencer.

Donc integer pour un entier, date pour une date, text pour du texte, etc.

Avoir le jour :

Day(LaDate)

Avoir le mois :

Month (LaDate)

Avoir l'année :

Year(LaDate)

Dans les instructions SQL, la plupart des versions MS Access attendent des dates au format américain (mm/dd/yyyy). Dans les clauses de la requête,
les champs typés utilisent des caractères de type :

MonChamp=Valeur 'Numérique 
MonChamp="Valeur" 'Texte

(on peut aussi avoir 'Valeur', mais cette solution est dangereuse. En effet, s'il y a une apostrophe dans Valeur, la clause SQL se perd dans ces apostrophes...)

 MonChamp=#Valeur#  ' Date

Vous voulez que lorsque vous tapez par exemple "infirmiere", on trouve "infirmiére", "infirmière" ou "infirmiere" et vice versa. Bref vous souhaitez sélectionner le mot quel que soit l'accent se trouvant sur le 'e'.

Il suffit d'écrire la requête comme ceci :

Select * From MATABLE Where MONCHAMP Like "*infirmi[eèé]re*"

Utilisez : *

Select * From MATABLE Where VILLE Like "*an"

Tout d'abord, il faut éviter d'utiliser des symboles pour les noms de table ou de champ. Mais si vous ne pouvez échapper à cette contrainte, résolvez le problème en mettant des crochets.

Select [MonChamp#]...

Exemple :

Select * From MATABLE Where VILLE Like "*bord*"

Essayez le signe %

Select * From MATABLE Where VILLE Like "%bord%"

C'est par exemple utile lorsque l'on exploite une base de données Access avec Visual Basic.

La zone de texte se nomme zdt
champ de type numérique :

MonSQL = "Select * From MATABLE Where MONCHAMP = " & zdt

champ de type chaîne de caractères :

MonSQL = "Select * From MATABLE Where MONCHAMP = '" & zdt & "'"

ou bien :

monsql = "Select * From MATABLE Where " & BuildCriteria("MonChamp", dbText, zdt)

champ de type Date :

MonSQL = "Select * From MATABLE Where MONCHAMP = #" & zdt & "#"

ou bien :

monsql = "Select * From MATABLE Where " & BuildCriteria("MonChamp", dbDate, zdt)

Ce sujet est traité ici.
Les liens ci-dessous pourront également répondre à vos questions à ce sujet.

Exemple de question :
ma requête extrait des données et produit, par ligne, les champs "ID" et "VAL1", "VAL2","VAL3". Est-il possible de créer un nouveau champ "TOTAL", indépendant, et dont la valeur est conditionnée par la valeur de ID.
Exemple : si ID = "A", TOTAL = VAL1 + VAL2
si ID = "B", TOTAL = VAL2 + VAL3
si ID = "C", TOTAL = VAL1 + VAL2 + VAL3

Trois fonctions permettent d'effectuer un tel calcul :

1) IIf (VraiFaux()). Pour vérifier plusieurs conditions, il possible d'imbriquer plusieurs IIf.
Pour notre exemple :

Select TEST.ID, IIf([ID]='A',[VAL1]+[VAL2],IIf([ID]='B',[VAL2]+[VAL3],IIf([ID]='C',[VAL1]+[VAL2]+[VAL3]))) AS Total
From TEST;

2) Switch() (PremVrai()). Les arguments de cette expression fonctionnent comme ceci :
Condition à vérifier; Résultat si condition vraie
Pour notre exemple :

Select TEST.ID, Switch([ID]='A',[VAL1]+[VAL2],[ID]='B',[VAL2]+[VAL3],[ID]='C',[VAL1]+[VAL2]+[VAL3]) AS Total
From TEST;

3) Choose() (Choisir()). Cette fonction n'est utile que si la condition à vérifier correspond à un nombre renvoyé par un seul et même champ de la requête. Généralement, le champ à vérifier est la colonne liée d'une petite zone de liste.
Dans cette fonction le premier argument est le champ à vérifier. Le deuxième argument indique la valeur à renvoyer si le premier argument vaut 1, le troisième argument indique la valeur à renvoyer si le premier argument vaut 2, etc.

Revenons à notre exemple. Si le champ ID avait renvoyé un nombre et qu'au lieu de A, B, C... nous avions 1, 2, 3..., voici comment nous aurions pu utiliser la fonction Choose :

Select TEST.ID, Choose([ID],[VAL1]+[VAL2],[VAL2]+[VAL3],[VAL1]+[VAL2]+[VAL3]) AS Total
From TEST;

Remarque : ces trois fonctions évaluent systématiquement la totalité de leurs arguments par conséquent, mieux vaut les utiliser pour de petits calculs conditionnels.
Pour faire des tests complexes sur de nombreuses conditions, il sera préférable de créer une fonction personnalisée utilisant une instruction If Then Else ou Select Case.

Par exemple je suis en janvier 2006 et je veux avoir tous les enregistrements concernant le mois de février 2006. Je dois faire appel au critère suivant :

WHERE (((Year([madate]))=Year(DateAdd("m",1,Date()))) AND ((Month([madate]))=Month(DateAdd("m",1,Date()))));

Où madate est le champ de type date qui nous intéresse.

Prenons l'exemple suivant :

Dans ma table, je souhaite retourner tous les enregistrements où le champ MonChamp contient le mot Masson. En utilisant le critère Comme '*masson*', je retournerais aussi les enregistrements contenant Tomassonage. Si au contraire, je place des espaces entre les astérisques et le mot, je ne retournerais pas par exemple Lucien (Masson).

Pour cela, il suffit d'utiliser le critère suivant afin de vérifier que ce qui se trouve de chaque côté de masson n'est pas une lettre ce qui signifierait que masson est un mot à lui seul.

Comme '*[!a-z]masson[!a-z]*' Ou Comme 'masson[!a-z]*' Ou Comme '*[!a-z]masson' Ou 'masson'

Imaginons cette table :

Champ1
----------
Erreur
Erreur de saisie
**Erreur**

Le but est de réaliser une recherche qui retourne les lignes commençant par deux astérisques.

SELECT Champ1 FROM MATABLE WHERE CHAMP1 LIKE "***"

Le caractère * étant un joker, cette requête retourne toutes les lignes.

Dans l'implémentation SQL d'Access les caractères jokers (wildcard) doivent être mis dans une charlist entre crochets [], ce qui donnerait ici :

SELECT Champ1 FROM MATABLE WHERE CHAMP1 LIKE "[*][*]*"