Uso Del Cliente Mysql

5/8/2018 Uso Del Cliente Mysql - slidepdf.com

http://slidepdf.com/reader/full/uso-del-cliente-mysql 1/36

Proyecto Agenda Administración de base de datos

Sexto cuatrimestre en ciencias computacionales proporciona el planteamiento y el prototipo de

una agenda empresarial como el fin de implementar lo aprendido en el salón de clase.



ADMINISTRACIÓN DE BASE DE DATOSCENTRO UNIVERSITARIO FELIPE CARRILLO PUERTO

CATEDRÁTICO: Miguel SuasteProyecto:Agenda Digital.

Planteamiento del Problema

La manera actual en la cual nuestra empresa mantiene actualizado los datos de contacto de los

proveedores, clientes y/o amigos, es poco eficiente y rudimentaria, ya que se guardan en agendasconvencionales a las cuales solo tienen acceso personal especifico en lugares establecidos.

Se plantea la necesidad de encontrar de manera rápida y eficiente cualquier información de contacto

especifico y que los datos de la agenda sean útiles y fidedignos para otros fines diferentes a una

agenda comercial y estos datos sean accesibles desde cualquier sitio, a personal autorizado y

debidamente acreditado.

Propuesta de solución del problema

Se propone la implementación de una agenda electrónica , la cual almacenara la información de loscontactos en una base de datos, que sea accesible para consulta, así como para la implementación en

otras aplicaciones.

*Terminar de chorear

Motores de Base de Datos.

MS SQL SERVER

ORACLE

SYBASE

MYSQL

POSTGRESS

MS ACCESS

YB

M

DB2

Plataformas

BSD

FREEBSD

HP-UX





GNU-LINUX

MAC OSX

SOLARIS

SU N OS

WINDOWS

Aplicaciones

JAVA

PERL

PHP

C/C++

VISUALBASIC

VISUAL STUDIO

DELPHI

O pcion 1.

MYSQL

MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario con más de

seis millones de instalaciones.1 MySQL AB ²desde enero de 2008 una subsidiaria de Sun

Microsystems y ésta a su vez de Oracle Corporation desde abril de 2009² desarrolla MySQL

como software libre en un esquema de licenciamiento dual.

Por un lado se ofrece bajo la GNUGPL para cualquier uso compatible con esta licencia, pero para

aquellas empresas que quieran incorporarlo en productos privativos deben comprar a la empresauna licencia específica que les permita este uso. Está desarrollado en su mayor parte en ANSI C.

Al contrario de proyectos como Apache, donde el software es desarrollado por una comunidad

pública y los derechos de autor del código están en poder del autor individual, MySQL es

patrocinado por una empresa privada, que posee el copyright de la mayor parte del código.





Esto es lo que posibilita el esquema de licenciamiento anteriormente mencionado. Además de la

venta de licencias privativas, la compañía ofrece soporte y servicios. Para sus operaciones contratan

trabajadores alrededor del mundo que colaboran vía Internet.

O pción 2.

Access

Microsoft Access es un programa, utilizado en los sistemas operativos MicrosoftWindows, para la

gestión de bases de datos creado y modificado por Microsoft y orientado a ser usado en entornos

personal o en pequeñas organizaciones. Es un componente de la suite Microsoft Office. Permite

crear ficheros de bases de datos relacionales que pueden ser fácilmente gestionadas por una interfaz

gráfica sencilla. Además, estas bases de datos pueden ser consultadas por otros programas. Dentro

de un sistema de información, entraría dentro de la categoría de gestión, y no en la de ofimática,como podría pensarse. Este programa permite manipular los datos en forma de tablas (formadas por

filas y columnas), crear relaciones entre tablas, consultas, formularios para introducir datos e

informes para presentar la información

Tabla Comparativa.

Motor de Base de Datos a utilizar

MYSQL





Justificación

-MySQL es gratuito

-Es un gestor de BD, MySQL es cliente/servidor, o sea, tienes tu BD en un servidor potente y solo

tienes aplicaciones clientes en las estaciones de trabajo. Esto te da la ventaja de que la única

maquina potente que necesitas es el servidor, además de que puedes usar storedprocedures que al

correr en el servidor se ejecutan mucho más rápido.

-Familiaridad con el motor de base de datos Mysql.

-Es un motor multiplataforma.

-Existe una gran cantidad de información disponible.

-Escaso conocimiento del motor de base de datos postgreSQL.

-Mayor velocidad de MYSQL sobre PostgreSQL.

-MySQL es un motor de base de datos con mayor tiempo en el mercado en comparación con

PostgreSQL lo que genera más confianza en el motor.

-A pesar que MySQL tiene una integridad de datos menor a la de PostgreSQL para la envergadura

del proyecto no tiene mayor influencia.

USO DEL CLIENTE MYSQL

(Información utilizada para comprender, entender y aprender funciones

del motor de la base de datos)

El cliente mysql, crear y usar una sencilla base de datos. mysql (algunas veces referido como"monitor mysql") es un programa interactivo que permite conectarnos a un servidor MySQL,ejecutar algunas consultas, y ver los resultados. mysql puede ser usado también en modo batch: es

decir, se pueden colocar toda una serie de consultas en un archivo, y posteriormente decirle





a mysql que ejecute dichas consultas.

Asumimos que mysql está instalado en alguna máquina y que disponemos de un servidor MySQL

al cuál podemos conectarnos. Si este no es el caso, tenemos que contactar con nuestro administrador MySQL. (Si nosotros somos los administradores, es necesario consultar la documentación de

MySQL que se refiere a la instalación y configuración del servidor MySQL).

Para ver la lista de opciones proporcionadas por mysql , lo invocamos con la opción --help:

shell>mysql --help

A continuación se describe el proceso completo de creación y uso de una base de datos en MySQL.Si se está interesado sólo en el acceso y uso de una base de datos existente, se pueden omitir lassecciones que describen como crear la base de datos y las tablas correspondientes.

