MySQL

1 - Introducción.

Es una lenguaje de programación que se utiliza para trabajar con base de datos relacionales
como MySQL, Oracle, etc

MySQL es un intérprete de SQL, es un servidor de base de datos nos permite crear bases de
datos y tablas, insertar dato, modificarlo, eliminarlos, ordenarlo, hacer consultas y realizar
muchas operaciones. Podemos ingresar instrucciones con el lenguaje PHP y al terminar la
sentencia la cerramos con un ;

Depende el sistema operativo que usemos va a detectar la mayúsculas, en Windows no afecta

pero en Linux si, por eso hay que tener cuidado a la hora de escribir las sentencias en
diferentes sistemas operativos.

2 - show databases.

Una bases de datos es un conjunto de tablas, y esta tiene un nombre por el cual podremos
acceder a ella, para que nos muestren la bases de datos existentes debemos usar el comando

Show databases;

3-Creación de una tabla y mostrar sus campos (create table - show tables - describe - drop
table).

las bases de datos almacenan sus datos en tablas, esta es una estructura que almacena datos
en columnas y filas; cada columna es un camp y cada fila un registro.

Para poder ver las tablas existentes usaremos

Show tables;

Para crear una tabla vamos a usar

Create table usuarios (

Nombre varchar (30),

Clave varchar(10)

);

Asi hemos creado la tabla llamada usuario, con los capos Nombre y clave. Si deseamos ver la
tabla que acabamos de crear vamos a usar.

show tables;

si deseamos eliminar la tabla que acabamos de creamos vamos a usar.

drop table usuarios;

vamos usar drop table y ponemos el nombre de la tabla que deseamos eliminar.

4-Carga de registros a una tabla y su recuperación (insert into - select).

Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro
tiene un dato por cada columna. Al ingresar los datos de cada registro debe tenerse en cuenta
la cantidad y el orden de los campos.Ahora vamos a agregar un registro a la tabla:

insert into usuarios (nombre, clave) values ('MarioPerez','Marito');

Usamos "insert into". Especificamos los nombres de los campos entre paréntesis y separados
por comas y luego los valores para cada campo, también entre paréntesis y separados por
comas.

Para ver los registros de una tabla usamos "select":

select nombre,clave from usuarios;

Aparece un registro, el comando "select" recupera los registros de una tabla. Luego del
comando select indicamos los nombres de los campos a rescatar.

5 - Típos de datos básicos de un campo de una tabla.

-varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de
caracteres. Se coloca entre comillas (simples): 'Hola'. El tipo "varchar" define una cadena de
longitud variable en la cual determinamos el máximo de caracteres. Puede guardar hasta
65535 caracteres.

- integer: se usa para guardar valores numéricos enteros, de -2000000000 a 2000000000

aprox.

- float: se usa para almacenar valores numéricos decimales. Se utiliza como separador el punto
(.).

6 - Recuperación de algunos campos (select).

Podemos especificar el nombre de los campos que queremos ver separándolos por comas:

select titulo,autor,editorial from libros;

En la sentencia anterior la consulta mostrará sólo los campos "titulo", "autor" y "editorial". En
la siguiente sentencia, veremos los campos correspondientes al título y precio de todos los
libros:

select titulo,precio from libros;

Para ver solamente la editorial y la cantidad de libros tipeamos:

select editorial,cantidad from libros;

7 - Recuperación de registros específicos (select - where).

Existe una cláusula, "where" que es opcional, con ella podemos especificar condiciones para la
consulta "select". Es decir, podemos recuperar algunos registros, sólo los que cumplan con
ciertas condiciones indicadas con la cláusula "where".

select nombre, clave from usuarios where nombre='MarioPerez';

Esta clausula que utilizamos busca si la condición en nuestro caso MarioPerez y recupera ese
registro.

8 - Operadores Relacionales = <> < <= > >=.

Los operadores relacionales son los siguientes:

= igual

<> distinto

> mayor

< menor

>= mayor o igual

<= menor o igual

9 - Borrado de registros de una tabla (delete).

