Veamos un comando simple que ordena al servidor que muestre su número de versión y la fecha actual. Debemos escribir el comando a continuación del prompt mysql> y presionar Enter:
mysql> SELECT VERSION(), CURRENT_DATE;
+---------------------+-------------------------+
| VERSION() | CURRENT_DATE |
+---------------------+-------------------------+
| 5.0.7-beta-Max | 2005-07-11 |
+---------------------+-------------------------+
1 row in set (0.01 sec)
mysql>
Esta consulta nos muestra varias cosas acerca de mysql:
• Un comando normalmente consiste en una sentencia SQL seguida de punto y coma. (Hay excepciones donde el punto y coma puede omitirse. QUIT es una de ellas por ejemplo
• Cuando ingresamos un comando, mysql lo envía al servidor para ser ejecutado e imprime los resultados. A continuación muestra de nuevo el prompt mysql> que está listo para otro comando.
• mysql imprime los resultados de la consulta en forma tabulada (filas y columnas). La primera fila contiene etiquetas para las columnas. Las filas siguientes son los resultados de la consulta. Generalmente, el nombre de cada columna es el nombre del campo que trae desde la base de datos. Si está trayendo el valor de una expresión, en lugar del contenido de un campo o columna de una tabla (como en el ejemplo anterior), mysql etiqueta la columna usando el texto de la expresión.
• mysql informa cuántas filas fueron devueltas y cuánto tiempo le tomó ejecutarse a la consulta, lo cual da una idea aproximada del rendimiento del servidor. Estos valores son imprecisos porque representan tiempo de reloj corriente (no tiempo de CPU), y además porque están afectados por factores como la carga del servidor, etc.
Las palabras clave pueden ingresarse en cualquier combinación de minúsculas y mayúsculas. Por ejemplo, las siguientes consultas mysql son equivalentes:
mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;
Una consulta mysql puede usarse como calculadora como en el siguiente ejemplo:
mysql> SELECT SIN(PI()/4), (4+1)*5;
+---------------------------+-----------+
| SIN(PI()/4) | (4+1)*5 |
+--------------------------+-----------+
| 0.70710678118655 | 25 |
+--------------------------+-- -------+
1 row in set (0.02 sec)
Las consultas que vimos hasta ahora han sido relativamente cortas, sentencias de una sola línea. Se puede inclusive ingresar múltiples sentencias en una misma línea, separándolas con punto y coma, por ejemplo:
mysql> SELECT VERSION(); SELECT NOW();
+----------------+
| VERSION() |
+----------------+
| 5.0.7-beta-Max |
+----------------+
1 row in set (0.00 sec)
+---------------------+
| NOW() |
+---------------------+
| 2005-07-11 17:59:36 |
+---------------------+
1 row in set (0.00 sec)
No es necesario que un comando sea ingresado en una sola línea, de ese modo, comandos extensos que requieren varias líneas no son un problema.
Mysql determina cuando una sentencia ha llegado a l final observando si termina en un punto y coma, no si se llegó al final de la línea física.
Un ejemplo de una consulta mysql de múltiples líneas seria:
mysql> SELECT
-> USER()
-> ,
-> CURRENT_DATE;
+---------------+--------------+
| USER() | CURRENT_DATE |
+---------------+--------------+
| jon@localhost | 2005-07-11 |
+---------------+--------------+
1 row in set (0.00 sec)
En este ejemplo observamos que el prompt cambia de mysql> a -> después que se ha ingresado la primera línea de una consulta de múltiples líneas. Esta es la forma en que mysql advierte que no se ha completado la sentencia y aún espera por el resto.
Si durante el ingreso de un comando decidimos que no queremos ejecutarlo, lo podemos cancelar tipeando \c:
mysql> SELECT
-> USER()
-> \c
mysql>
Es importante observar el prompt de Mysql ya que el mismo nos informa en que estado se encuentra mysql, por ejemplo:
mysql> Listo para un nuevo comando.
-> Esperando la siguiente línea en un comando de múltiples líneas.
'> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con apostrofo (''').
"> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con comillas dobles ('"').
`> Esperando la siguiente línea, se encuentra abierta una cadena que comienza con tilde ('`').
/*> Esperando la siguiente línea, se encuentra abierto un comentario que comienza con /*.
Es frecuente que se origine una sentencia de múltiples líneas cuando accidentalmente le damos entrada a un comando de una sola línea pero olvidamos terminarlo con punto y coma. En ese caso, mysql espera más caracteres:
mysql> SELECT USER()
->
Si esto le ocurre (considera que ha ingresado una sentencia completa pero solamente obtiene un prompt ->), la mayoría de las veces es porque mysql está esperando por el punto y coma. Si no advertimos lo que el indicador trata de decirnos, podría demorar un buen tiempo en hacer lo que necesita. Ingresamos un punto y coma para completar la sentencia, y mysql ejecutará la consulta:
mysql> SELECT USER()
-> ;
+--------------------+
| USER() |
+--------------------+
| joesmith@localhost |
+--------------------+
Los prompts '> y "> aparecen durante el ingreso de cadenas. Podemos escribir cadenas delimitadas por ''' o '"' (por ejemplo, 'hola' o "adiós"), y mysql nos permite ingresar cadenas divididas en múltiples líneas. Cuando vemos un prompt '> o "> significa que comenzamos a ingresar una cadena comenzando con ''' o '"' pero no ingresamos el correspondiente caracter de terminación. A menudo esto significa que inadvertidamente omitió este carácter. Por ejemplo:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30;
'>
Si ingresamos esta sentencia SELECT, presionamos ENTER y esperaos por el resultado, nada ocurrirá. En lugar de asombrarnos por el tiempo que consume la consulta, debemos observar lo que el prompt '> está diciendo. Indica que mysql espera por el final de una cadena inconclusa. En el caso del ejemplo, la cadena 'Smith no tiene el apóstrofo de cierre.
¿Qué hacer llegado a este punto? Lo más simple es cancelar el comando. No obstante, no podemos simplemente tipear \c en este caso, porque mysql interpretará que es parte de la cadena que estamos ingresando. En lugar de eso, escribimos el caracter de cierre que falta y entonces ingresamos \c.>:
mysql> SELECT * FROM my_table WHERE name = 'Smith AND age < 30;
'> '\c
mysql>
El prompt cambia de nuevo a mysql>, informando que mysql está listo para un nuevo comando.
El prompt `> es similar a '> y "> , pero informa que está pendiente de completar un identificador delimitado por tildes.
Es importante conocer el significado de estos indicadores, ya que si por error se ingresa una cadena incompleta, todo lo que se ingrese posteriormente será aparentemente ignorado por mysql — incluyendo el comando QUIT. Esto puede ser sumamente desconcertante, en particular si no se conoce lo que debe hacer para terminar la línea y cancelar el comando.
0 comentarios:
Publicar un comentario en la entrada