Puesto que es imposible que se describan a detalle muchos de los tópicos cubiertos en esteDocumento, se recomienda que se consulte el manual deMySQL para obtener más información al

respecto.

Conectándose y desconectándose al servidor MySQL

Para conectarse al servidor, usualmente necesitamos de un nombre de usuario (login) y de unacontraseña (password), y si el servidor al que nos deseamos conectar está en una máquina diferentede la nuestra, también necesitamos indicar el nombre o la dirección IP de dicho servidor. Una vez

que conocemos estos tres valores, podemos conectarnos de la siguiente manera:

shell>mysql -h NombreDelServidor -u NombreDeUsuario -p

Cuando ejecutamos este comando, se nos pedirá que proporcionemos también la contraseña para elnombre de usuario que estamos usando.

Si la conexión al servidor MySQL se pudo establecer de manera satisfactoria, recibiremos el

mensaje de bienvenida y estaremos en el prompt de mysql :

shell>mysql -h casita -u blueman - p Enter password: ******Welcome to theMySQL monitor.

Commands end with ; or \g. Your MySQL connection id is 5563 to server version: 3.23.41 Type'help;' or '\h' for help. Type '\c' toclearthe buffer. mysql>

Este prompt nos indica que mysql está listo para recibir comandos.

Algunas instalaciones permiten que los usuarios se conecten de manera anónima al servidor corriendo en la máquina local. Si es el caso de nuestra máquina, debemos de ser capaces de

conectarnos al servidor invocando a mysql sin ninguna opción:

shell>mysql





Después de que nos hemos conectado de manera satisfactoria, podemos desconectarnos encualquier momento al escribir "quit", "exit", o presionar CO NTR OL+D.

La mayoría de los ejemplos siguientes asume que estamos conectados al servidor, lo cual se indicacon el prompt de mysql .

EJECUTANDO ALGUNAS CONSULTAS

En este momento debimos de haber podido conectarnos ya al servidor MySQL, aún cuando nohemos seleccionado alguna base de datos para trabajar. Lo que haremos a continuación es escribir

algunos comandos para irnos familiarizando con el funcionamiento de mysql

mysql> SELECT VERSIO N(), CURRENT_DATE; +-----------+--------------+ | VERSIO N() |

CURRENT_DATE | +-----------+--------------+ | 3.23.41 | 2002-10-01 | +-----------+--------------+ 1row in set (0.03 sec) mysql>

Este comando ilustra distintas cosas acerca de mysql :

y Un comando normalmente consiste de un sentencia SQL seguida por un punto y coma.

y Cuando emitimos un comando, mysql lo manda al servidor para que lo ejecute, nos muestra

los resultados y regresa el prompt indicando que está listo para recibir más consultas.

y mysql muestra los resultados de la consulta como una tabla (filas y columnas). La primera

fila contiene etiquetas para las columnas. Las filas siguientes muestran los resultados de la

consulta. Normalmente las etiquetas de las columnas son los nombres de los campos de lastablas que estamos usando en alguna consulta. Si lo que estamos recuperando es el valor deuna expresión (como en el ejemplo anterior) las etiquetas en las columnas son la expresión

en sí.

y mysql muestra cuántas filas fueron regresadas y cuanto tiempo tardó en ejecutarse laconsulta, lo cual puede darnos una idea de la eficiencia del servidor, aunque estos valores

pueden ser un tanto imprecisos ya que no se muestra la hora del CPU, y porque pueden

verse afectados por otros factores, tales como la carga del servidor y la velocidad decomunicación en una red.

y Las palabras clave pueden ser escritas usando mayúsculas y minúsculas.

Las siguientes consultas son equivalentes: mysql> SELECT VERSIO N(), CURRENT_DATE; mysql> select version(), current_date;

mysql>SeLeCtvErSiOn(), current_DATE;

Aquí está otra consulta que demuestra como se pueden escribir algunas expresiones matemáticas y

trigonométricas:

mysql>SELECT SIN(PI()/4), (4+1)*5; +-------------+---------+ | SIN(PI()/4) | (4+1)*5 | +-------------+---------+ | 0.707107 | 25 | +-------------+---------+





Aunque hasta este momento se han escrito sentencias sencillas de una sóla línea, es posible escribir más de una sentencia por línea, siempre y cuando estén separadas por punto y coma:

mysql> SELECT VERSIO N(); SELECT NOW(); +-----------+ | VERSIO N() | +-----------+ | 3.23.41

| +-----------

+ 1 row in set (0.01 sec) +---------------------

+ | NOW

() | +---------------------

+ | 2002-10-

28 14:26:04 | +---------------------+ 1 row in set (0.01 sec)

EL PROMPT DE MYSQL

Un comando no necesita ser escrito en una sóla línea, así que los comandos que requieran de variaslíneas no son un problema. mysql determinará en dónde finaliza la sentencia cuando encuentre el

punto y coma, no cuando encuentre el fin de línea.

Aquí está un ejemplo que muestra un consulta simple escrita en varias líneas:

mysql> SELECT -> USER(), ->CURRENT_DATE; +-------------------+--------------+ | USER() |CURRENT_DATE | +-------------------+--------------+ | blueman@localhost | 2002-09-14 | +----------

---------+--------------+ 1 row in set (0.00 sec) mysql>

En este ejemplo debe notarse como cambia el prompt (de mysql> a ->) cuando se escribe unaconsulta en varias líneas. Esta es la manera en cómo mysql indica que está esperando a que finalicela consulta. Sin embargo si deseamos no terminar de escribir la consulta, podemos hacerlo al

escribir c como se muestra en el siguiente ejemplo:

mysql> SELECT -> USER(), -> c mysql>De nuevo, se nos regresa el comando el promptmysql> que nos indica que mysql está listo para una

nueva consulta.

En la siguiente tabla se muestran cada uno de los prompts que podemos obtener y una breve

descripción de su significado para mysql :

