TEORIA DE MYSQL

proporciona un servidor de base de datos SQL (Structured Query Language)

muy rápido, multi usuario, algunas de las características más importantes del
software de base de datos MySQL.

 Funciona en diferentes plataformas.

 Tipos de columnas( de datos)
FLOAT, DOUBLE, CHAR,VARCHAR, TEXT, BLOB, DATE, TIME, DAT
ETIME, TIMESTAMP, YEAR, SET, ENUM,
 Registros de longitud fija y longitud variable.

 Sentencias y funciones

 Soporte completo para operadores y funciones en las cláusulas de

consultas SELECT y WHERE.
 Soporte completo para las cláusulas SQL GROUP BY y ORDER BY.
Soporte de funciones de agrupación
(COUNT(), COUNT(DISTINCT ...), AVG(), STD(), SUM(), MAX(), MIN(),
y GROUP_CONCAT()).

 Seguridad

 Un sistema de privilegios y contraseñas que es muy flexible y

seguro, y que permite verficación basada en el host. Las contraseñas son
seguras porque todo el tráfico de contraseñas está cifrado cuando se
conecta con un servidor.

 Escalabilidad y límites

 Soporte a grandes bases de datos. Usamos MySQL Server con

bases de datos que contienen 50 millones de registros. También
conocemos a usuarios que usan MySQL Server con 60.000 tablas y cerca
de 5.000.000.000.000 de registros.

 Se permiten hasta 64 índices por tabla (32 antes de MySQL

4.1.2). Cada índice puede consistir desde 1 hasta 16 columnas o partes
de columnas. El máximo ancho de límite son 1000 bytes (500 antes de
MySQL 4.1.2).Un índice puede usar prefijos de una columna para los
tipos de columna CHAR, VARCHAR, BLOB, o TEXT.
 Conectividad
  Los clientes pueden conectar con el servidor MySQL usando
sockets TCP/IP en cualquier plataforma. En sistemas Windows de la
familia NT (NT,2000,XP, o 2003), los clientes pueden usar named pipes
para la conexión. En sistemas Unix, los clientes pueden conectar usando
ficheros socket Unix.

 En MySQL 5.0, los servidores Windows soportan conexiones con

memoria compartida si se inicializan con la opción --shared-memory. Los
clientes pueden conectar a través de memoria compartida usando la
opción --protocol=memory.
 La interfaz para el conector ODBC (MyODBC) proporciona a
MySQL soporte para programas clientes que usen conexiones ODBC
(Open Database Connectivity). Por ejemplo, puede usar MS Access para
conectar al servidor MySQL. Los clientes pueden ejecutarse en Windows
o Unix. El código fuente de MyODBC está disponible. Todas las funciones
para ODBC 2.5 están soportadas, así como muchas otras.
ConsulteSección 25.1, “MySQL Connector/ODBC”.

Para crear una base de datos

mysql> CREATE DATABASE menagerie;
Al crear una base de datos, ésta no se selecciona para su uso, debe hacerlo
explicitamente. Para convertir amenagerie en la base de datos actual, use este
comando:
mysql> USE menagerie
Database changed

Para crear una tabla

Debe usar la sentencia CREATE TABLE para especificar la estructura de una

tabla:
mysql> CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20),
-> species VARCHAR(20), sex CHAR(1), birth DATE, death DATE);

El tipo de dato VARCHAR es una buena elección para las

columnas name, owner, y species porque los datos que allí se almacenan no
son de longitud uniforme.
Es obvio el uso del tipo de dato DATE para las columnas birth y death.
Luego de crear una tabla, SHOW TABLES debería producir una salida:
mysql> SHOW TABLES;
+---------------------+
| Tables in menagerie |
+---------------------+
| pet |
+---------------------+
Para verificar que la tabla ha sido creada en la forma esperada, utilice la
sentencia DESCRIBE:
mysql> DESCRIBE pet;
+---------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| name | varchar(20) | YES | | NULL | |
| owner | varchar(20) | YES | | NULL | |
| species | varchar(20) | YES | | NULL | |
| sex | char(1) | YES | | NULL | |
| birth | date | YES | | NULL | |
| death | date | YES | | NULL | |
+---------+-------------+------+-----+---------+-------+
DESCRIBE puede ser utilizada en cualquier momento, por ejemplo, si olvida
los nombres o el tipo de dato de las columnas de la tabla.

Para llenar una tabla

Luego de crear la tabla, necesitará completarla con datos. Para esto, le serán
de utilidad las sentencias LOAD DATA e INSERT.

Para esto, debería crear un fichero de texto llamado pet.txt, conteniendo un

registro por linea, con cada valor separado por un carácter de tabulación, y
dispuestos en el orden en el cual se especificaron las columnas en la
sentencia CREATE TABLE. Para valores ausentes (como sexo desconocido o
fechas de muerte de animales con vida), puede usar valores NULL. Para
representar estos valores en el archivo de texto, utilice \N (barra diagonal y N
mayúscula). Por ejemplo, el registro de Whistler se vería del modo siguiente (el
espacio en blanco entre cada valor es un solo carácter de tabulación):

Name owner species sex birth death

Whistler Gwen bird \N 1997-12-09 \N

