Home Map Index Search News Archives Links About LF
[Top Bar]
[Bottom Bar]
[Photo of the Author]
Jose M. Fernández



Índice de Contenidos:

Introducción
Principales Características
Instalación
Primeros Pasos, Administración (Seguridad)
Lenguaje SQL en MySQL
Conclusiones

MySQL
Servidor de Bases de Datos

[Ilustration]

Resumen: Tras un análisis de las principales prestaciones de la base de datos MySQL, la base de datos más rápida de su categoría, el autor nos enseña los primeros pasos mediante el uso de sencillos ejemplos.




Introducción

MySQL es un gestor de bases de datos SQL (Structured Query Language). Es una implementación Cliente-Servidor que consta de un servidor y diferentes clientes (programas/librerías).

Hablar de una base de datos SQL es muy complicado ya que habría que remontarse a los orígenes mismos de las bases de datos relacionales y el objetivo de este artículo no es tan ambicioso, simplemente intenta describir y mostrar un implementación específica de un gestor de bases de datos SQL.

Aunque reseñar como dato histórico que IBM empezó a comercializar en 1.981 el SQL y desde entonces este producto ha tenido un papel importante en el desarrollo de la bases de datos relacionales. IBM propuso y fue aceptada , una versión de SQL al Instituto de Estándares Nacional Americano(ANSI) y desde entonces es utilizado de forma generalizada en las bases de datos relacionales. En 1.983 nació DB2 la más popular( por lo menos en los grandes ordenadores) de las bases de datos de este tipo hasta estos mismos momentos.

En el mundo GNU, una de las bases de datos que se reseña en cualquier referencia de aplicaciones de éste tipo bajo LINUX, es MySQL aunque no está incluida en ninguna distribución ya que no tiene licencia GNU como tal, para comercializarla a ella o a cualquier software que la utilice o se sirva de ésta habrá que adquirir una licencia.

Esta base de datos es considerada (en su propia documentación así lo reseña) como la más rápida y robusta tanto para volúmenes de datos grandes como pequeños (siempre, claro está, comparada con las de su categoría), aunque como veremos más adelante está rapidez es a costa de no implementar ciertos aspectos del SQL.

MySQL está disponible (Fuentes y binario) para: Linux 2.0+, SCO, Solaris 2.5, 2.6, SUNOS 4.x, BSDI 2.x, 3.0, SGI IRIX 6.x, AIX 4.x, DEC UNIX 4.x, HPUX 10.20, Windows 95 (con perdón) , entre los sistemas operativos más populares.

La versión libre fue escrita por Michael Windenis, la versión comercial es distribuida por TCX Datakonsulter AB.

Principales Características

  • El principal objetivo de MySQL es velocidad y robustez.
  • Escrito en C y C++, testado con GCC 2.7.2.1. Usa GNU autoconf para potabilidad.
  • Clientes C, C++, JAVA, Perl, TCL.
  • Multiproceso, es decir puede usar varias CPU si éstas están disponibles.
  • Puede trabajar en distintas plataformas y S.O. distintos.
  • Sistema de contraseñas y privilegios muy flexible y segura.
  • Todas la palabras de paso viajan encriptadas en la red.
  • Registros de longitud fija y variable.
  • 16 índices por tabla, cada índice puede estar compuesto de 1 a 15 columnas o partes de ellas con una longitud máxima de 127 bytes.
  • Todas las columnas pueden tener valores por defecto.
  • Utilidad (Isamchk) para chequear, optimizar y reparar tablas.
  • Todos los datos están grabados en formato ISO8859_1.
  • Los clientes usan TCP o UNIX Socket para conectarse al servidor.
  • El servidor soporta mensajes de error en distintas lenguas.
  • Todos los comandos tienen -help o -? Para las ayudas.
  • Diversos tipos de columnas como enteros de 1, 2, 3, 4, y 8 bytes, coma flotante, doble precisión, carácter, fechas, enumerados, etc.
  • ODBC para Windows 95 (con fuentes), se puede utilizar ACCESS para conectar con el servidor.

Instalación

Naturalmente, antes de la instalación de la base de datos, habrá que conseguirla y para ello podemos acceder al WEB: http://www.tcx.se, o FTP: ftp://ftp.sunet.se/pub/unix/databases/relational/mysql