Los comandos multi-línea comúnmente ocurren por accidente cuando tecleamos ENTER, peroolvidamos escribir el punto y coma. En este caso mysql se queda esperando para que finalicemos la

consulta:

Prompt Significado

mysql> Listo para una nueva consulta.

-> Esperando la línea siguiente de una consulta multi-línea.

'>Esperando la siguiente línea para completar una cadena que comienza con una

comilla sencilla ( ' ).

">Esperando la siguiente línea para completar una cadena que comienza con unacomilla doble ( " ).





mysql>SELECTUSER() ->Si esto llega a suceder, muy probablemente mysql estará esperando por un punto y coma, de manera

que si escribimos el punto y coma podremos completar la consulta ymysql podrá ejecutarla:

mysql> SELECTU

SER()-> ; +

----------------+ |U

SER() | +----------------

+ | root@localhost | +------

----------+ 1 row in set (0.00 sec) mysql>

Los prompts '> y "> ocurren durante la escritura de cadenas. En mysql podemos escribir cadenasutilizando comillas sencillas o comillas dobles (por ejemplo, 'hola' y "hola"), y mysql nos permite

escribir cadenas que ocupen múltiples líneas. De manera que cuando veamos el prompt '> o ">, mysql nos indica que hemos empezado a escribir una cadena, pero no la hemos finalizado con lacomilla correspondiente.

Aunque esto puede suceder si estamos escribiendo una cadena muy grande, es más frecuente que

obtengamos alguno de estos prompts si inadvertidamente escribimos alguna de estas comillas.

Por ejemplo:

mysql>SELECT * FR OMmi_tablaWHERE nombre = "Lupita AND edad < 30; ">

Si escribimos esta consulta SELECT y entonces presionamos ENTER para ver el resultado, nosucederá nada. En lugar de preocuparnos porque la consulta ha tomado mucho tiempo, debemos