Para eliminar los registros de una tabla usamos el comando "delete":

delete from usuarios;

La ejecución del comando indicado en la línea anterior borra TODOS los registros de la tabla.

Si queremos eliminar uno o varios registros debemos indicar cuál o cuáles, para ello utilizamos
el comando "delete" junto con la clausula "where" con la cual establecemos la condición que
deben cumplir los registros a borrar.

10 - Modificación de registros de una tabla (update).

Para modificar uno o varios datos de uno o varios registros utilizamos "update" (actualizar).

update usuarios set clave='Hola';

Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su
nuevo valor.

El cambio afectará a todos los registros.

Podemos modificar algunos registros, para ello debemos establecer condiciones de selección
con "where".
11 - Clave primaria.

Una clave primaria es un campo (o varios) que identifica 1 solo registro (fila) en una tabla. Para
un valor del campo clave existe solamente 1 registro. Los valores no se repiten ni pueden ser
nulos.

Establecemos que un campo sea clave primaria al momento de creación de la tabla:

create table usuarios (

nombre varchar(20),

clave varchar(10),

primary key(nombre)

);

Para definir un campo como clave primaria agregamos "primary key" luego de la definición de
todos los campos y entre paréntesis colocamos el nombre del campo que queremos como
clave.

12 - Campo entero con autoincremento.

Un campo de tipo entero puede tener otro atributo extra 'auto_increment'. Los valores de un
campo 'auto_increment', se inician en 1 y se incrementan en 1 automáticamente. Se utiliza
generalmente en campos correspondientes a códigos de identificación para generar valores
únicos para cada nuevo registro que se inserta. Sólo puede haber un campo "auto_increment"
y debe ser clave primaria (o estar indexado). Para establecer que un campo autoincremente
sus valores automáticamente, éste debe ser entero (integer) y debe ser clave primaria:

create table libros(

codigo int auto_increment,

titulo varchar(50),

autor varchar(50),

editorial varchar(25),

primary key (codigo)

);

Para definir un campo autoincrementable colocamos "auto_increment" luego de la definición

del campo al crear la tabla.
13 - Comando truncate table.

También podemos eliminar todos los registros de una tabla con "truncate table". Por ejemplo,
queremos vaciar la tabla "libros", usamos:

truncate table libros;

La sentencia "truncate table" vacía la tabla (elimina todos los registros) y vuelve a crear la tabla
con la misma estructura. La diferencia con "drop table" es que esta sentencia borra la tabla,
"truncate table" la vacía.

14 - Valores null.

"null' significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor 0, una
cadena vacía o una cadena literal "null". Por defecto, es decir, si no lo aclaramos en la creación
de la tabla, los campos permiten valores nulos. Imaginemos que ingresamos los datos de un
libro, para el cual aún no hemos definido el precio:

insert into libros (titulo,autor,editorial,precio)

values ('El aleph','Borges','Planeta',null);

Note que el valor "null" no es una cadena de caracteres, no se coloca entre comillas. Si un
campo acepta valores nulos, podemos ingresar "null" cuando no conocemos el valor. Los
campos establecidos como clave primaria no aceptan valores nulos. Nuestro campo clave
primaria, está definido "auto_increment"; si intentamos ingresar el valor "null" para este
campo, no lo tomará y seguirá la secuencia de incremento.

15 - Valores numéricos sin signo (unsigned).

El atributo "unsigned" (sin signo) permite sólo valores positivos. Si necesitamos almacenar
edades, por ejemplo, nunca guardaremos valores negativos, entonces sería adecuado definir
un campo "edad" de tipo entero sin signo:

edad integer unsigned;

16 - Tipos de datos.

Los valores que podemos guardar son:

A) TEXTO: Para almacenar texto usamos cadenas de caracteres. Las cadenas se colocan entre
comillas simples. Podemos almacenar dígitos con los que no se realizan operaciones
matemáticas, por ejemplo, códigos de identificación, números de documentos, números
telefónicos. Tenemos los siguientes tipos: varchar, char y text.