Además habrá que decidir por bajarse una distribución en código fuente o binario. Ésta última es más fácil de instalar pero debe de existir la versión binaria para nuestra plataforma (aunque existe para las más populares).

Instalación Binario

Una vez descargado el fichero empaquetado tal como: mysql-Version.tar.gz. Se procederá a desempaquetarlo. Se puede hacer de varias formas, pero yo prefiero hacerlo paso a paso:

  1. Desempaquetar:
    gunzip -dfv     mysql-Version.tar.gz
  2. Después se realiza el comando tar
    tar -xvf mysql-Version.tar
    

Este comando tar en mi instalación lo hice en el directorio /usr/local con lo que en éste se creé el directorio: /usr/local/mysql-3.20.32a-pc-linux-gnu-i586

que como vemos no es muy práctico su manejo, con lo que se recomienda (en la propia guía de instalación del MySQL) que se realice un acceso directo con el comando ln (hacer Links entre ficheros)

ln -s mysql-3.20.32a-pc-linux-gnu-i586/bin mysql

con lo que el directorio tendrá el aspecto:


drwxr-xr-x  8192 Nov    24  1993 bin
drwxr-xr-x  8192 Nov    24  1993 etc
drwxr-xr-x  8192 Aug    17  1997 i18n
drwxr-xr-x  8192 Mar    16  1994 include
drwxr-xr-x  8192 Mar    19 02:03 jdk1.1.3
drwxr-xr-x  8192 Aug    17  1997 jre
drwxr-xr-x  8192 Mar    16  1994 lib
lrwxrwxrwx    36 Jan    18 19:40 mysql 
drwxr-xr-x  8192 Feb     5 00:07 mysql-3.20.32a-pc-linux-gnu-i586
drwxr-xr-x  8192 Nov    24  1993 sbin
drwxr-xr-x  8192 Nov    24  1993 src
        

y haciendo cd mysql estaremos naturalmente en el directorio bin de MySQL, con lo cual y si todo ha funcionado perfectamente estaremos en disposición de poder arrancar el servidor de la base da datos.

Instalación Fuentes

Desempaquetar el archivo de la misma forma que en el apartado anterior.

cd mysql-Version 
./configure
make install
        
Existe una gran cantidad de documentación para realizar el proceso de instalación donde podemos encontrar desde los Errores (Bugs), pasando por documentación específica para distintos sistemas operativos, parámetros para distintas configuraciones y hasta una colección de FAQ de este tema. Si el proceso de instalación se realiza sin problemas (sería la primera vez que pase) se tendrá como resultado algo similar a lo obtenido en la instalación del software en binario.

Esta opción es sólo recomendable para aquellos usuarios con bastante experiencia en esto de compilar e instalar código fuente y además disponer de bastante tiempo y paciencia para ir resolviendo cada uno de los problemas que inevitablemente surjan.

Primeros Pasos, Administración (Seguridad)

Una vez instalado en nuestro sistema el gestor de bases de datos con una de las dos formas descritas en el apartado anterior y dentro del directorio: /usr/local/mysql-3.20.32a-pc-linux-gnu-i586 tendremos los siguientes ficheros y directorios:


-rw-r--r--  1 root    root    4133  Oct    1  1997  INSTALL-BINARY
-rw-r--r--  1 root    root   16666  Oct    7 21:10  INSTALL-SOURCE
-rw-r--r--  1 root    root   24088  Oct   27 23:06  NEWS
-rw-r--r--  1 root    root    3562  Apr   11  1997  PORTING
-rw-r--r--  1 root    root    8512  May   21  1997  PUBLIC
-rw-r--r--  1 root    root    1963  Jul   31  1997  README
-rw-r--r--  1 root    root    3416  Jun    4  1997  TODO
drwxr-xr-x  6 root    root    8192  Oct   28 00:44  bench
drwxr-xr-x  2 cuenta1 users   8192  Mar   27 00:42  bin
drwxr-xr-x  5 root    root    8192  Mar   31 00:26  data
drwxr-xr-x  2 root    root    8192  Oct   28 00:44  include
drwxr-xr-x  2 root    root    8192  Oct   28 00:44  lib
-rw-r--r--  1 root    root  132883  Jun    8  1997  mysql-faq.html
-rw-r--r--  1 root    root  117622  Jun   10  1997  mysql-faq.txt
-rw-r--r--  1 root    root    9301  Jun    8  1997  mysql-faq_toc.html
drwxr-xr-x  4 root    root    8192  Oct   28 00:44  mysqlperl
drwxr-xr-x  2 root    root    8192  Oct   28 00:44  scripts
drwxr-xr-x  3 root    root    8192  Oct   28 00:44  share
drwxr-xr-x  2 root    root    8192  Oct   28 00:44  tests
        