notar la pista que nos da mysql cambiando el prompt. Esto nos indica que mysql está esperando quefinalicemos la cadena iniciada ("Lupita).

En este caso, ¿qué es lo que debemos hacer? . La cosa más simple es cancelar la consulta. Sin

embargo, no basta con escribir c, ya que mysql interpreta esto como parte de la cadena que estamos

escribiendo. En lugar de esto, debemos escribir antes la comilla correspondiente y después c :

mysql> SELECT * FR OM mi_tabla WHERE nombre = "Lupita AND edad< 30; "> " c mysql>

El prompt cambiará de nuevo al ya conocido mysql>, indicándonos que mysql está listo para una

nueva consulta.

Es sumamente importante conocer lo que significan los prompts '> y ">, ya que si en algún

momento nos aparece alguno de ellos, todas la líneas que escribamos a continuación serán

consideradas como parte de la cadena, inclusive cuando escribimos QUIT. Esto puede ser confuso,

especialmente si no sabemos que es necesario escribir la comilla correspondiente para finalizar la

cadena, para que podamos escribir después algún otro comando, o terminar la.

CALCULOS CON FECHAS

MySQL proporciona diversas funciones que se pueden usar para efectuar cálculos sobre fechas, por ejemplo, para calcular edades o extraer partes de una fecha (día, mes, año, etc).

Para determinar la edad de cada una de nuestras mascotas, tenemos que calcular la diferencia de

años de la fecha actual y la fecha de nacimiento, y entonces substraer uno si la fecha actual ocurre





antes en el calendario que la fecha de nacimiento. Las siguientes consultas muestran la fecha actual,

la fecha de nacimiento y la edad para cada mascota.

mysql>SELECT nombre, nacimiento, CU

RRENT_DATE,-> (YEAR(C

URRENT_DATE)

- YEAR(nacimiento)) -> - (RIGHT(CURRENT_DATE,5) <RIGHT(nacimiento,5)) AS edad FR OM

mascotas; +--------+------------+--------------+------+ | nombre | nacimiento | CURRENT_DATE |

edad | +--------+------------+--------------+------+ | Fluffy | 1999-02-04 | 2002-12-23 | 3 | | Mau | 1998-03-17 | 2002-12-23 | 4 | | Buffy | 1999-05-13 | 2002-12-23 | 3 | | FanFan | 2000-08-27 | 2002-12-23 |

2 | | Kaiser | 1989-08-31 | 2002-12-23 | 13 | | Chispa | 1998-09-11 | 2002-12-23 | 4 | | Wicho | 2000-02-09 | 2002-12-23 | 2 | | Skim | 2001-04-29 | 2002-12-23 | 1 | | Pelusa | 2000-03-30 | 2002-12-23 | 2| +--------+------------+--------------+------+ 9 rows in set (0.01 sec)

Aquí, YEAR( ) obtiene únicamente el año y RIGHT( ) obtiene los cinco caracteres más a la derechade cada una de las fechas, que representan el mes y el día (MM-DD). La parte de la expresión quecompara los valores MM-DD se evalúa a 1 o 0, y permite ajustar el valor de la edad en el caso de

que el valor MM-DD de la fecha actual ocurra antes del valor MM-DD de la fecha de nacimiento.

Dado que la expresión en sí es bastante fea, se ha usado un alias (edad) que es el que aparece como

etiqueta en la columna que muestra el resultado de la consulta.

Esta consulta debe trabajar bien, pero el resultado puede ser de alguna manera más útil si las filasson presentadas en algún orden. Para ello haremos uso de la cláusula ORDERBY.

Por ejemplo, para ordenar por nombre, usaremos la siguiente consulta:

mysql>SELECT nombre, nacimiento, CURRENT_DATE, -> (YEAR(CURRENT_DATE) - YEAR(nacimiento)) -> - (RIGHT(CURRENT_DATE,5) <RIGHT(nacimiento,5)) -> AS edad

FR OM mascotas ORDERBY nombre; +--------+------------+--------------+------+ | nombre |nacimiento | CURRENT_DATE | edad | +--------+------------+--------------+------+ | Buffy | 1999-05-13 | 2002-12-23 | 3 | | Chispa | 1998-09-11 | 2002-12-23 | 4 | | FanFan | 2000-08-27 | 2002-12-23 | 2 || Fluffy | 1999-02-04 | 2002-12-23 | 3 | | Kaiser | 1989-08-31 | 2002-12-23 | 13 | | Mau | 1998-03-17 |

2002-12-23 | 4 | | Pelusa | 2000-03-30 | 2002-12-23 | 2 | | Skim | 2001-04-29 | 2002-12-23 | 1 | |

Wicho | 2000-02-09 | 2002-12-23 | 2 | +--------+------------+--------------+------+ 9 rows in set (0.00sec)

Para ordenar por edad en lugar de nombre, únicamente tenemos que usar una cláusula ORDERBY

diferente: mysql>SELECT nombre, nacimiento, CURRENT_DATE, -> (YEAR(CURRENT_DATE) -

YEAR(nacimiento)) -> - (RIGHT(CURRENT_DATE,5) <RIGHT(nacimiento,5)) -> AS edad

FR OM mascotas ORDERBY edad; +--------+------------+--------------+------+ | nombre | nacimiento |

CURRENT_DATE | edad | +--------+------------+--------------+------+ | Skim | 2001-04-29 | 2002-12-23 | 1 | | FanFan | 2000-08-27 | 2002-12-23 | 2 | | Wicho | 2000-02-09 | 2002-12-23 | 2 | | Pelusa |

2000-03-30 | 2002-12-23 | 2 | | Fluffy | 1999-02-04 | 2002-12-23 | 3 | | Buffy | 1999-05-13 | 2002-12-23 | 3 | | Mau | 1998-03-17 | 2002-12-23 | 4 | | Chispa | 1998-09-11 | 2002-12-23 | 4 | | Kaiser | 1989-08-31 | 2002-12-23 | 13 | +--------+------------+--------------+------+ 9 rows in set (0.01 sec)

consulta que deseamos ejecutar.





Coincidencia de patrones

MySQL posee capacidades estándar para utilizar patrones así como también una forma de patrones

basada en expresiones regulares extendidas similares a las que se encuentran en utilidades de

U NIX, como ser vi, grep, ysed.

Los patrones SQL permiten emplear el caracter ' _ ' para representar coincidencia con un carácter

individual y '%' EnMySQL, por defecto, los patrones SQL no son case-sensitive. Abajo se

muestran algunos ejemplos. Advierta que no se emplean los operadores = o <> para trabajar con

patrones SQL, en lugar de eso se usan los operadores de comparación LIKE o NOTLIKE.

Para encontrar nombres que comiencen con 'b':

mysql> SELECT * FROM pet WHERE name LIKE 'b%';

+--------+--------+---------+------+------------+------------+

| name | owner | species | sex | birth | death |

+--------+--------+---------+------+------------+------------+

| Buffy | Harold | dog | f | 1989-05-13 | NULL |

| Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 |

+--------+--------+---------+------+------------+------------+

Para encontrar nombres que terminen con 'fy':

mysql> SELECT * FROM pet WHERE name LIKE '%fy';

+--------+--------+---------+------+------------+-------+


+--------+--------+---------+------+------------+-------+

| Fluffy | Harold | cat | f | 1993-02-04 | NULL |


+--------+--------+---------+------+------------+-------+

Para encontrar nombres que contengan 'w':

mysql> SELECT * FROM pet WHERE name LIKE '%w%';

+----------+-------+---------+------+------------+------------+


+----------+-------+---------+------+------------+------------+

| Claws | Gwen | cat | m | 1994-03-17 | NULL |


| Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |

+----------+-------+---------+------+------------+------------+

Para encontrar nombres que contengan exactamente 5 caracteres, use 5 veces el caracter patrón ' _ ':

mysql> SELECT * FROM pet WHERE name LIKE '_____';

+-------+--------+---------+------+------------+-------+


+-------+--------+---------+------+------------+-------+







+-------+--------+---------+------+------------+-------+

Los otros patrones que pueden emplearse con MySQL usan expresiones regulares extendidas.

Cuando busque coincidencias con este tipo de patrones, use los

operadores REGEXP y NOTREGEXP (o bien los sinónimos RLIKE yNOTRLIKE).

Algunas características de las expresiones regulares extendidas:

y '.' detecta coincidencia con cualquier carácter individual.

y Una clase de carácter '[...]' detecta coincidencia con cualquier caracter entre los corchetes. Por

ejemplo, '[abc]' coincidirá con 'a', 'b', o 'c'. Para hacer referencia a un rango de caracteres, use un

guión. '[a-z]' detecta coincidencia con cualquier letra, mientras que '

[0-9]' lo hace con cualquier

dígito.

y '*' detecta coincidencia con cero o más apariciones de los caracteres que lo preceden. Por

ejemplo, 'x*' detecta cualquier número de caracteres 'x', '[0-9]*' detecta cualquier cantidad de

dígitos, y '.*' coincidirá con cualquier número de cualquier carácter.

y REGEXP tendrá éxito si el patrón suministrado encuentra coincidencia en cualquier parte del

valor examinado (esto difiere de LIKE en que este último solo tiene éxito si el patrón concuerda

con todo el valor).

y Para lograr que un patrón detecte coincidencias solamente al principio o al final del valor

examinado, utilice '^' al principio o '$' al final del patrón.

Para demostrar el funcionamiento de las expresiones regulares extendidas, las consultas

con LIKE expuestas anteriormente se han reescrito utilizando REGEXP.

Para hallar nombres que comiencen con 'b', use '^' para buscar coincidencia al principio del valor:

mysql> SELECT * FROM pet WHERE name REGEXP '^b';

+--------+--------+---------+------+------------+------------+


+--------+--------+---------+------+------------+------------+



+--------+--------+---------+------+------------+------------+

EnMySQL 5.0, si realmente quiere forzar a que la comparación realizada por REGEXP sea case

sensitive, utilice la palabra clave BINARY para convertir a una de las cadenas en una cadena

binaria. Esta consulta solamente encontrará coincidencia con 'b' minúsculas al comienzo de un

nombre:





mysql> SELECT * FROM pet WHERE name REGEXP BINARY '^b';

Para hallar nombres finalizados en 'fy', emplee '$' para buscar la coincidencia en el final del

nombre:mysql> SELECT * FROM pet WHERE name REGEXP 'fy$';

+--------+--------+---------+------+------------+-------+


+--------+--------+---------+------+------------+-------+

| Fluffy | Harold | cat | f | 1993-02-04 | NULL |


+--------+--------+---------+------+------------+-------+

Para encontrar nombres conteniendo una 'w', utilice esta consulta:

mysql> SELECT * FROM pet WHERE name REGEXP 'w';

+----------+-------+---------+------+------------+------------+| name | owner | species | sex | birth | death |

+----------+-------+---------+------+------------+------------+



| Whistler | Gwen | bird | NULL | 1997-12-09 | NULL |

+----------+-------+---------+------+------------+------------+

Debido a que un patrón de expresión regular encuentra coincidencia sin importar el lugar del valor

donde se produce, en la consulta previa no es necesario colocar un comodín a cada lado del patrón

para obtener coincidencia en cualquier parte del valor, como hubiera sucedido de utilizar un patrón

SQL

Para hallar nombres conteniendo exactamente cinco caracteres, use '^' y '$' para obligar a que la

coincidencia deba estar al principio y al final del nombre, y cinco instancias de '.' entre ellas.

mysql> SELECT * FROM pet WHERE name REGEXP '^.....$';

+-------+--------+---------+------+------------+-------+


+-------+--------+---------+------+------------+-------+



+-------+--------+---------+------+------------+-------+

La consulta anterior también se podría haber escrito empleando el operador '{n}' ³repetir -n-veces´:

mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$';

+-------+--------+---------+------+------------+-------+


+-------+--------+---------+------+------------+-------+






En alguna ocasión, como ahora que estamos practicando, nos puede interesar borrar toda la base de

datos. La orden para conseguirlo es:

dropdatabase ejemplo2;

Si esta orden es parte de una secuencia larga de órdenes, que hemos cargado con la orden "source"

(por ejemplo) y la base de datos no existe, obtendríamos un mensaje de error y se interrumpiría el proceso. Podemos evitarlo añadiendo "ifexists", para que se borre la base de datos sólo si realmente

existe:

dropdatabase ejemplo2 ifexists;

Borrar una tabla

Es más frecuente que creemos alguna tabla de forma incorrecta. La solución razonable es corregir ese error, cambiando la estructura de la tabla, pero todavía no sabemos hacerlo. Al menos veremos

cómo borrar una tabla. La orden es:

droptable personas;

Al igual que para las bases de datos, podemos hacer que la tabla se borre sólo cuando realmente

existe:

drop table personas if exists;

Borrar datos de una tabla

También podemos borrar los datos que cumplen una cierta condición. La orden es "deletefrom", y

con "where" indicamos las condiciones que se deben cumplir, de forma similar a como hacíamos en

la orden "select":

delete from personas where nombre = 'juan';

Esto borraría todas las personas llamadas "juan" que estén almacenadas en la tabla "personas".

Cuidado: si no se indica la parte de "where", no se borrarían los datos que cumplen una condición,

sino TODOS los datos. Si es eso lo que se pretende, una forma más rápida de conseguirlo es usar:

truncatetable personas;





Modificación de datos

Ya sabemos borrar datos, pero existe una operación más frecuente que esa (aunque tambiénligeramente más complicada): modificar los datos existentes. Con lo que sabíamos hasta ahora,

podíamos hacer algo parecido: si un dato es incorrecto, podríamos borrarlo y volver a introducirlo, pero esto, obviamente, no es lo más razonable... debería existir alguna orden para cambiar los datos.

Así es. El formato habitual para modificar datos de una tabla es "update tabla set

campo=nuevoValorwherecondicion".

Por ejemplo, si hemos escrito "Alberto" en minúsculas ("alberto"), lo podríamos corregir con:

update personas set nombre = 'Alberto' where nombre = 'alberto';

Y si queremos corregir todas las edades para sumarles un año se haría con

update personas set edad = edad+1;

(al igual que habíamos visto para "select" y para "delete", si no indicamos la parte del "where", los

cambios se aplicarán a todos los registros de la tabla).

Modificar la estructura de una tabla

Algo más complicado es modificar la estructura de una tabla: añadir campos, eliminarlos, cambiar su nombre o el tipo de datos. En general, para todo ello se usará la orden "alter table". Vamos a ver

las posibilidades más habituales.

Para añadir un campo usaríamos "add":

altertable ciudades add habitantes decimal(7);

Si no se indica otra cosa, el nuevo campo se añade al final de la tabla. Si queremos que sea el

primer campo, lo indicaríamos añadiendo "first" al final de la orden. También podemos hacer que se

añada después de un cierto campo, con "afternombreCampo".

Podemos modificar el tipo de datos de un campo con "modify". Por ejemplo, podríamos hacer queel campo "habitantes" no fuera un "decimal" sino un entero largo ("bigint") con:

altertable ciudades modify habitantes bigint;





Si queremos cambiar el nombre de un campo, debemos usar "change" (se debe indicar el nombreantiguo, el nombre nuevo y el tipo de datos). Por ejemplo, podríamos cambiar el nombre

"habitantes" por "numhabitantes":

altertable ciudades change habitantes numhabitantesbigint;

Si queremos borrar algún campo, usaremos "dropcolumn":

altertable ciudades dropcolumnnumhabitantes;

Muchas de estas órdenes se pueden encadenar, separadas por comas. Por ejemplo, podríamos borrar

dos campos con "alter table ciudades dropcolumnnum habitantes, dropcolumn provincia;"

Finalmente, también podríamos cambiar el nombre de una tabla con "rename":

altertable ciudades rename ciudad;

Operaciones matemáticas

Desde SQL podemos realizar operaciones a partir de los datos antes de mostrarlos. Por ejemplo,

podemos mostrar cual era la edad de una persona hace un año, con

select edad-1 from personas;

Los operadores matemáticos que podemos emplear son los habituales en cualquier lenguaje de

programación, ligeramente ampliados: + (suma), - (resta y negación), * (multiplicación), / (división). La división calcula el resultado con decimales; si queremos trabajar con números enteros, también

tenemos los operadores DIV (división entera) y MOD (resto de la división):

select 5/2, 5 div 2, 5 mod 2;

Daría como resultado

+--------+---------+---------+

| 5/2 | 5 div 2 | 5 mod 2 |

+--------+---------+---------+

| 2.5000 | 2 | 1 |

+--------+---------+---------+





También podríamos utilizar incluso operaciones a nivel de bits, como las del lenguaje C:

select 25 >> 1, 25 > 1 | 25 24;

que mostraría

+----------+------+

| count(*) | edad |

+----------+------+

| 1 | 25 |

+----------+------+

¿Qué es una subconsulta?

A veces tenemos que realizar operaciones más complejas con los datos, operaciones en las que nos

interesaría ayudarnos de una primera consulta auxiliar que extrajera la información en la que nos

queremos basar. Esta consulta auxiliar recibe el nombre de "subconsulta" o "subquery".

Por ejemplo, si queremos saber qué clientes tenemos en la ciudad que más habitantes tenga, laforma "razonable" de conseguirlo sería saber en primer lugar cual es la ciudad que más habitantes

tenga, y entonces lanzar una segunda consulta para ver qué clientes hay en esa ciudad.

Como la estructura de nuestra base de datos de ejemplo es muy sencilla, no podemos hacer grandes

cosas, pero un caso parecido al anterior (aunque claramente más inútil) podría ser saber qué personas tenemos almacenadas que vivan en la última ciudad de nuestra lista.

Para ello, la primera consulta (la "subconsulta") sería saber cual es la última ciudad de nuestra lista.

Si lo hacemos tomando la que tenga el último código, la consulta podría ser

SELECTMAX(codigo) FR OM ciudades;

Vamos a imaginar que pudiéramos hacerlo en dos pasos. Si llamamos "maxCodigo" a ese código

obtenido, la "segunda" consulta podría ser:





SELECT * FR OM personas WHERE codciudad= maxCodigo;

Pero estos dos pasos se pueden dar en uno: al final de la "segunda" consulta (la "grande") incluimos

la primera consulta (la "subconsulta"), entre paréntesis, así

SELECT * FR OM personas WHERE codciudad= (

SELECTMAX(codigo) FR OM ciudades

);

Subconsultas que devuelven conjuntos de datos

Si la subconsulta no devuelve un único dato, sino un conjunto de datos, la forma de trabajar será básicamente la misma, pero para comprobar si el valor coincide con uno de la lista, no usaremos el

símbolo "=", sino la palabra "in".

Por ejemplo, vamos a hacer una consulta que nos muestre las personas que viven en ciudades cuyo

nombre tiene una "a" en segundo lugar (por ejemplo, serían ciudades válidas Madrid o Barcelona,

pero no Alicante).

Para consultar qué letras hay en ciertas posiciones de una cadena, podemos usar SUBSTRING (enel próximo apartado veremos las funciones más importantes de manipulación de cadenas). Así, una

forma de saber qué ciudades tienen una letra A en su segunda posición sería:

SELECT codigo FR OM ciudades

WHERE SUBSTRING(nombre,2,1)='a';

Como esta subconsulta puede tener más de un resultado, deberemos usar IN para incluirla en la

consulta principal, que quedaría de esta forma:

SELECT * FR OM personas

WHERE codciudad IN

(





SELECT codigo FR OM ciudadesWHERE SUBSTRING(nombre,2,1)='a'

);

Funciones de cadena

EnMySQL tenemos muchas funciones para manipular cadenas: calcular su longitud, extraer un

fragmento situado a la derecha, a la izquierda o en cualquier posición, eliminar espacios finales o

iniciales, convertir a hexadecimal y a binario, etc. Vamos a comentar las más habituales. Losejemplos estarán aplicados directamente sobre cadenas, pero (por supuesto) también se pueden

aplicar a campos de una tabla:

Funciones de conversión a mayúsculas/minúsculas

� LOWER o LCASE convierte una cadena a minúsculas: SELECTLOWER('Hola'); -> hola

� UPPER oUCASE convierte una cadena a mayúsculas: SELECTUPPER('Hola'); -> HOLA

Funciones de extracción de parte de la cadena

� LEFT(cadena, longitud) extrae varios caracteres del comienzo (la parte izquierda) de la

cadena: SELECTLEFT('Hola',2); -> Ho

� RIGHT(cadena, longitud) extrae varios caracteres del final (la parte derecha) de la cadena:

SELECTRIGHT('Hola',2); -> la

� MID(cadena, posición, longitud), SUBSTR(cadena, posición, longitud) oSUBSTRING(cadena, posición, longitud) extrae varios caracteres de cualquier posición de una

cadena, tantos como se indique en "longitud": SELECTSUBSTRING('Hola',2,2); ->ol (Nota: a

partir MySQL 5 se permite un valor negativo en la posición, y entonces se comienza a contar desdela derecha -el final de la cadena-)

� CO NCAT une (concatena) varias cadenas para formar una nueva: SELECTCO NCAT('Ho',

'la'); -> Hola

� CO NCAT_ WS une (concatena) varias cadenas para formar una nueva, usando un separador

que se indique (WithSeparator): SELECTCO NCAT_ WS('-','Ho','la','Que','tal'); -> Ho-la-Que-tal

� LTRIM devuelve la cadena sin los espacios en blanco que pudiera contener al principio (en su

parte izquierda): SELECTLTRIM(' Hola'); -> Hola

� RTRIM devuelve la cadena sin los espacios en blanco que pudiera contener al final (en su

parte derecha): SELECTRTRIM('Hola '); -> Hola





� TRIM devuelve la cadena sin los espacios en blanco que pudiera contener al principio ni alfinal: SELECTTRIM(' Hola '); -> Hola (Nota: realmente, TRIM puede eliminar cualquier prefijo,

no sólo espacios; mira el manual deMySQL para más detalles)

Funciones de conversión de base numérica

� BIN convierte un número decimal a binario: SELECTBIN(10); -> 1010

� HEX convierte un número decimal a hexadecimal: SELECTHEX(10); -> 'A' (Nota: HEX

también puede recibir una cadena, y entonces mostrará el código ASCII en hexadecimal de suscaracteres: SELECTHEX('Hola'); -> '486F6C61')

� OCT convierte un número decimal a octal: SELECTOCT(10); -> 12

� CO NV(número,baseInicial,baseFinal) convierte de cualquier base a cualquier base:

SELECTCO NV('F3',16,2); -> 11110011

� U NHEX convierte una serie de números hexadecimales a una cadena ASCII, al contrario de

lo que hace HEX: SELECTU NHEX('486F6C61'); -> 'Hola')

