Lorsque j'écrivais une page aujourd'hui, j'étais également très déprimé. Il y avait des enregistrements dans la table, mais je ne les trouvais pas dans ASP. Cela s'est avéré être dû aux différents caractères génériques dans les instructions d'accès et SQL. .
Comparaison des caractères génériques dans ACCESS et des caractères génériques dans SQL SERVER
=================================================== =
Les caractères génériques pour la bibliothèque ACCESS sont :
*correspond à n'importe quel nombre de caractères
?correspond à n'importe quel caractère à une seule lettre
Les caractères génériques dans SQL Server sont :
% correspond à n'importe quel nombre de caractères
_ correspond à un seul caractère
texte
Quand j'écrivais une page aujourd'hui, j'étais aussi très déprimé. Il y avait des enregistrements dans le tableau, mais je ne les trouvais pas dans ASP. L'instruction SQL théorique est la suivante :
Sélectionnez * FROM t_food Où t_food.name comme '*apple*'
En effectuant une recherche sur GOOGLE, j'ai trouvé que la requête floue dans ASP devait être écrite comme ceci :
Sélectionnez * FROM t_food Où t_food.name comme '%%apple%%'
Il doit y en avoir %, et il doit y en avoir deux. S'il vous plaît faites attention.
++++++++++++++++++++++++++++++++++++++++++++++++++ ++ ++++++++++++++++++++++++
Problème de caractère générique d'instruction de requête SQL
Lorsque vous utilisez des instructions SQL pour interroger des données dans Access, le caractère générique * est utilisé pour l'interrogation. La déclaration est la suivante :
Sélectionnez * à partir de la normale où le nom du livre ressemble à '*h*'
Je l'ai essayé dans la vue SQL d'Access sans aucun problème, tout fonctionne bien. J'ai donc écrit l'instruction SQL dans le programme C#, mais dès que l'instruction de requête a été atteinte, une erreur s'est produite. J'ai donc cherché le fichier d'aide d'Access et j'ai trouvé l'aide suivante :
/////////////////////////////////////////////// /// //////////
Compare une expression de chaîne à un modèle dans une expression SQL.
grammaire
expression comme un motif
La syntaxe de l'opérateur Like comprend les parties suivantes :
Description partielle
expression L'expression SQL utilisée dans la clause Where.
Le modèle littéral de chaîne est comparé à l’expression.
illustrer
Vous pouvez utiliser l'opérateur Like pour rechercher des valeurs de champ qui correspondent à un modèle spécifié. Pour le modèle, vous pouvez spécifier une valeur complète (par exemple, Like Smith) ou utiliser des caractères génériques pour rechercher une plage de valeurs (par exemple, Like Sm*).
Dans les expressions, vous pouvez utiliser l'opérateur Like pour comparer les valeurs des champs aux chaînes. Par exemple, si vous saisissez Like C* dans une requête SQL, la requête renvoie toutes les valeurs de champ commençant par la lettre C. Dans une requête paramétrée, vous pouvez inviter l’utilisateur à saisir un modèle à rechercher.
L'exemple suivant renvoie des données commençant par la lettre P et suivies d'une lettre de A à F et de trois chiffres :
Comme P[AF]###
Le tableau suivant montre comment tester différents modèles d'expressions via Like.
type de correspondance
correspondance de motifs
(Retour vrai) Aucune correspondance
(Renvoyer faux)
Plusieurs caractères a*a aa, aBa, aBBBa aBC
*ab* abc, AABB, Xab aZb, bac
Caractère spécial a
aa*a aaa
Plusieurs caractères ab* abcdefg, abc cab, aab
Caractère unique a?a aaa, a3a, aBa aBBBa
Numéros simples a#a a0a, a1a, a2a aaa, a10a
Plage de caractères [az] f, p, j 2 et
Hors plage [!az] 9, &, % b, a
Valeurs non numériques [!0-9] A, a, &, ~ 0, 1, 9
Valeur composée a[!bm]# An9, az0, a99 abc, aj0
Adresse de référence : http://office.microsoft.com/zh-cn/assistance/HP010322532052.aspx
/////////////////////////////////////////////// /// /////////
L'aide dit ceci, et il n'y a aucun problème. Quel est le problème ? Cela me rend encore plus confus. Plus tard, j'ai demandé à un collègue et je lui ai dit : Votre instruction SQL est fausse. Le caractère générique doit être % au lieu de *. Mais l'aide indique *, et tout fonctionne bien lorsque je le teste dans Access. Mes collègues ne peuvent pas expliquer pourquoi, alors ils continuent de chercher des réponses aux demandes d'aide. Les informations suivantes ont été trouvées dans un autre fichier d'aide :
/////////////////////////////////////////////// /// /////////
Les méthodes de correspondance de modèles intégrées fournissent un outil général pour la comparaison de chaînes. Le tableau suivant présente les caractères génériques pouvant être utilisés avec l'opérateur Like, ainsi que les nombres et les chaînes auxquels ils correspondent.
Caractères dans le modèle Correspondances dans l'expression
? ou _ (soulignement) n'importe quel caractère
* ou % zéro ou plusieurs caractères
# N'importe quel numéro (0-9)
[charlist] N'importe quel caractère unique dans charlist.
[!charlist] Tout personnage ne figurant pas dans charlist.
Vous pouvez utiliser un jeu d'un ou plusieurs caractères (charlist) entourés de crochets ([]) pour faire correspondre n'importe quel caractère unique dans une expression, et charlist peut contenir la plupart des caractères du jeu de caractères ANSI, y compris des chiffres. Des caractères spécifiques tels que le crochet gauche ([), le point d'interrogation (?), le signe numérique (#) et l'astérisque (*) peuvent être comparés directement aux symboles eux-mêmes en les plaçant entre crochets. Le crochet fermant ne peut pas être utilisé dans un groupe pour correspondre à lui-même, mais il peut être utilisé comme caractère unique en dehors du groupe.
En plus d'une simple liste de caractères entourée de crochets, une charlist peut avoir des limites supérieure et inférieure séparées à l'aide d'un trait d'union (-). Par exemple, lors de l'utilisation de [AZ] dans un modèle, une correspondance est obtenue si le caractère correspondant dans l'expression contient un caractère majuscule compris entre A et Z. Vous pouvez placer plusieurs plages entre crochets sans délimiter les plages. Par exemple, [a-zA-Z0-9] correspond à n'importe quel caractère alphanumérique.
Veuillez noter que les caractères génériques ANSI SQL (%) et (_) ne sont valides que dans la version Microsoft® Jet 4.X et le fournisseur Microsoft OLE DB pour Jet. S'ils sont utilisés dans Microsoft Access ou DAO, ils sont traités comme du texte.
Les autres règles importantes pour la correspondance de modèles sont les suivantes :
L'utilisation d'un point d'exclamation (!) au début d'une liste de caractères indiquera qu'une correspondance se produira si un caractère en dehors de la liste de caractères apparaît dans l'expression. Lorsqu'il est utilisé en dehors des crochets, le point d'exclamation correspond à lui-même.
Un trait d'union (-) peut être utilisé au début (après le point d'exclamation) ou à la fin d'une liste de caractères pour correspondre à elle-même. Dans toute autre position, le trait d'union identifie une plage de caractères ANSI.
Lorsqu'une plage de caractères est spécifiée, les caractères doivent apparaître par ordre croissant (AZ ou 0-100). [AZ] est un mode valide, [ZA] est un mode invalide.
L'ordre des caractères [ ] est ignoré ; il est traité comme un caractère de longueur nulle ( ).
Adresse de référence : http://office.microsoft.com/zh-cn/assistance/HP010322842052.aspx
/////////////////////////////////////////////// /// //////////////
À ce stade, la raison a enfin été trouvée. Parce que j'utilise le caractère générique * dans Access, tout fonctionne bien, mais si je le change en %, cela ne réussira pas. En C#, seul le caractère générique % est pris en charge, et son remplacement par * provoquera une erreur ! Ce problème est-il considéré comme un problème de compatibilité ?
Caractère générique :
Exemple de description générique
% Toute chaîne contenant zéro ou plusieurs caractères. WHERE titre LIKE '%computer%' trouvera tous les titres de livres contenant le mot ordinateur n'importe où dans le titre.
_ (trait de soulignement) N'importe quel caractère unique. WHERE au_fname LIKE '_ean' trouvera tous les noms de 4 lettres se terminant par ean (Dean, Sean, etc.).
[ ] Spécifie n'importe quel caractère unique dans une plage ([af]) ou un ensemble ([abcdef]). Où au_lname LIKE '[CP]arsen' trouvera les noms d'auteurs se terminant par arsen et commençant par n'importe quel caractère entre C et P, par exemple Carsen, Larsen, Karsen, etc.
[^] Tout caractère unique n'appartenant pas à la plage spécifiée ([af]) ou à l'ensemble ([abcdef]). Où au_lname LIKE 'de[^l]%' trouvera tous les noms d'auteurs commençant par de et non suivis de l.
Utiliser des caractères génériques comme littéraux
Vous pouvez utiliser des chaînes de correspondance de modèles génériques comme chaînes littérales en plaçant les caractères génériques entre parenthèses. Le tableau suivant montre un exemple d'utilisation du mot-clé LIKE et du caractère générique [ ].
Signification du symbole
COMME '5[%]' 5%
COMME '[_]n' _n
COMME '[a-cdf]' a, b, c, d ou f
COMME '[-acdf]' -, a, c, d ou f
COMME '[ [ ]' [
COMME ']' ]
COMME 'abc[_]d%' abc_d et abc_de
COMME 'abc[def]' abcd, abce et abcf
Correspondance de modèles à l'aide de la clause ESCAPE
Recherche les chaînes contenant un ou plusieurs caractères génériques spéciaux. Par exemple, le tableau des remises dans la base de données clients peut stocker les valeurs de remise avec le signe de pourcentage (%). Pour rechercher le signe de pourcentage sous forme de caractère plutôt que de caractère générique, vous devez fournir le mot clé ESCAPE et un caractère d'échappement. Par exemple, un exemple de base de données contient une colonne nommée commentaire qui contient 30 % de texte. Pour rechercher des lignes contenant 30 % de la chaîne n'importe où dans la colonne de commentaire, spécifiez une clause Where composée du commentaire WHERE LIKE '%30!%%' ESCAPE '!'. Si vous ne spécifiez pas ESCAPE ni le caractère d'échappement, SQL Server renvoie toutes les lignes contenant la chaîne 30.
L'exemple suivant montre comment rechercher la chaîne 50 % de réduction lorsque 100 exemplaires ou plus sont achetés dans la colonne notes de la table titres de la base de données pubs :
Sélectionnez les notes FROM titres Où les notes LIKE '50 % de réduction à l'achat de 100 exemplaires ou plus' ÉCHAPPER '%'