B) NUMEROS: Existe variedad de tipos numéricos para representar enteros, negativos,

decimales. Para almacenar valores enteros, por ejemplo, en campos que hacen referencia a
cantidades, precios, etc., usamos el tipo integer. Para almacenar valores con decimales
utilizamos: float o decimal.
C) FECHAS Y HORAS: para guardar fechas y horas dispone de varios tipos: date (fecha),
datetime (fecha y hora), time (hora), year (año) y timestamp.

D) OTROS TIPOS: enum y set representan una enumeración y un conjunto respectivamente. Lo

veremos más adelante.

E) Otro valor que podemos almacenar es el valor "null". El valor 'null' significa “valor
desconocido” o "dato inexistente", ya lo estudiamos. No es lo mismo que 0 o una cadena
vacía.

17 - Tipos de datos (texto).

1) varchar(x): define una cadena de caracteres de longitud variable en la cual determinamos el

máximo de caracteres con el argumento "x" que va entre paréntesis. Su rango va de 1 a 65535
caracteres..

2) char(x): define una cadena de longitud fija, su rango es de 1 a 255 caracteres. Si la cadena
ingresada es menor a la longitud definida (por ejemplo cargamos 'Juan' en un char(10)),
almacena espacios en blanco a la derecha, tales espacios se eliminan al recuperarse el dato. Un
char(10) ocupa 10 bytes, pues al ser fija su longitud, no necesita ese byte adicional donde
guardar la longitud. Por ello, si la longitud es invariable, es conveniente utilizar el tipo char;
caso contrario, el tipo varchar. Ocupa tantos bytes como se definen con el argumento "x". Si
ingresa un argumento mayor al permitido (255) aparece un mensaje indicando que no se
permite y sugiriendo que use "blob" o "text". Si omite el argumento, coloca 1 por defecto.

3) blob o text: bloques de datos de 60000 caracteres de longitud aprox. No lo veremos por
ahora.

18 - Tipos de datos (numéricos).

1) integer(x) o int(x): su rango es de -2000000000 a 2000000000 aprox. El tipo "int unsigned"

va de 0 a 4000000000. El tipo "integer" tiene subtipos:

- mediumint(x): va de –8000000 a 8000000 aprox. Sin signo va de 0 a 16000000 aprox.

- smallint(x): va de –30000 a 30000 aprox., sin signo, de 0 a 60000 aprox.

- tinyint(x): define un valor entero pequeño, cuyo rango es de -128 a 127. El tipo sin signo va de
0 a 255.

- bool o boolean: sinónimos de tinyint(1). Un valor cero se considera falso, los valores distintos
de cero, verdadero.

- bigint(x): es un entero largo. Va de –9000000000000000000 a 9000000000000000000 aprox.

Sin signo es de 0 a 10000000000000000000.

Para almacenar valores con decimales utilizamos:

2) float (t,d): número de coma flotante. Su rango es de -3.4e+38 a –1.1e-38 (9 cifras).

3) decimal o numeric (t,d): el primer argumento indica el total de dígitos y el segundo, la
cantidad de decimales. El rango depende de los argumentos, también los bytes que ocupa. Si
queremos almacenar valores entre 0.00 y 99.99 debemos definir el campo como tipo "decimal
(4,2)". Si no se indica el valor del segundo argumento, por defecto es 0. Para los tipos "float" y
"decimal" se utiliza el punto como separador de decimales.

19 - Tipos de datos (fechas y horas).

1) date: representa una fecha con formato "YYYY-MM-DD". El rango va de "1000-01-01" a

"9999-12-31".

2) datetime: almacena fecha y hora, su formato es "YYYY-MM-DD HH:MM:SS". El rango es de

"1000-01-01 00:00:00" a "9999-12-31 23:59:59".

3) time: una hora. Su formato es "HH:MM:SS". El rango va de "-838:59:59" a "838:59:59".

4) year(2) y year(4): un año. Su formato es "YYYY" o "YY". Permite valores desde 1901 a 2155
(en formato de 4 dígitos) y desde 1970 a 2069 (en formato de 2 dígitos).