Otras funciones de modificación de la cadena

� INSERT(cadena,posición,longitud,nuevaCadena) inserta en la cadena otra cadena:

SELECTINSERT('Hola', 2, 2, 'ADIOS'); ->HADIOSa

� REPLACE(cadena,de,a) devuelve la cadena pero cambiando ciertas secuencias de caracteres por otras: SELECTREPLACE('Hola', 'l', 'LLL'); ->HoLLLa

� REPEAT(cadena,numero) devuelve la cadena repetida varias veces: SELECTREPEAT('

Hola',3); ->HolaHolaHola

� REVERSE(cadena) devuelve la cadena "del revés": SELECT REVERSE('Hola'); ->aloH

� SPACE(longitud) devuelve una cadena formada por varios espacios en blanco:

SELECTSPACE(3); -> " "

Funciones de información sobre la cadena

� CHAR_LENGTH o CHARACTER_LENGTH devuelve la longitud de la cadena en

caracteres

� LENGTH devuelve la longitud de la cadena en bytes





� BIT_LENGTH devuelve la longitud de la cadena en bits

� INSTR(cadena,subcadena) o LOCATE(subcadena,cadena,posInicial) devuelve la posición de

una subcadena dentro de la cadena: SELECTINSTR('H

ola','ol');-> 2

(Más detalles en el apartado 12.3 del manual de referencia MySQL 5.0)

Los "join"

Sabemos enlazar varias tablas para mostrar datos que estén relacionados. Por ejemplo, podríamosmostrar nombres de deportistas, junto con los nombres de los deportes que practican. Pero todavíahay un detalle que se nos escapa: ¿cómo hacemos si queremos mostrar todos los deportes que hay

en nuestra base de datos, incluso aunque no haya deportistas que los practiquen?

Vamos a crear una base de datos sencilla para ver un ejemplo de cual es este problema y de cómo

solucionarlo.

Nuestra base de datos se llamará "ejemploJoins":

createdatabaseejemploJoins;

useejemploJoins;

En ella vamos a crear una primera tabla en la que guardaremos "capacidades" de personas (cosasque saben hacer):

createtable capacidad(

codigovarchar(4),

nombrevarchar(20),

primarykey(codigo)

);

También crearemos una segunda tabla con datos básicos de personas:

createtable persona(





codigovarchar(4),

nombrevarchar(20),

codcapacvarchar(4),

primarykey(codigo)

);

Vamos a introducir datos de ejemplo:

insert into capacidad values

('c','Progr.C'),

('pas','Progr.Pascal'),

('j','Progr.Java'),

('sql','Bases datos SQL');

insert into persona values

('ju','Juan','c'),

('ja','Javier','pas'),

('jo','Jose','perl'),

('je','Jesus','html');

Antes de seguir, comprobamos que todo está bien:

select * from capacidad;

+--------+-----------------+





| codigo | nombre |

+--------+-----------------+

| c | Progr.C |

| j | Progr.Java |

| pas | Progr.Pascal |

| sql | Bases datos SQL |

+--------+-----------------+

select * from persona;

+--------+--------+----------+

| codigo | nombre | codcapac |

+--------+--------+----------+

| ja | Javier | pas |

| je | Jesus | html |

| jo | Jose | perl |

| ju | Juan | c |

+--------+--------+----------+

Como se puede observar, hay dos capacidades en nuestra base de datos para las que no conocemos a

ninguna persona; de igual modo, existen dos personas que tienen capacidades sobre las que no

tenemos ningún detalle.

Por eso, si mostramos las personas con sus capacidades de la forma que sabemos, sólo apareceránlas parejas de persona y capacidad para las que todo está claro (existe persona y existe capacidad),

es decir:





| Javier | Bases datos SQL |

| Jesus | Bases datos SQL |

| Jose | Bases datos SQL |

| Juan | Bases datos SQL |

+--------+-----------------+

Si sólo queremos ver los datos que coinciden en ambas tablas, lo que antes conseguíamoscomparando los códigos con un "where", también podemos usar un "innerjoin" (unión interior; se

puede abreviar simplemente "join"):


from persona innerjoin capacidad

onpersona.codcapac = capacidad.codigo;

+--------+--------------+

| nombre | nombre |

+--------+--------------+

| Juan | Progr.C |


+--------+--------------+

Pero aquí llega la novedad: si queremos ver todas las personas y sus capacidades, incluso para

aquellas personas cuya capacidad no está detallada en la otra tabla, usaríamos un "leftjoin" (unión por la izquierda, también se puede escribir "leftouterjoin", unión exterior por la izquierda, para dejar

claro que se van a incluir datos que están sólo en una de las dos tablas):


from persona leftouterjoin capacidad





| NULL | Bases datos SQL |

+--------+-----------------+

Otros gestores de bases de datos permiten combinar el "rightjoin" y el "leftjoin" en una única

consulta, usando "full outerjoin", algo que no permite MySQL en su versión actual.

(Más detalles en el apartado 13.2.7.1 del manual de referencia MySQL 5.0)

Union, Vistas

En el apartado anterior comentábamos que la versión actual de MySQL no permite usar "fullouterjoin" para mostrar todos los datos que hay en dos tablas enlazadas, aunque alguno de esos

datos no tenga equivalencia en la otra tabla.

También decíamos que se podría imitar haciendo a la vez un "rightjoin" y un "leftjoin".

En general, tenemos la posibilidad de unir dos consultas en una usando "union", así:


from persona rightouterjoin capacidad

onpersona.codcapac = capacidad.codigo

union


from persona left outer join capacidad


+--------+-----------------+

| nombre | nombre |

+--------+-----------------+

| Juan | Progr.C |





| NULL | Progr.Java |


| NULL | Bases datos SQL |

| Jesus | NULL |

| Jose | NULL |

+--------+-----------------+

Nota: en algunos gestores de bases de datos, podemos no sólo crear "uniones" entre dos tablas, sino

también realizar otras operaciones habituales entre conjuntos, como calcular su intersección("intersection") o ver qué elementos hay en la primera pero no en la segunda (diferencia,

"difference"). Estas posibilidades no están disponibles en la versión actual de MySQL.

Implementación en el Navicat Premium

/*

Navicat MySQL Data Transfer

Source Server : local

Source Server Version : 50141

Source Host : localhost:3306





Source Database : cdcol

Target Server Type : MYSQL

Target Server Version : 50141

File Encoding : 65001

Date: 2011-06-16 23:44:30

*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------

-- Table structure for `contactos`

-- ----------------------------

DR OP TABLE IF EXISTS `contactos`;

CREATE TABLE `contactos` (

ìd_c` int(11) NOT NULL AUTO _INCREMENT,

`nombre1` varchar(50) COLLATE latin1_general_ci NOT NULL,


àpe_pat` varchar(50) COLLATE latin1_general_ci NOT NULL,

àpe_mat` varchar(50) COLLATE latin1_general_ci NOT NULL,

èmpresa` varchar(50) COLLATE latin1_general_ci NOT NULL,

`direccion` varchar(50) COLLATE latin1_general_ci NOT NULL,

`telefono1` decimal(10,0) NOT NULL,

`teleono2` decimal(10,0) NOT NULL,

`celular` decimal(10,0) NOT NULL,

òtro` decimal(10,0) NOT NULL,

`correo` varchar(50) COLLATE latin1_general_ci NOT NULL,





ìd_tc` int(11) NOT NULL,

`rfc` varchar(15) COLLATE latin1_general_ci NOT NULL,

`fecha_captura` date NOT NULL,

ìd_s` int(11) NOT NULL,

PRIMARY KEY (ìd_c`),

KEY ìd_tc` (ìd_tc`),

KEY ìd_s` (ìd_s`)

) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;

-- ----------------------------

-- Records of contactos

-- ----------------------------

-- ----------------------------

-- Table structure for èstatus`

-- ----------------------------

DR OP TABLE IF EXISTS èstatus`;

CREATE TABLE èstatus` (

ìd_s` int(11) NOT NULL AUTO _INCREMENT,

`descripcion` varchar(50) COLLATE latin1_general_ci NOT NULL,

PRIMARY KEY (ìd_s`)


-- ----------------------------

-- Records of estatus

-- ----------------------------





-- ----------------------------

-- Table structure for èventos`

-- ----------------------------

DR OP TABLE IF EXISTS èventos`;

CREATE TABLE èventos` (

ìd_e` int(11) NOT NULL AUTO _INCREMENT,


ìd_c` int(11) NOT NULL,

`fecha` datetime NOT NULL,

PRIMARY KEY (ìd_e`),

KEY ìd_c` (ìd_c`)


-- ----------------------------

-- Records of eventos

-- ----------------------------

-- ----------------------------

-- Table structure for `tipo_contactos`

-- ----------------------------

DR OP TABLE IF EXISTS `tipo_contactos`;

CREATE TABLE `tipo_contactos` (

ìd_tc` int(11) NOT NULL,


PRIMARY KEY (ìd_tc`)






-- ----------------------------

-- Records of tipo_contactos

-- ----------------------------

-- ----------------------------

-- Table structure for `tipo_usuario`

-- ----------------------------

DR OP TABLE IF EXISTS `tipo_usuario`;

CREATE TABLE `tipo_usuario` (

ìd_tu` int(11) NOT NULL AUTO _INCREMENT,

`descripcion` varchar(50) COLLATE latin1_general_ci DEFAULT NULL,

ìd_s` int(11) DEFAULT NULL,

PRIMARY KEY (ìd_tu`),

KEY ìd_s` (ìd_s`)


-- ----------------------------

-- Records of tipo_usuario

-- ----------------------------

-- ----------------------------

-- Table structure for ùsuarios`

-- ----------------------------

DR OP TABLE IF EXISTS ùsuarios`;

CREATE TABLE ùsuarios` (

ìd_u` int(11) NOT NULL AUTO _INCREMENT,







àpe_pat` varchar(50) COLLATE latin1_general_ci NOT NULL,

àpe_mat` varchar(50) COLLATE latin1_general_ci NOT NULL,

`correo1` varchar(50) COLLATE latin1_general_ci NOT NULL,

`correo2` varchar(50) COLLATE latin1_general_ci NOT NULL,

`telefono` decimal(10,0) NOT NULL,

`puesto` varchar(50) COLLATE latin1_general_ci NOT NULL,

`fechar_reg` date NOT NULL,

ìd_s` int(11) NOT NULL,

PRIMARY KEY (ìd_u`),

KEY ìd_s` (ìd_s`)


-- ----------------------------

-- Records of usuarios

-- ----------------------------

Uso Del Cliente Mysql

Documents

Transcript of Uso Del Cliente Mysql