En los ficheros README, TODO, INSTALL, mysql-faq, etc., viene información sobre la instalación del servidor de bases de datos, FAQ, manual de funcionamiento, etc. que es bastante completo y efectivo (parte de este articulo está basado en ellos).

Dentro del directorio /data encontraremos como subdirectorios de este cada una de las bases de datos que vamos creando. En el momento de la instalación se define por defecto los archivos en los que se apoya el sistema de seguridad, esta base de datos es "mysql".

El directorio /bench encontraremos ejemplos de SQL. Notar que en la instalación en código fuente los ejemplos son mayores que en la instalación en binario.

El directorio /share contiene los mensajes de error del servidor en cada uno de los idiomas que está disponible.

Los directorios /include y /lib se encuentran los ficheros *.h y las librerías necesarias.

El directorio /bin están todos los ficheros ejecutables, entre los más importantes destacaremos:

`mysql'
Una Shell de SQL (con readline de GNU). Se puede usar tanto interactivamente como no.

`mysqladmin'
Utilidades de administración. Crear/borra base de datos. Información sobre procesos y versiones.

`mysqld'
El SQL "deamon" .Debe estar siempre ejecutándose.

`mysqlshow'
Visualiza información sobre base de datos, tablas y campos.

`safe_mysqld'
Arranca "mysqld".

`mysqlaccess'
Script para chequear los privilegios de una combinación: Host, Usuario y base de datos.

`mysqlbug'
Se utiliza para enviar los posibles errores (bug) que encontremos en el gestor.

`mysql_install_db'
Crear grandes tablas con privilegios por defecto, se ejecuta cuando se instala por primera vez en un sistema nuevo.