20 - Valores por defecto.

Para todos los tipos, excepto "blob", "text" y "auto_increment" se pueden explicitar valores
por defecto con la cláusula "default"; tema que veremos más adelante. Un valor por defecto se
inserta cuando no está presente al ingresar un registro y en algunos casos en que el dato
ingresado es inválido. Los campos para los cuales no se ingresaron valores tomarán los valores
por defecto según el tipo de dato del campo, en el campo "codigo" ingresará el siguiente valor
de la secuencia porque es "auto_increment"; en el campo "titulo", ingresará una cadena vacía
porque es "varchar not null"; en el campo "editorial" almacenará "null", porque no está
definido "not null"; en el campo "precio" guardará "null" porque es el valor por defecto de los
campos no definidos como "not null" y en el campo "cantidad" ingresará 0 porque es el valor
por defecto de los campos numéricos que no admiten valores nulos.

21 - Valores inválidos.

Un valor es inválido por tener un tipo de dato incorrecto para el campo o por estar fuera de
rango. Veamos los distintos tipos de datos inválidos.

Para campos de tipo caracter:

-valor numérico: si en un campo definido de tipo caracter ingresamos un valor numérico, lo

convierte automáticamente a cadena. Por ejemplo, si guardamos 234 en un varchar, almacena
'234'.

-mayor longitud: si intentamos guardar una cadena de caracteres mayor a la longitud definida,
la cadena se corta guardando sólo la cantidad de caracteres que quepa. Por ejemplo, si
definimos un campo de tipo varchar(10) y le asignamos la cadena 'Buenas tardes', se
almacenará 'Buenas tar' ajustándose a la longitud de 10.

Para campos numéricos:

-cadenas: si en un campo numérico ingresamos una cadena, lo pasa por alto y coloca 0. Por
ejemplo, si en un campo de tipo "integer" guardamos 'abc', almacenará 0.

-valores fuera de rango: si en un campo numérico intentamos guardar un valor fuera de rango,
se almacena el valor límite del rango más cercano (menor o mayor). Por ejemplo, si definimos
un campo 'tinyint' (cuyo rango va de -128 a 127) e intentamos guardar el valor 200, se
almacenará 127, es decir el máximo permitido del rango; si intentamos guardar -200, se
guardará -128, el mínimo permitido por el rango. Otro ejemplo, si intentamos guardar el valor
1000.00 en un campo definido como decimal(5,2) guardará 999.99 que es el mayor del rango.

-valores incorrectos: si cargamos en un campo definido de tipo decimal un valor con más
decimales que los permitidos en la definición, el valor es redondeado al más cercano. Por
ejemplo, si cargamos en un campo definido como decimal(4,2) el valor 22.229, se guardará
22.23, si cargamos 22.221 se guardará 22.22.

Para campos definidos auto_increment el tratamiento es el siguiente:

- Pasa por alto los valores fuera del rango, 0 en caso de no ser "unsigned" y todos los menores
a 1 en caso de ser "unsigned".

- Si ingresamos un valor fuera de rango continúa la secuencia.

- Si ingresamos un valor existente, aparece un mensaje de error indicando que el valor ya

existe.

Para campos de fecha y hora:

-valores incorrectos: si intentamos almacenar un valor que MySql no reconoce como fecha
(sea fuera de rango o un valor inválido), convierte el valor en ceros (según el tipo y formato).
Por ejemplo, si intentamos guardar '20/07/2006' en un campo definido de tipo "date", se
almacena '0000-00-00'. Si intentamos guardar '20/07/2006 15:30' en un campo definido de
tipo "datetime", se almacena '0000-00-00 00:00:00'. Si intentamos almacenar un valor inválido
en un campo de tipo "time", se guarda ceros. Para "time", si intentamos cargar un valor fuera
de rango, se guarda el menor o mayor valor permitido (según sea uno u otro el más cercano).

Para campos de cualquier tipo:

-valor "null": si un campo está definido "not null" e intentamos ingresar "null", aparece un
mensaje de error y la sentencia no se ejecuta.