22- Comillas Simples o Dobles
Autor:
Patxi Sanz
patxisanz@yahoo.es
Tudela (NA)
Vamos a suponer que tenemos lo siguiente:
Nombre de la tabla: tblPersonas
Campos de la tabla:
- idPersona -> Clave y autonumérico
- nombrePersona -> Texto
- apellidosPersona -> Texto
Ahora, la cuestión del mensaje: ¿cuándo debo usar comillas dobles y cuándo comillas simples? La respuesta es muy sencilla, por lo menos al principio, luego ya lo complicaremos: Siempre que usemos un texto o literal de texto, debemos usar comillas dobles para delimitarlo.
Así, si en la tabla anterior queremos contar las personas cuyo nombre sea Pepe, podemos usar DCont en un control de un formulario:
= DCont("nombrePersona"; "tblPersonas"; "nombrePersona = 'Pepe'")
¿Y en qué se traduce esta función y las comillas usadas? Pues en esto:
DCont es el nombre de la función que vamos a usar, y tiene los siguientes argumentos:
- Nombre del campo que se va a buscar. Debe ser un texto.
- Nombre de la tabla dónde está el campo. Debe ser un texto.
- Criterio a usar para determinar qué registros se cuentan. Está definido como Variant, aunque normalmente vamos a establecer un texto como criterio.
Y viendo el ejemplo de la función, vemos que estamos pasando lo siguiente:
- "nombrePersona" : El nombre del campo que vamos a usar para el contaje. Como es un literal, es decir, estamos indicando directamente el nombre del campo, debemos delimitar el texto. Y esto se consigue con las comillas dobles al principio y al final.
- "tblPersonas" : El nombre de la tabla donde se encuentra el campo. Este valor actúa igual que el anterior: es un literal de texto o valor constante, y lo delimitamos con comillas dobles para indicar exactamente eso: que es un valor constante y, además, de texto.
- "nombrePersona = 'Pepe'" : El criterio que queremos usar: en el campo nombrePersona debe estar el valor Pepe. Al ser un literal de texto, debemos delimitarlo con comillas dobles para que Access lo entienda así, pero además debemos tener en cuenta otra cosa: Pepe es otro literal de texto que se encuentra dentro de otro literal y, por tanto, también debemos delimitarlo.
Bueno, vale: ¿pero por qué has usado comillas simples para delimitar el Pepe, si has dicho que las comillas dobles son las que delimitan el texto?
Porque Access se habría quejado: si usamos comillas dobles para delimitar el texto Pepe:
= DCont("nombrePersona"; "tblPersonas"; "nombrePersona = "Pepe"")
Access empieza a leer de izquierda a derecha, y se encuentra lo siguiente:
"nombrePersona = "
Que es un literal de texto perfectamente delimitado por 2 comillas dobles, y lo siguiente que lee es:
Pepe"")
Que no está delimitado correctamente, y ni siquiera le hemos indicado que es una función, por ejemplo, o que lo una a lo anterior mediante el símbolo &, que es el concatenador de textos, con lo que nos arrojará un error:
La expresión que introdujo tiene una sintaxis no válida
Por eso usamos las comillas simples dentro de las comillas dobles: para poder indicarle a Access que Pepe es un literal de texto, y que además se encuentra dentro de otro literal de texto.
Eso está muy bien, pero yo uso controles de un formulario o un informe en los criterios para buscar o contar. ¿Cómo lo hago entonces?
Lo que debes hacer entonces es concatenar los diferentes textos en el criterio con &:
= DCont("nombrePersona"; "tblPersonas"; "nombrePersona = '" & Forms!MiForm!MiControl & "'")
Siguiendo la siguiente regla: Al cambiar la referencia al control, función, etc., por el valor que contiene, la sentencia debe quedar igual que si usaras un literal.
Sí, claro: con un único criterio lo haces muy bien: ¿pero qué pasa cuando tienes más criterios a usar? ¿eh, majete? ¿cómo hacerlo para no volverte loco con tantas comillas dobles y simples?
En ese caso puedes usar una pequeña herramienta que tienes en Access, para verificar que estás haciéndolo bien: la ventana Inmediato del editor de VBA. Si en esta ventana escribimos lo siguiente:
Parametro1 = "Pepe"
? "nombrePersona = '" & Parametro1 & "'"
Y pulsamos Enter al final de cada línea, nos aparecerá lo siguiente:
nombrePersona = 'Pepe'
¿Y qué vemos? Lo mismo que va a ver Access al usar esa fórmula, por lo que podemos usarlo como base de nuestro criterio. Por lo que si abrimos el formulario que nos va a servir de base del criterio, y en la ventana Inmediato modificamos la sentencia:
? "nombrePersona = '" & Forms!Personas!nombrePersona & "'"
Y pulsamos Enter al final, nos encontramos lo siguiente:
nombrePersona = 'Pepe'
Con lo que podemos hacer pruebas para encontrar el criterio que necesitamos:
? "nombrePersona = '" & Forms!Personas!nombrePersona & "' AND apellidosPersona = '" & Forms!Personas!apellidosPersona & "'"
Para ver lo siguiente:
nombrePersona = 'Pepe' AND apellidosPersona = 'Pérez'
¡Vale! Ahora sí que te fastidio: yo tengo un amigo que se llama Brian O'Hara: ¿cómo lo busco? Porque me vuelve a dar error tus consultitas
Si usamos el método de delimitar subtextos con comillas simples, es normal que te de error este criterio:
"nombrePersona = 'Brian' AND apellidosPersona = 'O'Hara'"
Por el mismo motivo que antes nos daba error al delimitar el Pepe con comillas dobles:
"nombrePersona = "Pepe""
Es decir, Access sigue leyendo de izquierda a derecha, por lo que lee esto:
"nombrePersona = 'Brian' AND apellidosPersona = 'O'
Todo muy correcto. Pero luego lee esto otro:
Hara'"
Y es cuando se vuelve loco, ya que no lo entiende: ¿qué debemos hacer? Pues indicar que la comilla simple del apellido O'Hara forma parte del texto. ¿Y cómo se hace? Agregando otra comilla simple para tener 2 comillas simples seguidas:
"nombrePersona = 'Brian' AND apellidosPersona = 'O''Hara'"
Ahora, al encontrarse Access con las 2 comillas simples seguidas, entiende que es una comilla simple y que forma parte del texto, con lo que nos dará el resultado que queremos, sin errores de sintaxis.
Pero también tenemos otra posibilidad: como O'Hara es un texto, también lo podemos delimitar con comillas dobles. ¿Cómo? Eso no es posible. Antes has dicho que nos iba a dar errores. Si colocamos una comilla doble para delimitar el subtexto, es normal que nos de error. Pero si usamos la técnica de las 2 comillas simples, y colocamos 2 comillas dobles, el resultado es el mismo: Access entiende que las 2 comillas dobles implican que en realidad debe dejar una para formar el texto. Así, si en la ventana Inmediato escribimos lo siguiente:
? "nombrePersona = """ & Forms!Personas!nombrePersona & """ AND apellidosPersona = """ & Forms!Personas!apellidosPersona & """"
Y pulsamos Enter, el resultado es el siguiente:
nombrePersona = "Brian" AND apellidosPersona = "O'Hara"
Un texto completamente válido. Y, por tanto, podemos usar el criterio en nuestras búsquedas.
¡Pues vaya! Espera un momentito que busque otro fallo... ¡uhmmm! ¡Ya está! ¡Lo encontré! ¡Je, je! ¿Qué pasa con los nombres de las empresas: Repostería "La alegre caries" me da un error de sintaxis con tus dobles comillas.
Porque ahora tienes dobles comillas para delimitar los textos de búsqueda, y Access se encuentra con una doble comilla ("La alegre caries"), donde no tendría que estar. Para evitarlo, hay que buscar esas dobles comillas y convertirlas en 2 dobles comillas:
? "nombrePersona = """ & Replace(Forms!Personas!nombrePersona,"""","""""") & """ AND apellidosPersona = """ & replace(Forms!Personas!apellidosPersona,"""","""""") & """"
Que nos da como resultado:
nombrePersona = "Repostería" AND apellidosPersona = """La alegre caries"""
¡Mi madre! Creí que me ibas a reducir los criterios, y me los estás alargando. Ahora sí que me he perdido con tantas " y más '.
Pues sí, en esto te tengo que dar la razón: si queremos controlar las comillas, tenemos que escribir "chorizos" muy largos. Pero siempre nos quedan un par de soluciones:
En vez de usar =, usar LIKE y reemplazar las comillas simples y dobles por ?. Es bueno para no tener tantos criterios, pero nos puede dar resultados inesperados: encontrar OSHara en vez de O'Hara, por ejemplo.
¡Espera un momentín! He creado una consulta con un criterio del tipo [Introduzca el nombre], ¡y no me da ningún fallo al pasarle el valor con la ventana que muestra Access! ¿Qué pasa? ¿Que Access sabe más que tú? ¡prrrrt!
Si hubieras esperado un poquito, te habría explicado esa opción: ¿por qué Access no se queja en este tipo de consultas? Porque ese tipo de consultas son consultas parametrizadas, y en estos casos Access no se queja tanto de los datos que le demos, a no ser que no los pueda convertir. Por ejemplo, "Pepe" no se puede convertir en un número, pero sí que podemos pasar O'Hara o Repostería "La alegre caries" para filtrar un campo de texto. Access no se queja y filtra los datos correctamente.