`isamchk'
Chequea, optimiza y repara tablas.

Seguridad

El sistema de seguridad de MySQL garantiza que cada usuario pueda hacer las cosas que le están permitidas (nada más y nada menos).

El sistema decide los diferentes privilegios dependiendo de "QUÉ USUARIO" conectado a "QUÉ BASE DE DATOS" desde "QUÉ HOST". El sistema de privilegios está basado, como no, en el contenido de 3 tablas, "USER", "HOST" y "DB" de la base de datos "mysql".

Las columnas de estas 3 tablas son:

Database: mysql
Tables
db
host
user


Table: db
Field Type Null Key Default Extra
Host char(60)   PRI    
Db char(32)   PRI    
User char(16)   PRI    
Select_priv char(1)     N  
Insert_priv char(1)     N  
Update_priv char(1)     N  
Delete_priv char(1)     N  
Create_priv char(1)     N  
Drop_priv char(1)     N  

Table: host
Field Type Null Key Default Extra
Host char(60)   PRI    
Db char(32)   PRI    
Select_priv char(1)     N  
Insert_priv char(1)     N  
Update_priv char(1)     N  
Delete_priv char(1)     N  
Create_priv char(1)     N  
Drop_priv char(1)     N  

Table: user
Field Type Null Key Default Extra
Host char(60)   PRI    
User char(16)   PRI    
Password char(16)        
Select_priv char(1)     N  
Insert_priv char(1)     N  
Update_priv char(1)     N  
Delete_priv char(1)     N  
Create_priv char(1)     N  
Drop_priv char(1)     N  
Reload_priv char(1)     N  
Shutdown_priv char(1)     N  
Process_priv char(1)     N  
File_priv char(1)     N  

Se puede decidir si se autoriza o no a seleccionar (SELECT), insertar (INSERT), actualizar (UPDATE), y borrar (DELETE) filas de una tabla.

Se puede permitir, o no, crear o barrar (CREATE, DROP) tablas o bases de datos.

Se pude permitir, o no, usar comandos de administración del gestor de bases de datos como "shutdown", "reload", "process", etc.

Se puede siempre comprobar nuestros privilegios con el script "mysqlaccess".

Un HOST debe ser un "host local", un numero IP, o una expresión SQL . Si en la tabla "db" la columna host está vacía significa "cualquier host" en la tabla de "host". Si en la tabla "host" o "user" la columna host está vacía significa que cualquier HOST puede crear una conexión TCP con vuestro servidor.

Db es el nombre de una base de datos.

Una columna "USER" vacía significa cualquier nombre de usuario.

Primeros Pasos

La forma más rápida de arrancar el servidor es ejecutando:

mysql.server  start
        
y para pararla:
mysql.server stop  

Se puede realizar lo mismo ejecutando el script safe_mysql como indica en la guía de instalación, aunque al final, de una forma o de otra, se ejecuta el fichero "mysqld".

Es necesaria, como se pude suponer, arrancar el servidor para realizar cualquier operación con la base de datos, una vez realizado esto se pueden ejecutar varios comando para comprobar que el arranque del servidor ha sido correcto como, por ejemplo, "mysqladmin" cuyo formato completo será:

mysqladmin [OPCIONES] comando comando  &
        

donde OPCIONES puede ser:

-f, --force No realiza la pregunta para confirmar al borran una tabla.
-?, --help Visualiza esta ayuda .
-h, --host=# Conexión con el host.
-p, --password[=...] Palabra de paso para la conexión al servidor
-P --port=... Numero de puerto a usar en la conexión.
-S --socket=... Fichero Socket para usar en la conexión.
-u, --user=# Usuario de conexión si no es el usuario actual.
-V, --version Información sobre la versión actual .

donde Comando puede ser uno o más de:

  • create nombre_base_de_datos
    Crea una nueva base de datos
  • drop nombre_de_base_de_datos
    Borra una base de datos y todos sus tablas
  • kill identificador_de_procesos
    "mata " un proceso mysql
  • processlist
    Muestra una lista de los procesos que se ejecutan en el servidor
  • shutdown
    Para al servidor
  • status
    Obtiene un mensaje del estado del servidor
  • version
    Obtiene la versión del servidor

    así que, ejecutando:

    mysqladmin create  nuevabasededatos     
    crearemos una nueva base de datos cuyo nombre será "nuevabasededatos".

    Podremos ver los procesos que se están ejecutando en el servidor con:

    mysqladmin      processlist
            
    Otro comando importante es el mysqlshow que nos permite ver las bases de datos que existen, por ejemplo, si ejecutamos el comando tal cual:
    mysqlshow
            
    nos mostrará como resultado:
            +-----------+
            | Databases |
            +-----------+
            | mysql     |
            | personas  |
            | test      |
            +-----------+
    

    Lenguaje SQL en MySQL

    Como idicamos en la introducción, este servidor de bases de datos está considerada como las más rápida entres las de sus misma categoría tanto para volúmenes de datos grandes como pequeños, pero como también indicamos al principio es a base de no implementar ciertos aspectos de las especificación SQL éstos aspectos, que a mi entender, son importantes son por una lado los Triggers y por otro lado la Lógica Transaccional.

    Los triggers no es nada más que una porción de código almacenado que se "dispara" o se ejecuta cuando se realiza una operación ( actualización, borrado, etc.) con la base de datos. Naturalmente comprobar la propia existencia de disparador y ejecutarlo si existe consume recursos y tiempo y es como su propio manual indica, la única razón por la que los triggers no están soportados.

    Un aspecto muy importante en cualquier base de datos relacional es la consistencia de las diferentes tablas que la componen, para conseguir esto de una forma más o menos fácil es utilizando la "Lógica Transaccional" , será el propio gestor de base de datos el que proporcione mecanismos de bloqueo de ficheros y consolidación o retroceso en la operaciones con las tablas. Pues bien Mysql no soporta las transacciones en aras simplemente de la velocidad (o por lo menos así lo indican en sus comentarios) , sólo nos podemos ayudar con los comandos LOCK tables /UNLOCK tables que permiten bloquear tablas impidiendo que otros usuarios puedan acceder a ellas pero sin la posibilidad de deshacer las operaciones realizadas con los datos.

    Teniendo en cuenta estas restricciones en la utilización del servidor a continuación veremos como implementamos algunos comandos SQL, no con el objetivo de analizar los comandos, sino ver como éstos se implementan en este gestor de bases de datos

    Una vez que tenemos el servidor arrancado ya no nos queda nada más que enviarle instrucciones para realizar las operaciones que deseemos. Como ejemplo veremos la creación de una base de datos "personas" que está constituida por tres tablas "clientes" "provincias" y "municipios". Es un ejemplo muy simple y sin ninguna utilidad pero nos ayudará en un ejemplo real como podemos manipular la base de datos. En primer lugar, diremos que éstas operaciones podemos realizarlas de varias formas: una de ellas sería atreves de una API en C , C++, JAVA o por medio de una ODBC si estuviéramos trabajando en Windows95 (con perdón) o también podríamos realizarlo con la shell de la propia instalación. Ésta última forma no parece más apropiada para nuestro articulo ya que no tenemos que describir las particularidades de los distintos lenguajes de programación.

    La shell de Mysql podemos arrancarla ejecutando

    mysql   nombrebasedatos
    

    y se nos presentará el prompt de la shell, con lo cual podemos enviar comandos al servidor.

    Asimismo podemos ejecutar la shell en modo "batch" o diferido ejecutando:

    mysql -e("comando SQL .... ") nombre_base_datos
    

    con lo que conseguiremos enviar el comando SQL al servidor.

    Para nuestro ejemplo hemos creado una base de datos llamada "personas"con el comando

    mysqladmin create personas
    

    Arrancaremos la shell con el comando

    mysql  personas
    

    y ya desde la shell podemos enviar comandos al propio servidor , como por ejemplo, que nos enseñe las tablas de la bases de datos con la que hemos arrancado la shell:


    > show tables /g

    y el sistema nos responderá con:

    Database: personas
    +-------------+ | Tables | +-------------+ | clientes | | municipios | | provincias | +-------------+

    Todos los comandos que enviamos al servidor desde la shell siempre acabarán con /g que es la forma de indicar el fin de comando y el envío de este al servidor para que lo ejecute.

    Naturalmente, antes de que el sistema nos devuelva esta información, hemos tenido que crear las tablas con los correspondiente comandos CREATE , los cuales tendrán un aspecto como:

    CREATE TABLE clientes
        (NIF         CHAR(9)   NOT NULL PRIMARY KEY,
         Nombre      CHAR(15)  NOT NULL,
         Apellidos   CHAR(35)  NOT NULL,
         Direccion   CHAR(50)  NOT NULL,
         Poblacion   INT(5)    NOT NULL,
         Provincia   INT(2)    NOT NULL,
         Telefono    INT(9),
         Fecha_Alta  DATE      NOT NULL)   /g
    
    CREATE TABLE provincias
         (Cod_provincia  INT(2)   NOT NULL PRIMARY KEY,
          Descripcion_p  CHAR(30) NOT NULL) g
    
    CREATE TABLE municipios
         (Cod_provincia  INT(2)    NOT NULL,
          Cod_municipio  INT(3)    NOT NULL,
          Descripcion_m  CHAR(30)  NOT NULL,
          PRIMARY KEY(Cod_provincia,Cod_municipio)) /g
    

    Si a continuación ejecutamos:

    > show colums from clientes from personas /g
    > show columns from provincias  from personas /g
    > show columns from municipios  from personas /g
    

    obtendremos respectivamente:

    
    Database: personas      Table: clientes  Rows: 4
    +--------------+----------+------+-----+---------+-------+
    | Field        | Type     | Null | Key | Default | Extra |
    +--------------+----------+------+-----+---------+-------+
    | NIF          | char(9)  |      |PRI  |         |       |
    | Nombre       | char(15) | YES  |     |         |       |
    | Apellidos    | char(35) |      |     |         |       |
    | Direccion    | char(50) |      |     |         |       |
    | Poblacion    | int(5)   |      |     |   0     |       |
    | Provincia    | int(2)   |      |     |   0     |       |
    | Telefono     | int(9)   | YES  |     |         |       |
    | Fecha_Alta   | date     | YES  |     |         |       |
    +--------------+----------+------+-----+---------+-------+
    
    
    Database: personas      Table: provincias  Rows: 3
    +-----------------+----------+------+-----+---------+-------+
    | Field           | Type     | Null | Key| Default  | Extra |
    +-----------------+----------+------+-----+---------+-------+
    | Cod_provincia   | int(2)   |      | PRI |    0    |       |
    | Descripcion_p   | char(30) |      |     |         |       |
    +-----------------+----------+------+-----+---------+-------+
    
    
    Database: personas      Table: municipios  Rows: 9
    +------------------+----------+------+-----+---------+-------+
    | Field            | Type     | Null | Key| Default  | Extra |
    +------------------+----------+------+-----+---------+-------+
    | Cod_provincia    | int(2)   |      | PRI |   0     |       |
    | Cod_municipio    |  int(3)  |      | PRI |   0     |       |
    | Descripcion_m    | char(30) |      |     |         |       |
    +------------------+----------+------+-----+---------+-------+
    

    El siguiente paso sería introducir datos a cada una de las tablas, vamos ha utilizar el comando INSERT puro del SQL sin que intervenga ningún lenguaje de programación ni rutina ni API:

    Para insertar un registro en la tabla de clientes, municipios y provincias lo realizaremos respectivamente como:

    
            INSERT INTO clientes VALUES
            ("5316828K","PEDRO","ROMERO
            DIAZ","C/ HOLA 9   ",29003,29,911111111,19980203)  
            /g
    
            INSERT INTO municipios VALUES
            (28,001,"Fuenlabrada")
            /g
    
            INSERT INTO provincias VALUES
            (08,"Barcelona")
            /g
            

    Y finalmente, terminaremos nuestro recorrido por los comandos SQL realizando selecciones de los filas que hemos introducido en las tablas creadas anteriormente dentro de la base de datos que hemos creado para el ejemplo de este articulo. Seleccionaremos registros de las tabla de cliente variando la condición se selección y una primera selección de la tabla de municipios:

    
    >   SELECT ALL
    Cod_provincia, Cod_municipio, Descripcion_m from municipios
           where Cod_provincia = 28 /g
    
    Cod_provincia   Cod_municipio   Descripcion_m
    28              1               Fuenlabrada
    28              2               Pozuelo
    28              3               Madrid
    
    
    
    >  SELECT ALL
    NIF,Nombre,Apellidos,Direccion from clientes
           where Poblacion = 28001       
    
    NIF        Nombre           Apellidos         direccion
    2416728U   JOSE FERNANDEZ     ROMERO      C/ FELIZ 1 3G
    
    > SELECT ALL NIF,Nombre,Apellidos,Direccion from clientes
           where Provincia  = 29
    
    NIF        Nombre        Apellidos          direccion
    23198623N  JUAN ANDRES   RUIZ MORALES  C/ CATEDRAL 12 2B
    5316828K   PEDRO         ROMERO DIAZ   C/ HOLA 9
    52312844J  LUIS ALBERTO  LISTO JIMENEZ C/ ROSA DE LOS VIENTOS 129 3I  
    

    Conclusiones

    Como comentaba al principio del artículo, el objetivo que seguía era simplemente mostrar el funcionamiento y ver las características fundamentales de una implementación en concreto de un servidor de bases de datos SQL , pero no sólo quería indicar una sería de recetas y comandos para poder utilizarlo, sino que pretendía realizar un estudio de las posibilidades y carencias que podía tener este software , sobre todo porque conociendo a fondo un producto podemos obtener el máximo rendimiento de éste, utilizándolo en aquellos aspectos que más potenciados están. Este es el caso de este gestor de bases de datos, ya que considero que la no implementación de los triggers y la lógica transaccional hace muy complicado el manejo de datos (inserciones, modificaciones, borrado de registros) desde aplicaciones multiusuarios y utilizando multitud de tablas relacionas entre si. Aunque pienso que, para aplicaciones donde se pretenda realizar consultas muy rápidas a bases de datos muy grandes, sería recomendable éste servidor (teniendo siempre como referencia la versión semi-free de este servidor)

    Indicar para concluir que la base de este articulo la he obtenido de la propia documentación Mysql, que la considero bastante completa, de algunos artículos de revistas especializadas así como de un amarillento manual de "auto-estudio" de IBM sobre SQL.


    Texto original en Castellano


Páginas web mantenidas por Miguel Ángel Sepúlveda
© Jose M. Fernández 1998
LinuxFocus 1998