Cerciórese de haberse conectado al servidor, tal como se describe en la sección anterior. Esto en sí mismo no selecciona ninguna base de datos para trabajar. En este punto es más importante aprender un poco más acerca de cómo realizar consultas que ir directamente a crear tablas, cargar datos, y recuperarlos. Esta sección describe los principios básicos del ingreso de comandos, empleando varias consultas que puede realizar para familiarizarse con la forma en que funciona mysql.

Aquí tiene un comando simple que ordena al servidor que muestre su número de versión y la fecha actual. Ingréselo a continuación del prompt mysql> y presione 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 le muestra varias cosas acerca de mysql:

Las palabras clave pueden ingresarse en cualquier combinación de minúsculas y mayúsculas. Las siguientes consultas son equivalentes:

mysql> SELECT VERSION(), CURRENT_DATE;
mysql> select version(), current_date;
mysql> SeLeCt vErSiOn(), current_DATE;

Aqui tiene otra consulta que demuestra que mysql puede usarse como calculadora:

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 mostradas hasta ahora han sido relativamente cortas, sentencias de una sola línea. Se puede inclusive ingresar múltiples sentencias en una misma línea. Solamente deben separarse con punto y coma:

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 lineas 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. (En otras palabras, mysql acepta un formato libre para las entradas: recolecta lineas pero no las ejecuta hasta que encuentra el punto y coma.)

Aqui tiene una sentencia de múltiples líneas:

mysql> SELECT
    -> USER()
    -> ,
    -> CURRENT_DATE;
+---------------+--------------+
| USER()        | CURRENT_DATE |
+---------------+--------------+
| jon@localhost | 2005-07-11   |
+---------------+--------------+
1 row in set (0.00 sec)

Observe en este ejemplo 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. El prompt es un aliado, puesto que suministra información valiosa. Si se emplea, siempre se sabrá lo que mysql está esperando.

Si durante el ingreso de un comando decide que no quiere ejecutarlo, cancélelo tipeando \c:

mysql> SELECT
    -> USER()
    -> \c
mysql>

Una vez más observe el prompt. Cambia a mysql> después de que ingresa \c, informándole que mysql está listo para un nuevo comando.

La siguiente tabla muestra cada uno de los indicadores que podrá ver y sintetiza lo que dicen acerca del estado en que se encuentra mysql:

El prompt /*> fue introducido en la serie 5.0 a partir de MySQL 5.0.6.

Es frecuente que se origine una sentencia de múltiples lineas cuando accidentalmente le da entrada a un comando de una sola línea pero olvida terminarlo con punto y coma. En ese caso, mysql aguarda por 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 advierte lo que el indicador trata de decirle, podría demorar un buen tiempo en hacer lo que necesita. Ingrese un punto y coma para completar la sentencia, y mysql la ejecutará:

mysql> SELECT USER()
    -> ;
+--------------------+
| USER()             |
+--------------------+
| joesmith@localhost |
+--------------------+

Los prompts '> y "> aparecen durante el ingreso de cadenas. Puede escribir cadenas delimitadas por ''' o '"' (por ejemplo, 'hola' o "adios"), y mysql le permite ingresar cadenas divididas en múltiples líneas. Cuando ve un prompt '> o "> significa que ha comenzado a ingresar una cadena comenzando con ''' o '"' pero no ha ingresado 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 ingresa esta sentencia SELECT, presiona ENTER y espera por el resultado, nada ocurrirá. En lugar de asombrarse por el tiempo que consume la consulta, note lo que el prompt '> le está diciendo. Indica que mysql espera por el final de una cadena inconclusa. (¿Ve el error en la sentencia? 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 puede simplemente tipear \c en este caso, ¡porque mysql interpretará que es parte de la cadena que está ingresando!. En lugar de eso, tipee el caracter de cierre que falta y entonces ingrese \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.