Para cargar el fichero pet.txt dentro de la tabla pet, utilice este comando:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet;
Si trabaja en Windows, con un editor que emplea \r\n (retorno de carro + nueva
linea) como caracteres de fin de línea, debería usar:
mysql> LOAD DATA LOCAL INFILE '/path/pet.txt' INTO TABLE pet
-> LINES TERMINATED BY '\r\n';
(En un ordenador Apple bajo OS X, probablemente quiera utilizar LINES
TERMINATED BY '\r'.).

Opcionalmente puede especificar en la sentencia LOAD DATA los caracteres

que actuarán como separador de campo y fin de línea, pero los valores por
defecto son tabulación y nueva línea. Estos son suficientes para que la
sentencia lea correctamente el fichero pet.txt
Si ocurre un error al ejecutar la sentencia, probablemente se deba a que su
instalación de MySQL no tiene habilitada por defecto la capacidad de manejar
archivos locales.
Cuando lo que desea es agregar nuevos registros de a uno por vez, la
sentencia INSERT resulta de utilidad. De esta sencilla manera, se suministran
valores para cada columna, dispuestos en el orden en el cual se especificaron
las columnas en la sentencia CREATE TABLE statement. Suponga que Diane
obtiene un nuevo hamster llamado "Puffball". Se podría agregar un nuevo
registro, usando la sentencia INSERT de este modo:
mysql> INSERT INTO pet
-> VALUES ('Puffball','Diane','hamster','f','1999-03-30',NULL);
Observe que las cadenas alfanuméricas y las fechas son representados como
cadenas delimitadas por apóstrofos. También, con INSERT, se pueden insertar
valores NULL directamente, para indicar un valor ausente. No se debe
utilizar \N como se hace con LOAD DATA.
A partir de este ejemplo queda demostrado que lleva mucho más trabajo
realizar una carga inicial de registros empleando varias sentencias INSERT que
si se hace mediante la sentencia LOAD DATA.

Para extraer información de una tabla

La sentencia SELECT es utilizada para traer información desde una tabla. La

sintaxis general de esta sentencia es:
SELECT seleccionar_Esto
FROM desde_tabla
WHERE condiciones;
 Para seleccionar todos los datos de una tabla

mysql> SELECT * FROM pet;

Esta forma de SELECT es útil si se quiere revisar la tabla completa, por
ejemplo, despues de haberla cargado con un conjunto de datos inicial. Por
ejemplo, puede ocurrir que la fecha de nacimiento de Bowser no parezca
correcta. Consultando los papeles de pedigri, se descubre que el año correcto
de nacimiento es 1989, no 1979.
Existen al menos dos formas de solucionarlo:

 Editando el fichero pet.txt para corregir el error, vaciando la tabla y

volviendola a llenar con los datos. Para esto se usan las
sentencias DELETE y LOAD DATA:
mysql> DELETE FROM pet;
mysql> LOAD DATA LOCAL INFILE 'pet.txt' INTO TABLE pet;
No obstante, si opta por esto, deberá volver a cargar el registro de Puffball.

 Corrigiendo únicamente el registro erróneo. Para esto se usa la

sentencia UPDATE:
mysql> UPDATE pet SET birth = '1989-08-31' WHERE name = 'Bowser';
UPDATE modifica solo el registro en cuestión y no requiere que se vuelva a
llenar la tabla.

Para seleccionar registros específicos

mysql> SELECT * FROM pet WHERE name = 'Bowser';

para seleccionar columnas concretas

mysql> SELECT name, birth FROM pet;

Para saber quien posee mascotas, utilice esta consulta:

mysql> SELECT owner FROM pet;
+--------+
| owner |
+--------+
| Harold |
| Gwen |
| Harold |
| Benny |
| Diane |
| Gwen |
| Gwen |
| Benny |
| Diane |
+--------+
Observe que esta sentencia retorna el campo owner de cada registro, y
algunos de ellos aparecen más de una vez. Para reducir la salida, recupere
solamente una vez cada registro repetido, agregando la palabra
claveDISTINCT:
mysql> SELECT DISTINCT owner FROM pet;
+--------+
| owner |
+--------+
| Benny |
| Diane |
| Gwen |
| Harold |
+--------+
Puede emplearse una clásula WHERE para combinar la selección de ciertas
filas y de ciertas columnas. Por ejemplo, para obtener únicamente la fecha de
nacimiento de perros y gatos, ejecute esta consulta:
mysql> SELECT name, species, birth FROM pet
-> WHERE species = 'dog' OR species = 'cat';
+--------+---------+------------+
| name | species | birth |
+--------+---------+------------+
| Fluffy | cat | 1993-02-04 |
| Claws | cat | 1994-03-17 |
| Buffy | dog | 1989-05-13 |
| Fang | dog | 1990-08-27 |
| Bowser | dog | 1989-08-31 |
+--------+---------+------------+

Para ordenar registros

A menudo es más fácil examinar la salida de una consulta cuando las filas se
ordenan de algún modo significativo. Para ordenar un resultado, se usa la
clásula ORDER BY.
Aqui tiene las fechas de cumpleaños de los animales, ordenadas por fecha:
mysql> SELECT name, birth FROM pet ORDER BY birth;