Cuando estaba escribiendo una página hoy, también estaba muy deprimido. Había registros en la tabla, pero no pude encontrarlos en ASP. Resultó que se debía a los diferentes caracteres comodín en las declaraciones de consulta de acceso y SQL. .
Comparación de caracteres comodín en ACCESS y caracteres comodín en SQL SERVER
==================================================== =
Los caracteres comodín para la biblioteca ACCESS son:
*coincide con cualquier número de caracteres
?coincide con cualquier carácter de una sola letra
Los caracteres comodín en SQL Server son:
% coincide con cualquier número de caracteres
_ coincide con un solo carácter
texto
Cuando estaba escribiendo una página hoy, también estaba muy deprimido. Había registros en la tabla, pero no pude encontrarlos en ASP. La declaración SQL teórica es la siguiente:
Seleccione * FROM t_food Donde t_food.name como '*apple*'
Buscando en GOOGLE, encontré que la consulta difusa en ASP debería escribirse así:
Seleccione * FROM t_food Donde t_food.name como '%%apple%%'
Debe ser %, y debe haber dos. Por favor preste atención.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++
Problema con comodines en la declaración de consulta SQL
Cuando se utilizan declaraciones SQL para consultar datos en Access, se utiliza el carácter comodín * para realizar consultas. El comunicado es el siguiente:
Seleccione * de normal donde el nombre del libro es como '*h*'
Lo probé en la vista SQL de Access sin ningún problema, todo funciona bien. Así que escribí la declaración SQL en el programa C#, pero tan pronto como llegué a la declaración de consulta, se produjo un error. Entonces busqué el archivo de ayuda de Access y encontré la siguiente ayuda:
////////////////////////////////////////////////// /// //////////
Compara una expresión de cadena con un patrón en una expresión SQL.
gramática
expresión como patrón
La sintaxis del operador Me gusta consta de las siguientes partes:
Descripción parcial
expresión La expresión SQL utilizada en la cláusula Where.
El patrón literal de cadena se compara con la expresión.
ilustrar
Puede utilizar el operador Me gusta para buscar valores de campo que coincidan con un patrón específico. Para el patrón, puede especificar un valor completo (por ejemplo, Como Smith) o puede utilizar comodines para buscar un rango de valores (por ejemplo, Como Sm*).
En las expresiones, puede utilizar el operador Me gusta para comparar valores de campo con cadenas. Por ejemplo, si ingresa Como C* en una consulta SQL, la consulta devuelve todos los valores de campo que comienzan con la letra C. En una consulta de parámetros, puede solicitar al usuario que escriba un patrón para buscar.
El siguiente ejemplo devuelve datos que comienzan con la letra P y van seguidos de cualquier letra de la A a la F y tres números:
Me gusta P[AF]###
La siguiente tabla muestra cómo probar diferentes patrones de expresiones a través de Me gusta.
tipo de coincidencia
coincidencia de patrones
(Devuelve verdadero) No hay coincidencia
(Devuelve falso)
Múltiples caracteres a*a aa, aBa, aBBBa aBC
*ab* abc, AABB, Xab aZb, bac
Carácter especial un
aa*a aaa
Varios caracteres ab* abcdefg, abc cab, aab
Carácter único a?a aaa, a3a, aBa aBBBa
Números individuales a#a a0a, a1a, a2a aaa, a10a
Rango de caracteres [az] f, p, j 2, &
Fuera de rango [!az] 9, &, % b, a
Valores no numéricos [!0-9] A, a, &, ~ 0, 1, 9
Valor compuesto a[!bm]# An9, az0, a99 abc, aj0
Dirección de referencia: http://office.microsoft.com/zh-cn/assistance/HP010322532052.aspx
////////////////////////////////////////////////// /// /////////
La ayuda dice esto y no hay problemas. Me confunde aún más. Más tarde, le pregunté a un colega y le dije: Su declaración SQL es incorrecta. El carácter comodín debería ser % en lugar de *. Pero la ayuda dice * y todo funciona bien cuando lo pruebo en Access. Mis colegas no pueden explicar por qué, por lo que continúan buscando respuestas a las solicitudes de ayuda. La siguiente información se encontró en otro archivo de ayuda:
////////////////////////////////////////////////// /// /////////
Los métodos de coincidencia de patrones integrados proporcionan una herramienta general para la comparación de cadenas. La siguiente tabla muestra los caracteres comodín que se pueden utilizar con el operador Me gusta y los números y cadenas con los que coinciden.
Caracteres en patrón Coincidencias en expresión
? o _ (guión bajo) cualquier carácter individual
* o % cero o más caracteres
# Cualquier número (0-9)
[charlist] Cualquier carácter individual en charlist.
[!charlist] Cualquier carácter que no esté en charlist.
Puede utilizar un conjunto de uno o más caracteres (charlist) encerrados entre corchetes ([]) para hacer coincidir cualquier carácter en la expresión, y charlist puede contener la mayoría de los caracteres del juego de caracteres ANSI, incluidos los números. Caracteres específicos como el corchete izquierdo ([), el signo de interrogación (?), el signo de dígito (#) y el asterisco (*) se pueden comparar directamente con los símbolos mismos encerrándolos entre corchetes. El corchete de cierre no se puede usar dentro de un grupo para coincidir con él mismo, pero se puede usar como un carácter único fuera del grupo.
Además de una lista de caracteres simple entre corchetes, una lista de caracteres puede tener límites de rango superior e inferior separados mediante un guión (-). Por ejemplo, cuando se utiliza [AZ] en el patrón, se logra una coincidencia si el carácter correspondiente en la expresión contiene cualquier carácter en mayúscula en el rango de la A a la Z. Puede encerrar varios rangos entre corchetes sin delimitar los rangos. Por ejemplo, [a-zA-Z0-9] coincide con cualquier carácter alfanumérico.
Tenga en cuenta que los caracteres comodín ANSI SQL (%) y (_) solo son válidos en la versión Microsoft® Jet 4.X y en el proveedor Microsoft OLE DB para Jet. Si se usan en Microsoft Access o DAO, se tratan como texto.
Otras reglas importantes para la coincidencia de patrones son las siguientes:
El uso de un signo de exclamación (!) al comienzo de una lista de caracteres indicará que se producirá una coincidencia si aparece algún carácter fuera de la lista de caracteres en la expresión. Cuando se utiliza fuera de los corchetes, el signo de exclamación coincide consigo mismo.
Se puede utilizar un guión (-) al principio (después del signo de exclamación) o al final de una lista de caracteres para que coincida. En cualquier otra posición, el guión identifica una variedad de caracteres ANSI.
Cuando se especifica un rango de caracteres, los caracteres deben aparecer en orden ascendente (AZ o 0-100). [AZ] es un modo válido, [ZA] es un modo no válido.
El orden de los caracteres [ ] se ignora; se trata como un carácter de longitud cero ( ).
Dirección de referencia: http://office.microsoft.com/zh-cn/assistance/HP010322842052.aspx
////////////////////////////////////////////////// /// //////////////
En este punto, finalmente se encontró el motivo. Debido a que uso el comodín * en Access, todo funciona bien, pero si lo cambio a %, no funcionará. En C#, solo se admite el comodín % y reemplazarlo con * provocará un error. ¿Se considera este problema un problema de compatibilidad?
Comodín:
Ejemplo de descripción comodín
% Cualquier cadena que contenga cero o más caracteres. DONDE título LIKE '%computadora%' encontrará todos los títulos de libros que contengan la palabra computadora en cualquier parte del título.
_ (guión bajo) Cualquier carácter individual. WHERE au_fname LIKE '_ean' encontrará todos los nombres de 4 letras que terminen en ean (Dean, Sean, etc.).
[ ] Especifica cualquier carácter en un rango ([af]) o conjunto ([abcdef]). Donde au_lname LIKE '[CP]arsen' encontrará los apellidos de los autores que terminan en arsen y comienzan con cualquier carácter entre C y P, por ejemplo, Carsen, Larsen, Karsen, etc.
[^] Cualquier carácter que no pertenezca al rango especificado ([af]) o conjunto ([abcdef]). Donde au_lname LIKE 'de[^l]%' encontrará todos los apellidos de autor que comiencen con de y no vayan seguidos de l.
Utilice comodines como literales
Puede utilizar cadenas de coincidencia de patrones comodín como cadenas literales encerrando los caracteres comodín entre paréntesis. La siguiente tabla muestra un ejemplo del uso de la palabra clave LIKE y el carácter comodín [ ].
Significado del símbolo
COMO '5[%]' 5%
ME GUSTA '[_]n' _n
COMO '[a-cdf]' a, b, c, d o f
COMO '[-acdf]' -, a, c, d o f
COMO '[ [ ]' [
COMO ']' ]
COMO 'abc[_]d%' abc_d y abc_de
COMO 'abc[def]' abcd, abce y abcf
Coincidencia de patrones usando la cláusula ESCAPE
Busca cadenas que contengan uno o más caracteres comodín especiales. Por ejemplo, la tabla de descuentos en la base de datos de clientes podría almacenar valores de descuento con un signo de porcentaje (%). Para buscar el signo de porcentaje como carácter en lugar de comodín, debe proporcionar la palabra clave ESCAPE y un carácter de escape. Por ejemplo, una base de datos de ejemplo contiene una columna denominada comentario que contiene un 30 % de texto. Para buscar filas que contengan el 30% de la cadena en cualquier lugar de la columna de comentarios, especifique una cláusula Where que consista en el comentario WHERE LIKE '%30!%%' ESCAPE '!'. Si no especifica ESCAPE y el carácter de escape, SQL Server devuelve todas las filas que contienen la cadena 30.
El siguiente ejemplo muestra cómo buscar la cadena 50% de descuento cuando se compran 100 o más copias en la columna de notas de la tabla de títulos en la base de datos de pubs:
Seleccione notas DE títulos Donde notas COMO '50%% de descuento cuando se compran 100 o más copias' ESCAPE '%'