Taller de Sentencias Utiles en MySQL PDF

PROGRAMACION DE SOFTWARE TALLER DE BASES DE DATOS - SQL
Estimado Aprendiz, con este taller se pretende que usted reciba y afiance sus conocimientos básicos en tratamiento de
sentencias SQL. Se advierte que no están todas las sentencias, pues demoraría bastante el curso en demostrar el
funcionamiento de cada sentencia, pero con este taller práctico y si es realizado a conciencia, usted tendrá las bases
mínimas para enfrentar el diseño y modelado de una base de datos, es posible que usted deba repetir varias sentencias
debido a que lo ejercicios son distintos dependiendo el requisito, entonces ¡Manos a la obra!
Crear la base de datos.
create database biblioteca;
Crear la tabla usuarios con los campos nombre y clave. Previamente borrar la tabla usuarios si ya existe en el servidor.
Luego mostrar la estructura de la tabla usuarios que acabamos de crear.
drop table if exists usuarios;

create table usuarios ( nombre varchar(30), clave varchar(10));
describe usuarios;
Insertar tres registros en la tabla usuarios y luego mostrar todos los registros de la tabla.
Primero eliminamos la tabla, si existe:

Creamos la tabla:
create table usuarios (nombre varchar(30), clave varchar(10));
Insertamos 3 registros:
insert into usuarios(nombre,clave) values ('MarioPerez','Marito');
insert into usuarios(nombre,clave) values ('MariaGarcia','Mary');
insert into usuarios(nombre,clave) values ('DiegoRodriguez','z8080');
Para ver los registros ejecutamos el comando select:
select nombre,clave from usuarios;
Típos de datos básicos de un campo de una tabla.
Para almacenar información de los libros de una librería necesitamos los siguientes campos:
-titulo, cadena de caracteres de 40 de longitud,
-autor, cadena de caracteres de 30 de longitud,
-editorial, caracteres de 15 de longitud,
-precio, valor numérico con decimales y
-cantidad, valor numérico entero.
Al crear la tabla, entonces, elegimos el tipo de dato más adecuado para cada campo:
create table libros( titulo varchar(40), autor varchar(20), editorial varchar(15), precio float, cantidad integer );
Vemos la estructura de la tabla:
describe libros;
Ingresamos algunos registros:
insert into libros (titulo,autor,editorial,precio,cantidad) values ('El aleph','Borges','Emece',45.50,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Alicia en el pais de las maravillas','Lewis Carroll',
'Planeta',25,200);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matemática estas ahi','Paenza','Planeta',15.8,200);
Veamos los registros cargados:
select * from libros;
Tengamos en cuenta que es lo mismo escribir:
Que
select codigo,titulo,autor,precio from libros;
Instructor Victor Rincon
Es una forma resumida de indicar que seleccione todos los campos de la tabla.
Recuperación de algunos campos (select)
Trabajamos con la tabla "libros" que almacena los datos de los libros de una librería.
Eliminamos la tabla, si existe:
drop table if exists libros;
Creamos la tabla "libros":
create table libros(titulo varchar(20), autor varchar(30), editorial varchar(15), precio float, cantidad integer );
Veamos la estructura de la tabla:
describe libros;
insert into libros (titulo,autor,editorial,precio,cantidad) values ('El aleph','Borges','Emece',45.50,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Alicia en el pais de las maravillas','Lewis
Carroll','Planeta',25,200);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matemática estas ahi','Paenza','Planeta',15.8,200);
Para ver todos los campos de una tabla tecleamos:
Con el asterisco (*) indicamos que seleccione todos los campos de la tabla.
Para ver solamente el título, autor y editorial de todos los libros especificamos los nombres de los campos separados por
comas:
select titulo,autor,editorial from libros;
La siguiente sentencia nos mostrará los títulos y precios de todos los libros:
select titulo,precio from libros;
Para ver solamente la editorial y la cantidad de libros tecleamos:
select editorial,cantidad from libros;
Recuperación de registros específicos (select - where)
Borramos la tabla si existe
Creamos la tabla:
describe usuarios;
insert into usuarios (nombre, clave) values ('Leonardo','payaso');
insert into usuarios (nombre, clave) values ('MarioPerez','Marito');
insert into usuarios (nombre, clave) values ('Marcelo','bocajunior');
insert into usuarios (nombre, clave) values ('Gustavo','bocajunior');
Vemos todos los registros:
select nombre, clave from usuarios;
Realizamos una consulta especificando una condición, queremos ver el usuario cuyo nombre es "Leonardo":
select nombre, clave from usuarios where nombre='Leonardo';
Realizamos un "select" de los usuarios cuya clave es 'bocajunior':
select nombre, clave from usuarios where clave='bocajunior';
Realizamos un "select" de los usuarios cuya clave es 'river':
select nombre, clave from usuarios where clave='river';
No aparece ninguno pues ningún registro cumple la condición.
Operadores Relacionales = <> < <= > >=
Borramos la tabla libros si existe
La creamos con la siguiente estructura:
create table libros(titulo varchar(20), autor varchar(30), editorial varchar(15), precio float);
Por primera vez definimos un campo de tipo float.
Agregamos registros a la tabla:
insert into libros (titulo,autor,editorial,precio) values ('El aleph','Borges','Planeta',12.50);
insert into libros (titulo,autor,editorial,precio) values ('Martin Fierro','Jose Hernandez','Emece',16.00);
insert into libros (titulo,autor,editorial,precio) values ('Aprenda PHP','Mario Molina','Emece',35.40);
insert into libros (titulo,autor,editorial,precio) values ('Cervantes','Borges','Paidos',50.90);
Note que al ingresar valores numéricos (en este caso float) no se utilizan comillas y para el separador de decimales se usa
el punto(.).
Seleccionamos todos los registros:
select titulo, autor,editorial,precio from libros;
Seleccionamos los registros cuyo autor sea diferente de 'Borges':
select titulo,autor,editorial,precio from libros where autor<>'Borges';
Seleccionamos los registros cuyo precio supere los 20 pesos:
select titulo,autor,editorial,precio from libros where precio>20;
Seleccionamos los libros cuyo precio es menor o igual a 30:
select titulo,autor,editorial,precio from libros where precio<=30;
Note que al comparar valores numéricos (en este caso de tipo float) no se utilizan comillas.
Borrado de registros de una tabla (delete)
Trabajamos con la tabla "usuarios".
Creamos la tabla:
insert into usuarios (nombre, clave) values ('Marcelo','River');
insert into usuarios (nombre, clave) values ('Gustavo','River');
Queremos eliminar el registro cuyo nombre de usuario es 'Leonardo':
delete from usuarios where nombre='Leonardo';
Veamos el contenido de la tabla:
Queremos eliminar los registros cuya clave es 'River':
delete from usuarios where clave='River';
Eliminemos todos los registros:
delete from usuarios;
Modificación de registros de una tabla (update)
Trabajamos con la tabla "usuarios" que guarda el nombre de usuario y su clave.
Creamos la tabla:
Visualizamos todos los registros:
select * from usuarios;
Para actualizar los valores de todas las claves, por 'RealMadrid' tecleamos:
update usuarios set clave='RealMadrid';
Visualizamos todos los registros para verificar la actualización:
Cambiamos el valor correspondiente a la clave de nuestro usuario llamado 'MarioPerez', por 'Boca':
update usuarios set clave='Boca' where nombre='MarioPerez';
Verificamos el cambio:
Cambiamos el valor correspondiente al nombre de usuario 'Gustavo' por 'GustavoGarcia':
update usuarios set nombre='GustavoGarcia' where nombre='Gustavo';
Podemos actualizar varios campos en una sola instrucción:
update usuarios set nombre='MarceloDuarte', clave='Marce' where nombre='Marcelo';
Clave o llave primaria.
Trabajamos con la tabla "usuarios" que contiene el nombre de usuario y su clave.
Creamos la tabla:
create table usuarios (nombre varchar(20), clave varchar(10), primary key (nombre));
describe usuarios;
Note que en la columna "KEY" del campo "nombre" aparece "PRI", esto significa que ese campo es clave primaria.
Al intentar ingresar un valor repetido para el campo clave, aparece un mensaje de error indicando que el registro no se
cargó pues el dato está duplicado; veámoslo en un ejemplo, ingresemos un registro con un nombre de usuario repetido:
insert into usuarios (nombre, clave) values ('Gustavo','Boca');
Campo entero con autoincremento.
Trabajamos con la tabla "libros" de una librería.
Creamos la tabla estableciendo como clave primaria y "auto_increment" el campo "codigo":
create table libros(codigo integer auto_increment, titulo varchar(20), autor varchar(30), editorial varchar(15),
primary key (codigo));
Al visualizar la estructura de la tabla:
describe libros;
Vemos que en la columna "EXTRA" del campo "codigo" aparece "auto_increment", esto significa que el campo es
autoincrementable, en la columna "KEY" aparece "PRI", es clave primaria.
insert into libros (titulo,autor,editorial) values('El aleph','Borges','Planeta');
Note que al detallar los campos para los cuales ingresaremos valores hemos omitido "codigo"; cuando un campo es
"auto_increment" no es necesario ingresar valor para él, porque se genera automáticamente. Recuerde que si es
obligatorio ingresar los datos de todos los campos que se detallan y en el mismo orden.
Si mostramos los registros:
Vemos que este primer registro ingresado guardó el valor 1 en el campo correspondiente al código, comenzó la secuencia
en 1.
Ingresamos más registros:
insert into libros (titulo,autor,editorial) values('Martin Fierro','Jose Hernandez','Emece');
insert into libros (titulo,autor,editorial) values('Aprenda JAVA','Mario Ladron','Emece');
insert into libros (titulo,autor,editorial) values('Cervantes y el Quijote','Borges','Paidos');
insert into libros (titulo,autor,editorial) values('Matemática de pichurrios', 'Paenza', 'Paidos');
Seleccionamos todos los registros:
select codigo,titulo,autor,editorial from libros;
Vemos que el código, dato que no ingresamos, se cargó automáticamente siguiendo la secuencia de autoincremento.
Está permitido ingresar el valor correspondiente al campo "auto_increment", por ejemplo:
insert into libros (codigo,titulo,autor,editorial)values(6,'Martin Fierro','Jose Hernandez','Palidos');
Pero debemos tener cuidado con la inserción de un dato en campos "auto_increment".
Veamos los distintos casos.
Si ingresamos un valor repetido, aparecerá un mensaje de error y el registro no se ingresará:
insert into libros (codigo,titulo,autor,editorial) values(2,'Martin Fierro','Jose Hernandez','Planeta');
Si ingresamos un valor que no sigue la secuencia, el dato es válido, lo toma, por ejemplo:
insert into libros (codigo,titulo,autor,editorial) values(15,'Harry Potter y la piedra filosofal','J.K. Rowling','Emece');
El siguiente registro insertado tomará el valor más alto para seguir la secuencia (en este caso 16):
insert into libros (titulo,autor,editorial) values('Harry Potter y la cámara secreta','J.K. Rowling','Emece');
Si ingresamos 0, no lo toma y guarda el registro continuando la secuencia (17 en este caso):
insert into libros (codigo,titulo,autor,editorial) values(0,'Alicia en el pais de las ratas','Manuel Santos','Planeta');
Si ingresamos un valor negativo (y el campo no está definido para aceptar sólo valores positivos), lo ingresa:
insert into libros (codigo,titulo,autor,editorial) values(-5,'Alicia a traves del espejo','Lewis Carroll','Planeta');
Comando truncate table.
Creamos la tabla:
create table libros(codigo integer auto_increment, titulo varchar(20), autor varchar(30), editorial varchar(15),
insert into libros (titulo,autor,editorial) values('Martin Fierro','Jose Hernandez','Planeta');
insert into libros (titulo,autor,editorial) values('Aprenda JAVA','Mario Ladron','Emece');
insert into libros (titulo,autor,editorial) values('Cervantes y el Quijote','Borges','Paidos');
insert into libros (titulo,autor,editorial) values('Matemática de pichurrios', 'Paenza', 'Paidos');
insert into libros (titulo,autor,editorial) values('El aleph', 'Borges', 'Emece');
Eliminemos todos los registros con "delete":
delete from libros;
Veamos el resultado:
La tabla ya no contiene registros.
Ingresamos un nuevo registro:
insert into libros (titulo,autor,editorial) values('Antología poetica', 'Borges', 'Emece');
Veamos el resultado:
Para el campo "codigo" se guardó el valor 6 porque el valor más alto de ese campo, antes de eliminar todos los registros
era "5".
Ahora vaciemos la tabla:
truncate table libros;
Veamos qué sucede si ingresamos otro registro sin valor para el código:
insert into libros (titulo,autor,editorial) values('Antología poética', 'Borges', 'Emece');
Vemos que la secuencia de "codigo" empezó en 1 nuevamente.
Ejecutamos entonces:
Valores null.
Creamos la tabla estableciendo con la siguiente estructura:
create table libros(codigo integer auto_increment, titulo varchar(20) not null, autor varchar(30), editorial varchar(15),
precio float, primary key(codigo));
Al visualizar la estructura de la tabla con "describe", Vemos lo siguiente:
Field Type Null Key Default Extra
______________________________________________________________________
codigo int(11) 7 b.. NO PRI (NULL) auto_increment
titulo varchar(20) 11 b.. NO
autor varchar(30) 11 b.. YES (NULL)
editorial varchar(15) 11 b.. YES (NULL)
precio float 5 b.. YES (NULL)
Vemos que el campo "codigo" y el campo "titulo" no permiten valores nulos. Y que el campo "codigo" es clave primaria y
"auto_increment". Los demás campos permiten valores nulos.
insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Planeta',null);
ingresamos "null" para el precio, campo que permite valores nulos. Note que el valor "null" no se coloca entre comillas
porque no es una cadena de caracteres.
Si intentamos ingresar el valor "null" en un campo que no lo permite (titulo), aparece un mensaje de error indicando tal
situación:
insert into libros (titulo,autor,editorial,precio) values (null,'Paenza','Paidos',10.30);
Si intentamos ingresar el valor "null" para el campo "codigo", que es clave primaria y "auto_increment", no lo tomará y
seguirá la secuencia de incremento:
insert into libros (codigo,titulo,autor,editorial,precio) values (null,'El quijote de la mancha', 'Cervantes Saavedra',
'Emece',25.50);
Podemos ingresar valores nulos en los campos que lo permiten, por ejemplo, en "editorial":
insert into libros (titulo,autor,editorial,precio) values ('Harry Potter y la piedra filosofal', 'J.K. Rowling',null,30.00);
Ingresemos otros valores que nos servirán luego para verificar que los valores "null" son diferentes de 0 y de cadenas
vacías.
insert into libros (titulo,autor,editorial,precio) values ('Matemática estas ahi','Paenza','Paidos',0);
insert into libros (titulo,autor,editorial,precio) values ('Martin Fierro','Jose Hernandez','',22.50);
Explicamos que "null" no es lo mismo que una cadena vacía o un valor 0.
Para recuperar los registros que contengan el valor "null" en el campo "precio" tecleamos:
select * from libros where precio is null;
La salida será diferente a:
select * from libros where precio=0;
Verifiquemos que las siguientes sentencias no retornan el mismo resultado:
select * from libros where editorial is null;
select *from libros where editorial='';
Con la primera sentencia recuperamos los libros cuya editorial es "null"; con la segunda, los libros cuya editorial guarda
una cadena vacía.
Valores numéricos sin signo (unsigned)
Trabaje con la tabla "libros" de una librería.
Elimine la tabla, si existe:
Cree la tabla con la siguiente estructura:
create table libros(codigo integer unsigned auto_increment, titulo varchar(20) not null, autor varchar(30),
editorial varchar(15), precio float unsigned, cantidad integer unsigned, primary key (codigo));
Al definir los campos especificamos si un campo numérico es "unsigned".
El atributo "unsigned" (sin signo) sólo puede agregarse a un campo de tipo numérico (enteros o comas flotantes)
permitiendo para dicho campo sólo valores positivos.
Si visualizamos la estructura de la tabla con "describe", Vemos que en el tipo de dato aparece este atributo:
Field Type
_________________________________
codigo int(10) unsigned
titulo varchar(20)
autor varchar(30)
editorial varchar(15)
precio float unsigned
cantidad int(10) unsigned
Para almacenar el código de los libros, definimos un campo de tipo "integer unsigned" porque guardaremos valores a
partir de 1 en adelante (no valores negativos).
Para almacenar el precio de los libros, definimos un campo de tipo "float unsigned" porque jamás guardaremos un valor
negativo.
Para almacenar la cantidad de libros disponibles, definimos un campo de tipo "integer unsigned" porque el menor valor
posible será 0, nunca negativos.
Tipos de datos (texto)
Un comercio que tiene un stand en una feria registra en una tabla llamada "visitantes" algunos datos de las personas que
visitan o compran en su stand para luego enviarle publicidad de sus productos.
Eliminamos la tabla "visitantes", si existe.
Creamos con la siguiente estructura:
create table visitantes(nombre varchar(30), edad integer unsigned, sexo char(1), domicilio varchar(30),
ciudad varchar(20), telefono varchar(11), montocompra float unsigned);
Note que definimos el campo "sexo" de tipo "char", porque necesitamos solamente 1 caracter "f" o "m", que siempre
será fijo, con esta definición ocupamos un byte.
Tipos de datos (numéricos)
Creamos la tabla con la siguiente estructura:
create table libros(codigo int unsigned auto_increment, titulo varchar(20) not null, autor varchar(30),
editorial varchar(15), precio decimal(5,2) unsigned, cantidad smallint unsigned, primary key (codigo));
Note que definimos el campo "cantidad" de tipo "smallint unsigned", esto es porque los valores para este campo serán
siempre positivos (mayores o iguales a 0), además la cantidad disponible no superará los 60000 aprox., así que no es
adecuado usar int (cuyo rango llega hasta 4000 millones aprox.), así ocupamos menos espacio (3 bytes para mediumint
contra 4 bytes para int). Es importante elegir el tipo de dato más preciso.
Como en el campo "precio" almacenaremos valores entre 0.00 y 999.99 definimos el campo como tipo "decimal (5,2)",
así evitamos tantos decimales innecesarios que teníamos antes con el tipo "float".
Tipos de datos (fechas y horas)
Una playa de estacionamiento guarda cada día los datos de los vehículos que ingresan a la playa en una tabla llamada
"vehiculos".
Eliminamos la tabla "vehiculos" si existe:
drop table if exists vehiculos;
create table vehiculos(patente char(6) not null, tipo char (4), horallegada time not null, horasalida time);
Hemos definido el campo "patente" de tipo "char" y no "varchar" porque la cadena de caracteres siempre tendrá la
misma longitud (6 caracteres), con esta definición ocupamos 6 bytes, si lo hubiésemos definido como "varchar(6)"
ocuparía 7 bytes. Lo mismo sucede con el campo "tipo", en el cual almacenaremos "auto" o "moto", necesitamos 4
caracteres fijos. Para los campos que registran la hora de llegada y de salida de cada vehículo usamos "time" porque
solamente almacenaremos horas, no fechas.
insert into vehiculos (patente,tipo,horallegada) values ('ACD123','auto','8:30');
insert into vehiculos (patente,tipo,horallegada) values('BGF234','moto','8:35');
insert into vehiculos (patente,tipo,horallegada) values('KIU467','auto','9:40');
Vemos los registros cargados:
select * from vehiculos;
Note que no ingresamos los segundos y colocó por defecto "00" para ellos.
Actualizamos la hora de salida del vehículo con patente "ACD123":
update vehiculos set horasalida='11:45' where patente='ACD123';
Ingresemos un registro con la hora, sin los minutos:
insert into vehiculos values('LIO987','auto','10',null);
Veamos lo que sucedió:
select * from vehiculos;
almacenó el valor ingresado como si fueran segundos.
Ingresamos un valor de horas y minutos sin separador:
insert into vehiculos values('GTR987','auto','1010',null);
incluye el separador, almacena "10:10".
Si ingresamos un valor "datetime" (fecha y hora), almacena solamente la hora:
insert into vehiculos values('HTR234','auto','2006-12-15 12:15',null);
Si ingresamos un separador diferente al permitido, por ejemplo "/", guarda solamente el último valor y lo coloca como
segundos:
insert into vehiculos values('KUY246','auto','12/15',null);
almacena "00:00:15".
Valores por defecto.
editorial varchar(15), precio decimal(5,2) unsigned, cantidad mediumint unsigned not null, primary key(codigo));
Veamos en algunos ejemplos qué sucede cuando al ingresar un registro no colocamos valores para algunos campos:
insert into libros (titulo,autor,precio) values('El aleph','Borges',23.6);
En el campo "codigo" ingresará el siguiente valor de la secuencia porque es "auto_increment"; en el campo "editorial"
almacenará "null", porque el campo acepta valores nulos y en el campo "cantidad" ingresará 0 porque es el valor por
defecto de los campos numéricos que no admiten valores nulos.
Ingresamos otro registro con algunos valores explícitos:
insert into libros (autor,editorial,cantidad) values('Borges','Planeta',100);
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" y en el campo "precio" guardará "null" porque es el valor por
defecto de los campos no definidos como "not null.
Valores inválidos.
editorial varchar(15), precio decimal(5,2) unsigned, cantidad mediumint unsigned not null, primary key(codigo));
Ingresemos algunos registros con valores inválidos y veamos qué sucede:

insert into libros (titulo,autor,editorial,precio) values ('Alicia en el pais de las maravillas',555,'Planeta',23.45);
En el campo "titulo" ingresamos una cadena de más de 20 caracteres (que es la longitud definida para el campo), como
resultado, corta la cadena ingresada. En el campo "autor" ingresamos un valor numérico, lo convierte a cadena.
Ingresemos otro registro:
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matemática esta ahi','Paenza','Planeta','abc',20000000);
En el campo "precio" ingresamos una cadena, la pasa por alto y coloca 0. En el campo "cantidad" ingresamos un valor
fuera de rango, entonces guarda el valor límite más cercano del rango (16777215).
insert into libros (titulo,editorial,precio) values ('Alegoria','Planeta',3333.50);
Como cargamos en el campo "precio" (decimal 5,2) un fuera de rango, almacenó el máximo valor permitido por el rango
(999.99).
insert into libros (titulo,editorial,precio) values ('Alegoria','Planeta',33.567);
Como cargamos en el campo "precio" (decimal 5,2) un valor con más decimales que los permitidos, el valor es
redondeado al más cercano (33.57).
insert into libros (codigo,titulo) values (2,'El gato con botas');
Aparece un mensaje de error indicando que la clave está duplicada.
Ingresemos otros registros:
insert into libros (codigo,titulo) values (0,'El gato con botas');
insert into libros (codigo,titulo) values (-5,'Robin Hood');
Intentamos ingresar el valor 0 para el código, lo pasa por alto y sigue la secuencia. Lo mismo sucede si ingresamos un
valor negativo.
Veamos qué sucede con los valores "null":
insert into libros (codigo,titulo) values (null,'Alicia a traves del espejo');
Si intentamos ingresar "null" para el código, lo pasa por alto y sigue la secuencia.
Otro ejemplo:
insert into libros (titulo,autor) values (null,'Borges');
Aparece un mensaje de error indicando que el campo "titulo" no acepta valores nulos.
Otro ejemplo:
insert into libros (titulo,autor,cantidad) values ('Antologia poética','Borges',null);
Muestra un mensaje de error indicando que el campo "cantidad" no acepta valores nulos.
Atributo default en una columna de una tabla.
create table libros(codigo int unsigned auto_increment, titulo varchar(40) not null, editorial varchar(15),
autor varchar(30) default 'Desconocido', precio decimal(5,2) unsigned default 1.11,
cantidad mediumint unsigned not null, primary key (codigo));
Ingresamos algunos registros omitiendo algunos campos para ver cómo trabaja la cláusula "default".
insert into libros (titulo,autor,editorial,precio,cantidad) values('Java en 10 minutos','Juan Pereyra','Paidos',25.7,100);
Como no ingresamos valor para el campo "codigo", se insertará el valor por defecto implícito, como "codigo" es un
campo "auto_increment", el valor por defecto es el siguiente de la secuencia.
Si omitimos el valor correspondiente al título:
insert into libros (autor,editorial,precio,cantidad) values('Juan Perez','Planeta',28.50,50);
MySQL insertará una cadena vacía, porque el valor por defecto de un campo de tipo caracter definido como "not null" es
ese y para el código, seguirá con la secuencia.
Lo mismo sucede si no ingresamos un valor para la editorial:
insert into libros (titulo,autor,precio,cantidad) values('Aprenda JAVA','Alberto Lopez',55.40,150);
Se almacenará una cadena vacía.
Si omitimos el valor correspondiente al autor:
insert into libros (titulo,editorial,precio,cantidad) values ('El gato con botas','Emece',15.6,150);
Se guardará "Desconocido" ya que éste es el valor por defecto que explicitamos al definir el campo.
Si omitimos el valor correspondiente al precio:
insert into libros (titulo,autor,editorial,cantidad) values ('El aleph','Borges','Emece',200);
Se guardará "1.11" ya que éste es el valor por defecto que explicitamos al definir el campo.
Si omitimos el valor correspondiente a la cantidad:
insert into libros (titulo,autor,editorial,precio) values('Alicia a traves del espejo','Lewis Carroll', 'Emece',34.5);
El valor que se almacenará será 0, porque con la cláusula "default" establecimos este valor por defecto para este campo.
También podemos usar "default" para dar el valor por defecto a los campos en sentencias "insert", por ejemplo:
insert into libros (titulo,autor,editorial,precio,cantidad) values ('El gato con botas',default,'Planeta',default,100);
Atributo zerofill en una columna de una tabla.
Creamos la tabla:
create table libros(codigo int(6) zerofill auto_increment, titulo varchar(40) not null, autor varchar(30),
editorial varchar(15), precio decimal(5,2) unsigned, cantidad smallint zerofill, primary key (codigo));
Visualizamos la estructura de la tabla:

describe libros;
Vemos que en la columna "Type" se muestra el atributo "zerofill" en los campos en los cuales lo especificamos.
Ingresemos algunos registros:
insert into libros (titulo,autor,editorial,precio,cantidad) values('Martin Fierro','Jose Hernandez','Planeta',34.5,200);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Aprenda PHP','Mario Molina','Emece',45.7,50);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Cervantes y el quijote','Borges','Paidos',23,40);
Veamos cómo se guardaron los datos:
Los valores de código están rellenados a la izquierda con ceros; también los del campo "cantidad".
Probemos ingresar un valor para código saltando la secuencia:
insert into libros (codigo,titulo,autor,editorial,precio,cantidad) values('545','El aleph', 'Borges', 'Emece',33,20);
Veamos cómo lo guardó:
Ingresemos un valor negativo para los campos definidos "zerofill":
insert into libros (codigo,titulo,autor,editorial,precio,cantidad) values(-400, 'Matemática de pichurrios', 'Paenza',
'Paidos',15.2,-100);
Veamos lo que sucedió:
Como los valores son inválidos, almacena los valores por defecto según el tipo; para el campo "auto_increment" sigue la
secuencia y para el campo "cantidad" guarda "00000".
Columnas calculadas.
Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, cantidad smallint unsigned, primary key (codigo));

insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Planeta',15,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Martin Fierro','Jose Hernandez','Emece',22.20,200);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Antologia poetica','Borges','Planeta',40,150);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Cervantes y el quijote','Borges','Paidos',36.40,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Manual de PHP', 'J.C. Paez', 'Paidos',30.80,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Harry Potter y la piedra filosofal','J.K.
Rowling','Paidos',45.00,500);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Harry Potter y la cámara secreta','J.K.
insert into libros (titulo,autor,editorial,precio,cantidad) values('Alicia en el pais de las maravillas','Lewis
Carroll','Paidos',null,50);
Para obtener el monto total en dinero de un título podemos multiplicar el precio por la cantidad, por cada título, MySQL
realiza el cálculo y lo incluye en una columna extra en la salida:
select titulo, precio,cantidad,precio*cantidad from libros;
Para saber el precio de cada libro con un 10% de descuento podemos incluir en la sentencia los siguientes cálculos:
select titulo, precio,precio*0.1,precio-(precio*0.1) from libros;
Funciones para el manejo de cadenas.
Eliminamos la tabla si existe.
Creamos la tabla "libros" con la siguiente estructura:
editorial varchar (20), precio decimal(5,2) unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio) values('El alehp','Borges','Paidos',33.4);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las Ratas','M. Santos','Planeta',16);
Usamos la función "concat_ws()":
select concat_ws('-',titulo,autor) from libros;
La salida muestra una sola columna en la cual se concatenan, con el separador "-", los distintos campos especificados.
Usamos la función "left()":
select left(titulo,15) from libros;
La salida muestra los títulos con los primeros 15 caracteres.
Empleamos la función "insert()":
select titulo,insert(editorial,1,0,'edit. ') from libros;
Retorna el nombre de las editoriales agregando al inicio la cadena "Edit. ".
Usamos las funciones "lower()" y "upper()":
select lower(titulo), upper(editorial) from libros;
Funciones matemáticas.

insert into libros (titulo,autor,editorial,precio) values('El alehp','Borges','Paidos',33.4);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las Ratas,'M. Santos,'Planeta',16.3);
insert into libros (titulo,autor,editorial,precio) values('Alicia a traves del espejo','L. Carroll','Planeta',18.8);
Usamos la función "ceiling(x)":
select titulo, ceiling(precio),floor(precio) from libros;
Usamos la función "round(x)":
select titulo, round(precio) from libros;
Empleamos la función "truncate(x,d)":
select titulo,truncate(precio,1) from libros;
Funciones para el uso de fecha y hora.
Una pequeña biblioteca de barrio registra los préstamos de sus libros en una tabla llamada "prestamos". En ella almacena
la siguiente información:
-título del libro,
-documento de identidad del socio a quien se le presta el libro,
-fecha de préstamo,
-fecha de devolución del libro,
-devuelto: si el libro ha sido o no devuelto.
Eliminamos la tabla "prestamos" si existe:
drop table if exists prestamos;
Creamos la tabla:
create table prestamos(titulo varchar(40) not null, documento char(8) not null, fechaprestamo date not null,
fechadevolucion date, devuelto char(1) default 'n');
Los libros se prestan por 5 días.

Ingresamos un registro con los 3 primeros datos y calculamos con una función la fecha de devolución:
insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('Manual de 1 grado','23456789','2006-
08-10',date_add('2006-08-10', interval 5 day));
Con un "select" Vemos cómo quedó almacenado el registro ingresado anteriormente:
select * from prestamos;
Ingresemos otros registros de la misma manera:
insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('Alicia en el pais de las
maravillas','23456789','2006-08-12',date_add('2006-08-12', interval 5 day));
insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('El aleph','22543987','2006-08-

15',date_add('2006-08-15', interval 5 day));
insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('Manual de geografia 5

grado','25555666','2006-08-30',date_add('2006-08-30', interval 5 day));
Ahora utilizaremos la función "current_date" para la fecha de préstamo:

insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('Atlas
universal','24000111',current_date,date_add(current_date, interval 5 day));
Cláusula order by del select.
Creamos la tabla estableciendo como clave primaria y "auto_increment" el campo "codigo":
create table libros(codigo int unsigned auto_increment, titulo varchar(40), autor varchar(30), editorial varchar(15),
precio decimal (5,2) unsigned, primary key (codigo));
Visualizamos su estructura:
describe libros;
insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Planeta',15.50);
insert into libros (titulo,autor,editorial,precio) values('Martin Fierro','Jose Hernandez','Emece',22.90);
insert into libros (titulo,autor,editorial,precio) values('Martin Fierro','Jose Hernandez','Planeta',39);
insert into libros (titulo,autor,editorial,precio) values('Aprenda PHP','Mario Molina','Emece',19.50);
insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Borges','Paidos',35.40);
insert into libros (titulo,autor,editorial,precio) values('Matemática estas ahi', 'Paenza', 'Paidos',19);
Recuperamos los registros de la tabla "libros" ordenados por el título:
select codigo,titulo,autor,editorial,precio from libros
order by titulo;
Aparecen los registros ordenados alfabéticamente por el campo especificado.
Ordenamos por "precio", colocando el número de orden del campo (5):
select codigo,titulo,autor,editorial,precio from libros order by 5;
Ordenamos los libros por 2 campos, "titulo" y "editorial":
select codigo,titulo,autor,editorial,precio from libros order by titulo, editorial;
Ahora los ordenamos en distintos sentidos, por "titulo" en sentido ascendente y "editorial" en sentido descendente:
select codigo,titulo,autor,editorial,precio from libros order by titulo asc, editorial desc;
Operadores Lógicos (and - or - not)
Eliminamos la tabla, si existe.
precio decimal(5,2), primary key(codigo));

insert into libros (titulo,autor,editorial,precio) values('Cervantes y el Quijote','Borges','Paidos',35.40);
insert into libros (titulo,autor,editorial,precio) values('Matemática de pichurrios', 'Paenza', 'Paidos',19);
Vamos a recuperar registros estableciendo 2 condiciones, necesitamos los operadores lógicos.
Para recuperar todos los registros cuyo autor sea igual a "Borges" y cuyo precio no supere los 20 pesos, tecleamos:
select * from libros where autor='Borges' and precio<=20;
Muestra un registro, porque sólo uno cumple con ambas condiciones.

Seleccionamos los libros cuyo autor sea "Paenza" y/o cuya editorial sea "Planeta":
select * from libros where autor='Paenza' or editorial='Planeta';
Muestra 3 registros, 1 de ellos cumple con la primera condición, 1 con la segunda y 1 con ambas.
Queremos ver los libros cuyo autor sea "Borges" o cuya editorial sea "Planeta":
select * from libros where (autor='Borges') xor (editorial='Planeta');
Muestra 2 registros, 1 cumple con la primera condición y 1 con la segunda. Los registros que cumplen con ambas
condiciones no fueron seleccionados porque usamos el operador "xor".
Establecemos la condición que la editorial sea igual a "Planeta", y recuperamos con un "select" los libros que no cumplan
la condición:
select * from libros where not (editorial='Planeta');
Muestra 4 registros que NO cumplen con la condición.
Los paréntesis sirven para establecer el orden de prioridad de evaluación de las condiciones.
Analicemos los siguientes ejemplos, estas sentencias devuelven resultados distintos:
select * from libros where (autor='Borges') or (editorial='Paidos' and precio<20);
select * from libros where (autor='Borges' or editorial='Paidos') and (precio<20);
El primer caso selecciona primero libros de "Paidos" con precio<20 y también los de "Borges", sin considerar el precio.
El segundo caso selecciona los libros de "Borges" y/o "Paidos", si tienen precio<20.
El libro con código 5, no aparece en la segunda consulta porque el precio no es <20; si en la primera porque la condición
referida al precio afecta a los libros de "Paidos".
Otros operadores relacionales (between - in)
precio decimal(5,2) unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio) values('Matemática estas ahi', 'Paenza', 'Paidos',19);
Recuperamos los registros que tienen precio mayor o igual a 20 y menor o igual a 40, usando 2 condiciones:
select * from libros where precio>=20 and precio<=40;
Ahora usamos "between" y confirmamos que la salida es la misma:

select * from libros where precio between 20 and 40;
Recuperamos los libros cuyo autor es 'Paenza' o 'Borges' usando 2 condiciones:
select * from libros where autor='Borges' or autor='Paenza';
Usamos "in" y obtenemos el mismo resultado:
select * from libros where autor in('Borges','Paenza');
Seleccionamos los libros cuyo autor no es 'Paenza' ni 'Borges' usamos:

select * from libros where autor<>'Borges' and autor<>'Paenza';
Realizamos la misma consulta, pero esta vez con "in" :

select * from libros where autor not in ('Borges','Paenza');
Búsqueda de patrones (like y not like)
create table libros(codigo int unsigned auto_increment, titulo varchar(40), autor varchar(30),
editorial varchar(15), precio decimal(5,2) unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio) values('Antologia poetica','J.L. Borges','Planeta',39);
insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Bioy Casare- J.L. Borges','Paidos',35.40);
insert into libros (titulo,autor,editorial,precio) values('Manual de PHP', 'J.C. Paez', 'Paidos',19);
insert into libros (titulo,autor,editorial,precio) values('Harry Potter y la piedra filosofal','J.K. Rowling','Paidos',45.00);
insert into libros (titulo,autor,editorial,precio) values('Harry Potter y la camara secreta','J.K. Rowling','Paidos',46.00);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos',36.00);
Recuperamos los libros cuyo autor sea igual a la cadena "Borges":

select * from libros where autor='Borges';
Nos devuelve 1 registro.
Recuperamos todos los registros cuyo autor contenga la cadena "Borges":

select * from libros where autor like '%Borges%';
El resultado nos devuelve 3 registros.
Para seleccionar todos los libros que comiencen con "A":

select * from libros where titulo like 'A%';
Para seleccionar todos los libros que no comiencen con "A":

select * from libros where titulo not like 'A%';
Queremos los libros de "Lewis Carroll" y no recordamos si se escribe "Carroll" o "Carrolt", entonces tecleamos:
select * from libros where autor like '%Carrol_';
Buscamos todos los libros de "Harry Potter":

select * from libros where titulo like '%Harry Potter%';
Todos los libros sobre "PHP":

select * from libros where titulo like '%PHP%';
Búsqueda de patrones (regexp)

Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio) values('Antologia poetica','J.L. Borges','Planeta',39);
insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Bioy Casare- J.L. Borges','Paidos',35.40);
insert into libros (titulo,autor,editorial,precio) values('Manual de PHP', 'J.C. Paez', 'Paidos',19);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos',36.00);
Para buscar libros cuyos títulos contengan la cadena "Ma" usamos:

select titulo from libros where titulo regexp 'Ma';
Retorna 4 registros.
Para buscar los registros cuyos autores tienen al menos una "h" o una "k" o una "w" tecleamos:
select titulo,autor from libros where autor regexp '[hkw]';
4 registros devueltos.
Para buscar los libros cuyos autores no tienen ni "h" o una "k" o una "w" tecleamos:
select titulo,autor from libros where autor not regexp '[hkw]';
Selecciona 5 registros.
Para buscar los autores que tienen por lo menos una de las letras de la "a" hasta la "d", es decir, "a,b,c,d", usamos:
select autor from libros where autor regexp '[a-d]';
Para ver los títulos que comienzan con "A" tecleamos:

select titulo from libros where titulo regexp '^A';
Devuelve 3 registros.
Para ver los títulos que terminan en "HP" usamos:

select titulo from libros where titulo regexp 'HP$';
Para buscar títulos que contengan una "a" luego un caracter cualquiera y luego una "e" utilizamos la siguiente sentencia:
select titulo from libros where titulo regexp 'a.e';
Podemos mostrar los títulos que contienen una "a" seguida de 2 caracteres y luego una "e":
select titulo from libros where titulo regexp 'a..e';
Para buscar autores que tengan 6 caracteres exactamente usamos:

select autor from libros where autor regexp '^......$';
Devuelve 1 registro.
Para buscar autores que tengan al menos 6 caracteres usamos:

select autor from libros where autor regexp '......';
Para buscar títulos que contengan 2 letras "a" usamos:

select titulo from libros where titulo regexp 'a.*a';
Contar registros (count)
Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, cantidad mediumint unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio,cantidad) values('Antologia poetica','J.L. Borges','Planeta',40,150);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Cervantes y el quijote','Bioy Casares- J.L.
Borges','Paidos',36.40,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Harry Potter y la camara secreta','J.K.
Para averiguar la cantidad de registros de la tabla "libros" usamos la función "count(*)":

select count(*) from libros;
Retorna 9.
Para saber la cantidad de libros de la editorial "Planeta" tecleamos:

select count(*) from libros where editorial='Planeta';
Para averiguar la cantidad de libros que contienen la cadena "Borges" tecleamos:

select count(*) from libros where autor like '%Borges%';
Nos retorna 3.
Para obtener la cantidad de libros cuyo precio no tiene valor nulo usamos la función "count()" y dentro del paréntesis
colocamos el nombre del campo correspondiente:
select count(precio) from libros;
Retorna 8, ya que uno de los libros tiene precio nulo y no se contabilizó.
Funciones de agrupamiento (count - max - min - sum - avg)

Trabajamos con la tabla "libros" que registra la información de los libros que vende una librería.
Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, cantidad mediumint unsigned, primary key(codigo));
insert into libros (titulo,autor,editorial,precio,cantidad) values('Antologia poetica','J.L. Borges','Planeta',40,150);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Cervantes y el quijote','Bioy Casares- J.L.
Borges','Paidos',36.40,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Harry Potter y la camara secreta','J.K.
Para conocer la suma de las cantidades de libros que tenemos disponibles tecleamos:
select sum(cantidad) from libros;
Retorna 1220; verifique la suma, sumando los valores de todos los registros del campo "cantidad".
Solicitamos la suma de las cantidades de los libros de la editorial "Planeta":

select sum(cantidad) from libros where editorial ='Planeta';
Retorna 250; verifique el total sumando las cantidades de los libros cuya editorial sea "Planeta".
Si queremos saber cuál es el mayor precio de los libros usamos:

select max(precio) from libros;
Devuelve 46.
Verifiquemos lo anterior realizando una consulta ordenada por precio de forma descendente:
select * from libros order by precio desc;
Para obtener el valor mínimo de los libros de "Rowling" utilizamos la siguiente sentencia:
select min(precio) from libros where autor like '%Rowling%';
Retorna 45.
Verifiquemos el resultado realizando una consulta "select" con la condición anterior ordenada por precio:
select * from libros where autor like '%Rowling%' order by 5;
Solicitamos el promedio del precio de los libros que tratan sobre "PHP":
select avg(precio) from libros where titulo like '%PHP%';
Retorna 24.50...
Verifiquemos el resultado seleccionado los libros de "PHP" y calculando el promedio manualmente:

select * from libros where titulo like '%PHP%';
Recuerde que no debe haber espacio entre el nombre de la función y el paréntesis. Pruebe las siguientes sentencias:
select count(*) from libros;
select count (*) from libros;
La segunda no se ejecuta, aparece un mensaje de error.
Agrupar registros (group by)
Un comercio que tiene un stand en una feria registra en una tabla llamada "visitantes" algunos datos de las personas que
visitan o compran en su stand para luego enviarle publicidad de sus productos.
drop table if exists visitantes;
Creamos la tabla:
create table visitantes(nombre varchar(30), edad tinyint unsigned, sexo char(1), domicilio varchar(30),
ciudad varchar(20), telefono varchar(11), montocompra decimal (6,2) unsigned);

insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Susana Molina', 28,'f','Colon
123','Cordoba',null,45.50);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Marcela
Mercado',36,'f','Avellaneda 345','Cordoba','4545454',0);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Alberto Garcia',35,'m','Gral.
Paz 123','Alta Gracia','03547123456',25);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Teresa Garcia',33,'f','Gral. Paz
123','Alta Gracia','03547123456',0);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Roberto
Perez',45,'m','Urquiza 335','Cordoba','4123456',33.20);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Marina Torres',22,'f','Colon
222','Villa Dolores','03544112233',25);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Julieta Gomez',24,'f','San
Martin 333','Alta Gracia','03547121212',53.50);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Roxana
Lopez',20,'f','Triunvirato 345','Alta Gracia',null,0);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Liliana Garcia',50,'f','Paso
999','Cordoba','4588778',48);
insert into visitantes (nombre,edad, sexo,domicilio,ciudad,telefono,montocompra) values ('Juan
Torres',43,'m','Sarmiento 876','Cordoba','4988778',15.30);
Para saber la cantidad de visitantes que tenemos de cada ciudad tecleamos:

select ciudad, count(*) from visitantes group by ciudad;
El resultado muestra los nombres de las distintas ciudades y la cantidad de registros de cada una.
Necesitamos conocer la cantidad visitantes con teléfono no nulo, de cada ciudad:
select ciudad, count(telefono)from visitantesgroup by ciudad;
Queremos conocer el total de las compras agrupadas por sexo:

select sexo, sum(montocompra) from visitantes group by sexo;
Para obtener el máximo y mínimo valor de compra agrupados por sexo:

select sexo, max(montocompra) from visitantes group by sexo;
select sexo, min(montocompra) from visitantes group by sexo;
Se pueden simplificar las 2 sentencias anteriores en una sola sentencia, ya que usan el mismo "group by":
select sexo, max(montocompra), min(montocompra) from visitantes group by sexo;
Queremos saber el promedio del valor de compra agrupados por ciudad:

select ciudad, avg(montocompra) from visitantes group by ciudad;
Contamos los registros y agrupamos por 2 campos, "ciudad" y "sexo":

select ciudad, sexo, count(*) from visitantes group by ciudad,sexo;

Limitamos la consulta, no incluimos los visitantes de "Cordoba", contamos y agrupar por ciudad:
select ciudad, count(*) from visitantes where ciudad<>'Cordoba' group by ciudad;
Usando la palabra clave "desc" obtenemos la salida ordenada en forma descendente:

select ciudad, count(*) from visitantes group by ciudad desc;
Selección de un grupo de registros (having)
Trabajamos con la tabla "libros" que registra los datos de una librería.
Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, primary key (codigo));
Agregamos algunos registros:

insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Planeta',15);
insert into libros (titulo,autor,editorial,precio) values('Antologia poetica','Borges','Planeta',40);
insert into libros (titulo,autor,editorial,precio) values('Manual de PHP', 'J.C. Paez', 'Paidos',30.80);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos',null);
Queremos averiguar la cantidad de libros agrupados por editorial:

select editorial, count(*) from libros group by editorial;
Queremos conocer la cantidad de libros agrupados por editorial pero considerando sólo los que devuelvan un valor
mayor a 2, tecleamos:
select editorial, count(*) from libros group by editorial having count(*)>2;
Necesitamos el promedio de los precios de los libros agrupados por editorial:

select editorial, avg(precio) from libros group by editorial;
Ahora, sólo queremos aquellos cuyo promedio supere los 25 pesos:

select editorial, avg(precio) from libros group by editorial having avg(precio)>25;
Queremos contar los registros agrupados por editorial sin tener en cuenta a la editorial "Planeta". Tecleamos y
analicemos las siguientes sentencias:
select editorial, count(*) from libros where editorial<>'Planeta' group by editorial;
select editorial, count(*) from libros group by editorial having editorial<>'Planeta';
Note que ambas retornan la misma salida. La primera, selecciona los registros sin considerar los de la editorial "Planeta" y
luego los agrupa para contarlos. La segunda, selecciona todos los registros, los agrupa para contarlos y finalmente
rechaza la cuenta correspondiente a la editorial "Planeta". Recuerde no confundir las cláusulas "where" y "having"; la
primera establece condiciones para la selección de registros individuales, la segunda establece condiciones para la
selección de filas de una salida "group by".
Probamos combinar condiciones "where" y "having". Queremos la cantidad de libros, sin tener en cuenta los que tienen
precio nulo, agrupados por editorial, rechazando los de editorial "Planeta":
select editorial, count(*) from libros where precio is not null group by editorial having editorial<>'Planeta';
Para obtener el promedio de los precios agrupados por editorial, de aquellas editoriales que tienen más de 2 libros
tecleamos:
select editorial, avg(precio) from libros group by editorial having count(*) > 2;
Para encontrar el mayor valor de los libros agrupados por editorial y luego seleccionar las filas que tengan un valor mayor
o igual a 30 usamos:
select editorial, max(precio) from libros group by editorial having max(precio)>=30;
Para esta misma sentencia podemos utilizar un "alias" para hacer referencia a la columna de la expresión:
select editorial, max(precio) as 'mayor' from libros group by editorial having mayor>=30;
Registros duplicados (distinct)
Creamos la tabla:

insert into libros (titulo,autor,editorial,precio) values('Martin Fierro','Jose Hernandez','Planeta',42.20);
insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Bioy Casares- Borges','Paidos',36.40);
insert into libros (titulo,autor,editorial,precio) values('Manual de PHP', null, 'Paidos',30.80);
insert into libros (titulo,autor,editorial,precio) values('Harry Potter y la piedra filosofal','J.K. Rowling','Planeta',45.00);
insert into libros (titulo,autor,editorial,precio) values('Harry Potter y la camara secreta','J.K. Rowling','Planeta',46.00);
insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',12.10);-
Para obtener la lista de autores sin repetición usamos "distinct":

select distinct autor from libros;
Si sólo queremos la lista de autores conocidos, es decir, no queremos incluir "null" en la lista, utilizamos la sentencia
siguiente:
select distinct autor from libros where autor is not null;
Para contar los distintos autores, sin considerar el valor "null" usamos:
select count(distinct autor) from libros;
Note que si contamos los autores sin "distinct", no incluirá los valores "null" pero si los repetidos:
select count(autor) from libros;
Esta sentencia cuenta los registros que tienen autor.

Para obtener los nombres de las editoriales usamos:
select editorial from libros;
Para una consulta en la cual los nombres no se repitan tecleamos:

select distinct editorial from libros;

Podemos saber la cantidad de editoriales distintas usamos:
select count(distinct editorial) from libros;
Queremos conocer los distintos autores de la editorial "Planeta":

select distinct autor from libros where editorial='Planeta';
Para contar la cantidad de autores distintos de cada editorial podemos usar "distinct" y "group by":
select editorial,count(distinct autor) from libros group by editorial;
Para mostrar los títulos y editoriales de los libros sin repetir títulos ni editoriales, usamos:
select distinct titulo,editorial from libros order by titulo;
La consulta nos devuelve registros con títulos iguales pero con editorial diferente, cada registro es distinto.
Alias
SQL permite renombrar temporalmente las tablas o columnas al momento de efectuar una consulta. Esto se lleva a cabo
con un Alias asociado al objeto al escribir la sentencia SELECT.

Creamos la tabla:
editorial varchar(15), precio decimal(5,2), primary key (codigo));

Colocamos un alias "Libros de Borges" para la expresión "count(*)" para tener una salida más clara:
select count(*) as 'Libros de Borges' from libros where autor like '%Borges%';
Colocamos el alias "Nombre de editorial" para el campo "editorial":

select editorial as 'Nombre de editorial' from libros group by 'Nombre de editorial';
Colocamos un alias para la cantidad calculada con "count()" y la empleamos en la cláusula "order by":
select editorial, count(*) as cantidad from libros group by editorial order by cantidad;
Colocamos un alias para el cálculo de la cantidad y lo utilizamos con "having":

select editorial, count(*) as cantidad from libros group by editorial having cantidad>2;
Clave primaria compuesta.
Una playa de estacionamiento guarda cada día los datos de los vehículos que ingresan a la playa en una tabla llamada
"vehiculos".
drop table if exists vehiculos;
Para crear una tabla con clave primaria compuesta usamos la siguiente sintaxis:
create table vehiculos(patente char(6) not null, tipo char(4), horallegada time not null, horasalida time,
primary key(patente,horallegada));
Veamos la estructura de la tabla:

describe vehiculos;
Vemos que en la columna "key", en ambos campos aparece "PRI", porque ambos son clave primaria.
Ingresemos los siguientes registros:
insert into vehiculos (patente,tipo,horallegada,horasalida) values('ACD123','auto','8:30','9:40');
insert into vehiculos (patente,tipo,horallegada,horasalida) values('AKL098','auto','8:45','11:10');
insert into vehiculos (patente,tipo,horallegada,horasalida) values('HGF123','auto','9:30','11:40');
insert into vehiculos (patente,tipo,horallegada,horasalida) values('DRT123','auto','15:30',null);
insert into vehiculos (patente,tipo,horallegada,horasalida) values('FRT545','moto','19:45',null);
insert into vehiculos (patente,tipo,horallegada,horasalida) values('GTY154','auto','20:30','21:00');
Intente ingresar un vehículo con clave primaria repetida:

insert into vehiculos (patente,tipo,horallegada,horasalida) values('ACD123','auto','16:00',null);
Aparece un mensaje de error indicando que la clave está duplicada.

Si ingresamos un registro con patente repetida, no hay problemas, siempre que la hora de ingreso sea diferente, sino,
repetimos el valor de la clave:
insert into vehiculos (patente,tipo,horallegada,horasalida) values('ACD123','auto','16:00',null);
Si ingresamos un registro con hora de ingreso repetida, no hay problemas, siempre que la patente sea diferente, sino,
repetimos el valor de la clave:
insert into vehiculos (patente,tipo,horallegada,horasalida) values('ADF123','moto','8:30','10:00');
Intente eliminar el campo "horallegada":

alter table vehiculos drop horallegada;
No se puede porque quedarían registros con clave repetida.
Elimine los registros con patente "ACD123":

delete from vehiculos where patente='ACD123';
Intente nuevamente eliminar el campo "horallegada":

alter table vehiculos drop horallegada;
Ahora si lo permite.
Vea la estructura de la tabla para ver cómo quedó la clave primaria:

describe vehiculos;
Indice de tipo primary.
Creamos la tabla definiendo el campo "codigo" como clave primaria:
editorial varchar(15), primary key(codigo));
Veamos la estructura de los índices de la tabla:

show index from libros;

Muestra la siguiente información:
Table Non_unique Key_name Column_name Null
______________________________________________________________
libros 0 PRIMARY código
Aparece el índice PRIMARY creado automáticamente al definir el campo "codigo" como clave primaria.
La columna "Table" indica a qué tabla pertenece el índice. La columna "Non_unique" indica si los valores del índice son
No únicos, es decir, si hay valores repetidos para ese campo, aquí indica "0" (false), o sea, los valores son únicos. La
columna "Key_name" muestra el nombre del índice. La columna "Column_name" muestra el campo indexado y la
columna "Null" señala si el campo indexado permite valores nulos, cuando los permite aparace "YES", aquí no, así que no
los permite.
Indice común (index)
Creamos la tabla "libros" con 2 índices:
- una clave primaria (codigo),
- un índice común por el campo "editorial",
create table libros(codigo int unsigned auto_increment,titulo varchar(40) not null, autor varchar(30),
editorial varchar(15), primary key(codigo), index i_editorial (editorial));
Analicemos la estructura de los índices:

Analicemos esta información:

Table Non_unique Key_name Column_name Null
______________________________________________________________
libros 0 PRIMARY codigo
libros 1 i_editorial editorial YES
Vemos que la tabla tiene 2 índices, uno de ellos corresponde a la clave primaria (codigo) que se creó automáticamente al
definir el campo "código" como clave primaria; el otro es el que creamos con "index" llamado "i_editorial".
La columna "Table" indica de qué tabla estamos visualizando los índices.
La columna "Non_unique" indica si los valores son "no únicos"; para el índice creado por la clave primaria indica "false"
(0), significa que SON únicos, no hay valores repetidos para ese campo (recuerde lo aprendido sobre clave primaria); para
el índice "i_editorial" indica "true" (1), es decir, NO son únicos, hay valores repetidos.
La columna "Key_name" muestra el nombre del índice; para el campo correspondiente a la clave primaria tomó el
nombre "PRIMARY"; el otro nombre es el que le dimos nosotros al definirlo (i_editorial).
La columna "Column_name" muestra el nombre del campo por el que está ordenado el índice, "codigo" para el índice
"PRIMARY" y "editorial" para nuestro índice.
La columna "Null" indica si permite valores nulos; el índice "PRIMARY" no los permite (recuerde lo aprendido sobre clave
primaria), el índice "i_editorial" si los permite (aparece YES).
Las demás columnas no serán explicadas por el momento.
Se pueden crear índices por varios campos:
editorial varchar(15), primary key(codigo), index i_tituloeditorial (titulo,editorial));
Note que los campos se listan entre paréntesis separados por comas.
Veamos la información de los índices:


Table Non_unique Key_name Seq_in_index Column_name Null
____________________________________________________________________________
libros 0 PRIMARY 1 codigo
libros 1 i_tituloeditorial 1 titulo
libros 1 i_tituloeditorial 2 editorial YES
Aparecen 3 filas.
La tabla tiene 2 índices (2 filas corresponden al mismo índice): uno de ellos corresponde a la clave primaria (codigo) que
se creó automáticamente al definir el campo "código" como clave primaria; el otro es el que creamos con "index"
llamado "i_tituloeditorial".
El índice "PRIMARY", no tiene valores repetidos (No es "No único"); el índice "i_tituloeditorial" es "No único", o sea, hay
valores repetidos.
La columna "Seq_in_index" y "Column_name" muestran la secuencia de la indexación para cada campo. En el índice
"i_tituloeditorial" y el campo "titulo" muestra 1 y para el campo "editorial" muestra 2, esto significa que está indexado en
ese orden.
La columna "Null" indica si el campo permite valores nulos; el índice "PRIMARY" no los permite; el campo "titulo" del
índice "i_tituloeditorial" no los permite (recuerde que lo definimos "not null"), el campo "editorial" si los permite (YES).
Indice único (unique)
Trabajamos con nuestra tabla "libros" de una librería.
Crearemos dos índices únicos, uno por un solo campo y otro multicolumna:
editorial varchar(15), unique i_codigo (codigo), unique i_tituloeditorial (titulo,editorial));


Table Non_unique Key_name Seq_in_index Column_name Null
____________________________________________________________________________
libros 0 i_codigo 1 codigo
libros 0 i_tituloeditorial 1 titulo
libros 0 i_tituloeditorial 2 editorial YES
Aparecen 3 filas.
La tabla tiene 2 índices (2 filas corresponden al mismo índice).

Ambos índices son únicos, o sea, no permiten valores repetidos, esto se indica en la columna "Non_unique". La columna
"Key_name" indica el nombre de los índices. La columna "Seq_in_index" y "Column_name" muestran la secuencia de la
indexación para cada campo del índice "i_tituloeditorial". En el índice "i_tituloeditorial" y el campo "titulo" muestra 1 y
para el campo "editorial" muestra 2, esto significa que está indexado en ese orden.
La columna "Null" indica si el campo permite valores nulos; el índice "i_codigo" no los permite; el campo "titulo" del
índice "i_tituloeditorial" no los permite (recuerde que lo definimos "not null"), el campo "editorial" si los permite (YES).
Borrar indice (drop index)
Creamos dos índices, uno común, por un solo campo y otro único multicolumna:
editorial varchar(15), primary key (codigo), index i_editorial (editorial), unique i_tituloeditorial (titulo,editorial));

Vemos que tenemos tres índices, uno creado automáticamente al definir la clave primaria (PRIMARY).
Para eliminar los índices creados con "index" y con "unique" usamos "drop index".
Eliminamos el índice "i_editorial":
drop index i_editorial on libros;
Eliminamos el índice "i_tituloeditorial":

drop index i_tituloeditorial on libros;
Si tecleamos:
Vemos que solamente queda el índice creado al definir la clave primaria. Este tipo de índice no puede borrarse con "drop
index".
Creación de índices a tablas existentes (create index)
Creamos la tabla con clave primaria:
editorial varchar(15), primary key (codigo));

Vemos que tenemos el índice creado al definir la clave primaria (PRIMARY).

Para agregar un índice común a la tabla "libros" tecleamos:
create index i_editorial on libros (editorial);

Aparecen 2, "PRIMARY" y "i_editorial".
Para agregar un índice único a la tabla "libros" tecleamos:

create unique index i_tituloeditorial on libros (titulo,editorial);

Aparecen 3, "PRIMARY", "i_editorial" y "i_tituloeditorial".
Cláusula limit del comando select.
Creamos la tabla:
create table libros(codigo int unsigned auto_increment,titulo varchar(20) not null,autor varchar(30),

Para recuperar 4 libros desde el registro cero tecleamos:

select * from libros limit 0,4;
Para recuperar 4 libros a partir del registro 5:

Si colocamos un solo argumento, éste indica el máximo número de registros a retornar, comenzando desde 0:
select * from libros limit 8;
Muestra los primeros 8 registros.
Para recuperar los registros desde cierto número hasta el último, colocamos un número grande para el segundo
argumento:
Ordenamos por precio y combinamos "limit" con el comando "delete" para eliminar los 2 registros con precio más bajo:
delete from libros order by precio limit 2;
se eliminaron los 2 registros con precio más bajo.
También podemos emplear la cláusula "limit" para eliminar registros duplicados. Por ejemplo: almacenamos el libro "El
aleph" de "Borges" de la editorial "Planeta":
Pero nos equivocamos y volvemos a ingresar el mismo libro, del mismo autor y editorial 2 veces más (es un error que no
controla MySQL):
Para eliminar el libro duplicado y que sólo quede un registro de él, Vemos cuántos tenemos:
select * from libros where titulo='El aleph" and autor='Borges' and editorial='Planeta';
Nos devuelve 3 registros.
Luego eliminamos con "limit" la cantidad sobrante (tenemos 3 y queremos sólo 1):
delete from libros where titulo='El aleph" and autor='Borges' and editorial='Planeta' limit 2;
Un mensaje nos muestra la cantidad de registros eliminados.
Veamos cuántos hay ahora:

select * from libros where titulo='El aleph" and autor='Borges' and editorial='Planeta';
Sólo queda 1.
Recuperación de registros en forma aleatoria (rand)
Trabajamos con la tabla "libros" en el cual una librería guarda los datos de sus libros.
Eliminamos la tabla "libros" si existe:
Creamos la tabla:
Agregamos varios registros:

insert into libros values(1,'El aleph','Borges','Planeta',23.5);
insert into libros values(2,'Cervantes y el quijote','Borges','Paidos',33.5);
insert into libros values(3,'Alicia a traves del espejo','Lewis Carroll','Planeta',15);
insert into libros values(4,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta',18);
insert into libros values(5,'Martin Fierro','Jose Hernandez','Planeta',34.6);
insert into libros values(6,'Martin Fierro','Jose Hernandez','Emece',45);
insert into libros values(7,'Aprenda PHP','Mario Molina','Planeta',55);
insert into libros values(8,'Java en 10 minutos','Mario Molina','Planeta',45);
insert into libros values(9,'Matematica estas ahi','Paenza','Planeta',12.5);
La librería quiere tomar 5 libros al azar para donarlos a una institución.

Para recuperar de la tabla "libros" registros aleatorios utilizamos la función "rand()" combinada con "order by" y "limit":
select * from libros order by rand() limit 5;
Nos devuelve los datos de 5 libros tomados al azar de la tabla "libros". Podemos ejecutar la sentencia anterior varias
veces seguidas y veremos que los registros recuperados son diferentes en cada ocasión:
Remplazar registros (replace)
Eliminamos la tabla si existe:
Creamos la tabla:
create table libros(codigo int unsigned, titulo varchar(40), autor varchar(30), editorial varchar(20), precio decimal(5,2)
unsigned, primary key(codigo));

insert into libros values (10,'Alicia en el pais de las maravillas','Lewis Carroll','Emece',15.4);
insert into libros values (15,'Aprenda PHP','Mario Molina','Planeta',45.8);
insert into libros values (23,'El aleph','Borges','Planeta',23.0);
Intentemos ingresar un registro con valor de clave repetida (código 23):

insert into libros values(23,'Java en 10 minutos','Mario Molina','Emece',25.5);
Aparece un mensaje de error indicando que hay registros duplicados.
Para reemplazar el registro con clave 23 por el nuevo empleamos "replace":

replace into libros values(23,'Java en 10 minutos','Mario Molina','Emece',25.5);
Aparece un mensaje indicando que se afectaron 2 filas, esto es porque un registro se eliminó y otro se insertó.
Veamos los casos en los cuales "replace" funciona como "insert":

- ingresamos un registro sin valor de código:
replace into libros(titulo,autor,editorial,precio) values('Cervantes y el quijote','Borges','Paidos',28);
Aparece un mensaje indicando que se afectó un solo registro, el ingresado, que se guarda con valor de código 0.
- ingresamos un registro con un valor de código que no existe:
replace into libros values(30,'Matematica estas ahi','Paenza','Paidos',12.8);
Aparece un mensaje indicando que se afectó solo una fila, no hubo reemplazo porque el código no existía antes de la
nueva inserción.
Quitemos la clave primaria:

alter table libros drop primary key;
Ingresamos un registro con valor de código repetido usando "replace":
replace into libros values(10,'Harry Potter ya la piedra filosofal','Hawking','Emece',48);
Aparece un mensaje indicando que se afectó 1 registro (el ingresado), no se reemplazó ninguno y ahora hay 2 libros con
código 10.
Agregar campos a una tabla (alter table - add)
Trabajamos con la tabla "libros".
Eliminamos la tabla "libros" si existe.
Para agregar el campo "cantidad" de tipo smallint unsigned not null, tecleamos:
alter table libros add cantidad smallint unsigned not null;
Vemos su nueva estructura:

describe libros;
Ahora la tabla tiene un nuevo campo, el ingresado con "alter table".

Si mostramos todos los registros, Vemos que los valores para el nuevo campo se cargaron con su valor por defecto, "0"
en el ejemplo porque el campo agregado es de tipo numérico y declarado "not null".
Agreguemos otro campo a la tabla:
alter table libros add edicion date;
Vemos la nueva estructura:

describe libros;
Si mostramos todos los registros, Vemos que los valores para el nuevo campo se cargaron con su valor por defecto, "null"
en este caso.
Si intentamos agregar un campo existente aparece un mensaje de error indicando que la columna existe y la acción no se
realiza:
alter table libros add precio int;
Eliminar campos de una tabla (alter table - drop)
editorial varchar (20), edicion date, precio decimal(5,2) unsigned, cantidad int unsigned, primary key(codigo));
Para eliminar el campo "edicion" tecleamos:

alter table libros drop edicion;
Si visualizamos la estructura de la tabla con "describe", Vemos que la columna "edicion" se ha eliminado:
describe libros;
Si intentamos borrar un campo inexistente aparece un mensaje de error y la acción no se realiza:

alter table libros drop edicion;

Para eliminar 2 campos en una misma sentencia tecleamos:
alter table libros drop editorial, drop cantidad;
Elimine el campo clave:

alter table libros drop codigo;
Modificar campos de una tabla (alter table - modify)
create table libros(codigo int unsigned, titulo varchar(30) not null, autor varchar(30), editorial varchar (20),
precio decimal(5,2) unsigned, cantidad int unsigned);
Para modificar el tipo del campo "cantidad" por "smallint unsigned", tecleamos:
alter table libros modify cantidad smallint unsigned;
Si visualizamos la estructura de la tabla:

describe libros;
Vemos la nueva definición del campo "cantidad".
Para modificar el tipo del campo "titulo" para poder almacenar una longitud de 40 caracteres y que no permita valores
nulos, tecleamos:
alter table libros modify titulo varchar(40) not null;
Visualicemos la estructura de la tabla:

describe libros;
Ahora el campo "titulo" permite 40 caracteres de longitud.

insert into libros (titulo,autor,editorial,precio,cantidad) values ('El aleph','Borges','Planeta',23.5,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Alicia en el pais de las maravillas','Lewis
Carroll','Emece',25,200);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('El gato con botas',null,'Emece',10,500);
insert into libros (titulo,autor,editorial,precio,cantidad) values ('Martin Fierro','Jose Hernandez','Planeta',150,200);
Modificamos el tipo de dato de "autor" a 10 caracteres de longitud:

alter table libros modify autor varchar(10);
Mostramos todos los registros:

Note que los nombres de los autores que tenían más de 10 caracteres se cortaron.
Modificamos el tipo de dato de "autor" para que no permita valores nulos:

alter table libros modify autor varchar(10) not null;

Note que en el campo "autor" del libro "El gato con botas", ahora tiene una cadena vacía, lo habíamos cargado con
"null", pero al redefinir el campo como no nulo, "null" se convirtió en un valor inválido.

El libro "Martín Fierro" tiene un precio de $150; si modificamos el tipo de dato de "precio" a "decimal(4,2), el precio
anterior quedará fuera del rango:
alter table libros modify precio decimal(4,2);

select * from libros,
Note que el valor "150" se convierte en un valor inválido para el tipo, entonces guarda en su lugar, el valor límite más
cercano, "99.99".
Si intentamos definir "auto_increment" un campo que no es clave primaria, aparece un mensaje de error indicando que
el campo debe ser clave primaria:
alter table libros modify codigo int unsigned auto_increment;
La sentencia no se ejecuta.
Cambiar el nombre de un campo de una tabla (alter table - change)
create table libros(codigo int unsigned auto_increment, nombre varchar(30), autor varchar(30), editorial varchar (20),
costo decimal(5,2) unsigned, cantidad int unsigned, primary key(codigo));
Para cambiar el nombre del campo "costo" por "precio", tecleamos:

alter table libros change costo precio decimal (5,2);
Si visualizamos la estructura de la tabla con "describe" Vemos que el nombre del campo se ha modificado.
Con "change" cambiamos el nombre de un campo y también podemos cambiar el tipo y sus modificadores.
Para cambiar el nombre del campo "nombre" por "titulo" y redefinirlo como "not null", tecleamos:
alter table libros change nombre titulo varchar(40) not null;
Si visualizamos la estructura nueva:

describe libros;
Vemos que el campo ahora tiene un nuevo nombre y no permite valores nulos.
Agregar y eliminar la clave primaria (alter table)
create table libros(codigo int unsigned, titulo varchar(40) not null, autor varchar(30), editorial varchar (20),
precio decimal(5,2) unsigned, cantidad smallint unsigned);
Para establecer el campo "codigo" como clave primaria usamos:

alter table libros add primary key (codigo);
Visualicemos la estructura de la tabla:

describe libros;
Ahora el campo "codigo" es clave primaria.
Si intentamos agregar otra clave primaria, aparecerá un mensaje de error porque (recuerde) una tabla solamente puede
tener una clave primaria:
alter table libros add primary key (titulo);

Si queremos que el campo clave sea "auto_increment" debemos modificarlo con:
alter table libros modify codigo int unsigned auto_increment;
Si intentamos eliminar la clave primaria:

La sentencia no se ejecuta porque si existe un campo con este atributo DEBE ser clave primaria.
Primero debemos modificar el campo quitándole dicho atributo:
alter table libros modify codigo int unsigned;
Ahora si podemos eliminar la clave primaria:


describe libros;
Vemos que la tabla ya no tiene clave primaria.
Agregar índices(alter table - add index)
create table libros(codigo int unsigned, titulo varchar(40), autor varchar(30),editorial varchar (20),
Para agregar un índice común por el campo "editorial" tecleamos:

alter table libros add index i_editorial (editorial);
Para agregar un índice único multicolumna por los campos "titulo" y "editorial", tecleamos:
alter table libros add unique index i_tituloeditorial (titulo,editorial);
Visualicemos los índices con:
Aparecen nuestros 2 índices agregados.
Agregar índices(alter table - add index)
create table libros(codigo int unsigned, titulo varchar(40), autor varchar(30), editorial varchar (20),
Para agregar un índice común por el campo "editorial" tecleamos:

alter table libros add index i_editorial (editorial);
Para agregar un índice único multicolumna por los campos "titulo" y "editorial", tecleamos:
alter table libros add unique index i_tituloeditorial (titulo,editorial);
Visualicemos los índices con:

Aparecen nuestros 2 índices agregados.
Borrado de índices (alter table - drop index)
Creamos la tabla "libros", con los siguientes campos e índices:
editorial varchar(15), primary key(codigo), index i_editorial (editorial), unique i_tituloeditorial (titulo,editorial));
Para eliminar el índice común llamado "i_editorial" usamos la siguiente sintaxis:

alter table libros drop index i_editorial;
Para eliminar el índice único llamado "i_tituloeditorial" usamos la misma sintaxis:

alter table libros drop index i_tituloeditorial;
Visualicemos los índices de la tabla:

Vemos que solamente queda el índice "PRIMARY", este índice no se puede eliminar; se elimina automáticamente al
eliminar la clave primaria.
Renombrar tablas (alter table - rename - rename table)
Eliminamos las tablas "aprendices" y "contactos" si existen.
Creamos la tabla "aprendices" con la siguiente estructura:
create table aprendices(nombre varchar(30), domicilio varchar(30), telefono varchar (11));
Para cambiar el nombre de nuestra tabla "aprendices" por "contactos" usamos esta sintaxis:
alter table aprendices rename contactos;
Veamos si existen las tablas "aprendices" y "contactos":
show tables;
La tabla "aprendices" ya no existe, si "contactos".
También podemos cambiar el nombre a una tabla usando la siguiente sintaxis:
rename table contactos to aprendices;
Así cambiamos el nombre de la tabla "contactos" por "aprendices".
Veamos si existen las tablas "aprendices" y "contactos":
show tables;
La tabla "contactos" ya no existe, si "aprendices".
Podemos intercambiar los nombres de dos tablas. Por ejemplo, tenemos una tabla llamada "aprendices" con los datos de
nuestros aprendices y otra tabla "contactos" con los datos de compañeros de trabajo, ambas con la misma estructura.
Elimine las tablas "aprendices" y "contactos" si existen.
Comprobemos:
create table aprendices(nombre varchar(30), domicilio varchar(30), telefono varchar (11));
create table contactos(nombre varchar(30), domicilio varchar(30), telefono varchar (11));

insert into contactos (nombre,telefono) values('Juancito','4565657');
insert into contactos (nombre,telefono) values('patricia','4223344');
insert into aprendices (nombre,telefono) values('Perez Luis','4565657');

insert into aprendices (nombre,telefono) values('Lopez','4223344');
Para intercambiar los nombres de estas dos tablas, debemos tipear lo siguiente:
rename table aprendices to auxiliar, contactos to aprendices, auxiliar to contactos;
Verifiquemos el cambio de nombre:

select * from aprendices;
select * from contactos;
Tipo de dato enum.
Una empresa necesita personal, varias personas se han presentado para cubrir distintos cargos.
La empresa almacena los datos de los postulantes a los puestos en una tabla llamada "postulantes". Le interesa, entre
otras cosas, conocer los estudios que tiene cada persona, si tiene estudios primario, secundario, terciario, universitario o
ninguno. Para ello, crea un campo de tipo "enum" con esos valores.
Eliminamos la tabla "postulantes", si existe.
Creamos la siguiente tabla definiendo un campo de tipo "enum":
create table postulantes(numero int unsigned auto_increment, documento char(8), nombre varchar(30),
sexo char(1), estudios enum('ninguno','primario','secundario', 'terciario','universitario') not null,
primary key(numero));

insert into postulantes (documento,nombre,sexo,estudios) values('22333444','Ana Acosta','f','primario');
insert into postulantes (documento,nombre,sexo,estudios) values('22433444','Mariana Mercado','m','universitario');
Ingresamos un registro sin especificar valor para "estudios", guardará el valor por defecto:
insert into postulantes (documento,nombre,sexo) values('24333444','Luis Lopez','m');
Vemos el registro ingresado:

select * from postulantes;
En el campo "estudios" se guardó el valor por defecto, el primer valor de la lista enumerada.
Si ingresamos un valor numérico, lo interpreta como índice de la enumeración y almacena el valor de la lista con dicho
número de índice. Por ejemplo:
insert into postulantes (documento,nombre,sexo,estudios) values('2455566','Juana Pereyra','f',5);
En el campo "estudios" almacenará "universitario" que es valor de índice 5.
Si ingresamos un valor no presente en la lista, coloca una cadena vacía. Por ejemplo:
insert into postulantes (documento,nombre,sexo,estudios) values('24678907','Pedro Perez','m','Post Grado');
Si ingresamos un valor de índice fuera de rango, almacena una cadena vacía:

insert into postulantes (documento,nombre,sexo,estudios) values('22222333','Susana Pereyra','f',6);
insert into postulantes (documento,nombre,sexo,estudios) values('25676567','Marisa Molina','f',0);
La cadena vacía ingresada como resultado de ingresar un valor incorrecto tiene el valor de índice 0; entonces, podemos
seleccionar los registros con valores inválidos en el campo de tipo "enum" así:
select * from postulantes where estudios=0;
Queremos seleccionar los postulantes con estudios universitarios:

select * from postulantes where estudios='universitario';
Como el campo está definido como "not null", si intentamos almacenar el valor "null" aparece un mensaje de error y la
sentencia no se ejecuta.
insert into postulantes (documento,nombre,sexo,estudios) values('25676567','Marisa Molina','f',null);
Tipo de dato set.
Una empresa necesita personal, varias personas se han presentado para cubrir distintos cargos. La empresa almacena los
datos de los postulantes a los puestos en una tabla llamada "postulantes". Le interesa, entre otras cosas, saber los
distintos idiomas que conoce cada persona; para ello, crea un campo de tipo "set" en el cual guardará los distintos
idiomas que conoce cada postulante.
Creamos la tabla definiendo un campo de tipo "set" usando la siguiente sintaxis:
create table postulantes(numero int unsigned auto_increment, documento char(8), nombre varchar(30),
idioma set('ingles','italiano','portuges'), primary key(numero));
Ingresamos un registro:
insert into postulantes (documento,nombre,idioma) values('22555444','Ana Acosta','ingles');
Ingresamos un valor que contiene 2 elementos del conjunto:
insert into postulantes (documento,nombre,idioma) values('23555444','Juana Pereyra','ingles,italiano');
Recuerde que no importa el orden en el que se inserten, se almacenan en el orden que han sido definidos:
insert into postulantes (documento,nombre,idioma) values('25555444','Andrea Garcia','italiano,ingles');
Tampoco importa si se repite algún valor, cada elemento repetido, se ignora y se guarda una vez y en el orden que ha
sido definido:
insert into postulantes (documento,nombre,idioma) values('27555444','Diego Morales','italiano,ingles,italiano');
Si ingresamos un valor que no está en la lista "set", se ignora y se almacena una cadena vacía:
insert into postulantes (documento,nombre,idioma) values('27555464','Diana Herrero','frances');
También coloca una cadena vacía si ingresamos valore de índice fuera de rango:
insert into postulantes (documento,nombre,idioma) values('28255265','Pedro Perez',0);
insert into postulantes (documento,nombre,idioma) values('22255260','Nicolas Duarte',8);
Si un "set" permite valores nulos, el valor por defecto el "null":

insert into postulantes (documento,nombre) values('28555464','Ines Figueroa');
Ingresemos un registro con el valor "ingles,italiano,portugues" para el campo "idioma" con su núméro de índice):
insert into postulantes (documento,nombre,idioma) values('29255265','Esteban Juarez',7);
Busquemos valores de campos "set" utilizando el operador "like". Recuperemos todos los valores que contengan la
cadena "ingles":
select * from postulantes where idioma like '%ingles%';
Para recuperar todos los valores que incluyen "ingles,italiano", tecleamos:

select * from postulantes where idioma like '%ingles,italiano%';
Recuerde que para las búsquedas, es importante respetar el orden en que se presentaron los valores en la definición del
campo; intentemos buscar el valor "italiano,ingles" en lugar de "ingles,italiano", no retornará registros:
select * from postulantes where idioma like '%italiano,ingles%';
Busquemos valores de campos "set" utilizando la función "find_in_set()". Recuperemos todos los postulantes que sepan
inglés:
select * from postulantes where find_in_set('ingles',idioma)>0;
Para localizar los registros que sólo contienen el primer miembro del conjunto "set" usamos:
select * from postulantes where idioma='ingles';
También podemos buscar por el número de índice:

select * from postulantes where idioma=1;
Para buscar los registros que contengan el valor "ingles,italiano,portugues" podemos utilizar:
select * from postulantes where idioma=7;
Para recuperar todos los valores que NO contengan la cadena "ingles" podemos usar cualquiera de las siguientes
sentencias:
select * from postulantes where idioma not like '%ingles%';
select * from postulantes where not find_in_set('ingles',idioma)>0;
Tipos de datos blob y text.
Un video club almacena la información de sus películas en alquiler en una tabla denominada "peliculas". Además del
título, actor y duración de cada película incluye un campo en el cual guarda la sinopsis de cada una de ellas.
drop table if exists peliculas;
Creamos la tabla con un campo de tipo "text" llamado "sinopsis":
create table peliculas(codigo int unsigned auto_increment, nombre varchar(40), actor varchar(30),
duracion tinyint unsigned, sinopsis text, primary key (codigo));

insert into peliculas values(1,'Mentes que brillan','Jodie Foster',120,
'El no entiende al mundo ni el mundo lo entiende a él, es un niño superdotado.
La escuela especial a la que asiste tampoco resuelve los problemas del niño.
Su madre hará todo lo que esté a su alcance para ayudarlo. Drama');
insert into peliculas values(2,'Charlie y la fábrica de chocolate','J. Deep',120, 'Un niño llamado Charlie tiene la ilusión de
encontrar uno de los 5 tickets del concurso para entrar a la fabulosa fábrica de chocolates del excéntrico Willy Wonka y
descubrir el misterio de sus golosinas. Aventuras');
insert into peliculas values(3,'La terminal','Tom Hanks',180, 'Sin papeles y esperando que el gobierno resuelva su
situación migratoria, Victor convierte el aeropuerto de Nueva York en su nuevo hogar trasformando la vida de los
empleados del lugar. Drama');
Para buscar todas las películas que en su campo "sinopsis" contengan el texto "Drama" usamos "like":
select * from peliculas where sinopsis like '%Drama%';
Podemos buscar la película que incluya en su sinopsis el texto "chocolates":
select * from peliculas where sinopsis like '%chocolates%';
Funciones de control de flujo (if)
Trabajamos con las tablas "libros" de una librería.
Creamos la tabla:

insert into libros (titulo, autor,editorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos',50.5);
insert into libros (titulo, autor,editorial,precio) values('Alicia a traves del espejo','Lewis Carroll','Emece',25);
insert into libros (titulo, autor,editorial,precio) values('El aleph','Borges','Paidos',15);
insert into libros (titulo, autor,editorial,precio) values('Matemática estas ahi','Paenza','Paidos',10);
insert into libros (titulo, autor,editorial) values('Antologia','Borges','Paidos');
insert into libros (titulo, editorial) values('El gato con botas','Paidos');
insert into libros (titulo, autor,editorial,precio) values('Martin Fierro','Jose Hernandez','Emece',90);

No nos interesa el precio exacto de cada libro, sino si el precio es menor o mayor a $50. Podemos utilizar estas
sentencias:
select titulo from libros where precio<50;
select titulo from libros where precio >=50;
En la primera sentencia mostramos los libros con precio menor a 50 y en la segunda los demás.
Usamos la función "if":
select titulo, if (precio>50,'caro','economico') from libros;
Si el precio del libro es mayor a 50 (primer argumento del "if"), coloca "caro" (segundo argumento del "if"), en caso
contrario coloca "economico" (tercer argumento del "if").
Queremos mostrar los nombres de los autores y la cantidad de libros de cada uno de ellos; para ello especificamos el
nombre del campo a mostrar ("autor"), contamos los libros con "autor" conocido con la función "count()" y agrupamos
por nombre de autor:
select autor, count(*) from libros group by autor;
El resultado nos muestra cada autor y la cantidad de libros de cada uno de ellos. Si solamente queremos mostrar los
autores que tienen más de 1 libro, es decir, la cantidad mayor a 1, podemos usar esta sentencia:
select autor, count(*) from libros group by autor having count(*)>1;
Pero si no queremos la cantidad exacta sino solamente saber si cada autor tiene más de 1 libro, podemos usar "if":
select autor, if (count(*)>1,'Más de 1','1') from libros group by autor;
Si la cantidad de libros de cada autor es mayor a 1 (primer argumento del "if"), coloca "Más de 1" (segundo argumento
del "if"), en caso contrario coloca "1" (tercer argumento del "if").
Podemos ordenar por la columna del "if":
select autor, if (count(*)>1,'Más de 1','1') as cantidad from libros group by autor order by cantidad;
Para saber si la cantidad de libros por editorial supera los 4 o es menor:

select editorial, if (count(*)>4,'5 o más','menos de 5') as cantidad from libros group by editorial order by cantidad;
Si la cantidad de libros de cada editorial es mayor a 4 (primer argumento del "if"), coloca "5 o más" (segundo argumento
del "if"), en caso contrario coloca "menos de 5" (tercer argumento del "if"). Además, la sentencia ordena la salida por el
alias "cantidad".
Funciones de control de flujo (case)
Creamos la tabla:
editorial varchar(20), precio decimal(5,2) unsigned, cantidad smallint unsigned, primary key(codigo));

insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Planeta',34.5,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Alicia en el pais de las maravillas','Carroll
L.','Paidos',20.7,50);
insert into libros (titulo,autor,editorial,precio,cantidad) values('harry Potter y la camara secreta',null,'Emece',35,500);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Aprenda PHP','Molina Mario','Planeta',54,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Harry Potter y la piedra filosofal',null,'Emece',38,500);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Aprenda Java','Molina Mario','Planeta',55,100);
insert into libros (titulo,autor,editorial,precio,cantidad) values('Aprenda JavaScript','Molina Mario','Planeta',58,150);
Queremos saber si la cantidad de libros de cada editorial es menor o mayor a 1 empleando "case":
select editorial,
case count(*) when 1 then 1 else 'mas de 1' end as 'cantidad' from libros group by editorial;
Por cada valor hay un "when" y un "then"; si encuentra un valor coincidente en algún "where" ejecuta el "then"
correspondiente a ese "where", si no encuentra ninguna coincidencia, se ejecuta el "else", si no hay parte "else" retorna
"null". Finalmente se coloca "end" para indicar que el "case" ha finalizado. Veamos un ejemplo sin parte "else":
select editorial, case count(*) when 1 then 1 end as 'cantidad' from libros group by editorial;
Extendamos el "case" para mostrar distintos mensajes comparando más de 2 valores:

select editorial, case count(*) when 1 then 1 when 2 then 2 when 3 then 3 else 'Más de 3' end as 'cantidad' from libros
group by editorial;
Agregamos la cláusula "order by" para ordenar la salida por la columna "cantidad":
select editorial, case count(*) when 1 then 1 when 2 then 2 when 3 then 3 else 'Más de 3' end as 'cantidad' from libros
group by editorial order by cantidad;
"case" toma valores puntuales, no expresiones. Intentemos lo siguiente:

select editorial, case count(*) when 1 then 1 when >1 then 'mas de 1' end as 'cantidad' from libros group by editorial;
Usemos la otra sintaxis de "case":

select editorial, case when count(*)=1 then 1 else 'mas de 1' end as 'cantidad' from libros group by editorial;
Varias tablas (join)
Trabajamos con las tablas "libros" y editoriales" de una librería.
Elimine las tablas, si existen:
drop table if exists libros, editoriales;
Cree las siguientes tablas:
create table libros(codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(30) not null default
'Desconocido', codigoeditorial tinyint unsigned not null, precio decimal(5,2) unsigned, cantidad smallint unsigned default
0, primary key (codigo));
create table editoriales(codigo tinyint unsigned auto_increment, nombre varchar(20) not null, primary key(codigo));
Cargamos algunos registros en la tabla "editoriales":

insert into editoriales (nombre) values('Paidos');
insert into editoriales (nombre) values('Emece');
insert into editoriales (nombre) values('Planeta');
insert into editoriales (nombre) values('Sudamericana');
Cargamos algunos registros en la tabla "libros":

insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('El Aleph','Borges',3,43.5,200);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Alicia en el pais de las maravillas','Lewis
Carroll',2,33.5,100);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Aprenda PHP','Mario Perez',1,55.8,50);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Java en 10 minutos','Juan Lopez',1,88,150);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Alicia a traves del espejo','Lewis Carroll',1,15.5,80);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Cervantes y el quijote','Borges- Bioy
Casares',3,25.5,300);
Mostramos todos los datos de la tabla "libros":

Queremos también el nombre de la editorial, necesitamos ambas tablas:
select * from libros join editoriales on libros.codigoeditorial=editoriales.codigo;
Analicemos la consulta: indicamos el nombre de la tabla luego del "from" ("libros"), unimos esa tabla con "join" y el
nombre de la otra tabla ("editoriales"), luego especificamos la condición para enlazarlas con "on", es decir, el campo por
el cual haremos coincidir los registros de las dos tablas, el campo "codigoeditorial" de "libros" y el campo "codigo" de
"editoriales" son los que enlazarán ambas tablas.
Si no especificamos por qué campo relacionamos ambas tablas, es decir, omitimos la condición "on":
select * from libros join editoriales;
El resultado es el producto cartesiano de ambas tablas. Un "join" sin condición "on" para la unión genera un resultado en
el que aparecen todas las combinaciones de los registros de ambas tablas.
Veamos lo que sucede si omitimos la referencia a las tablas al nombrar el campo "codigo" (nombre de campo que
contienen ambas tablas):
select * from libros join editoriales on codigoeditorial=codigo;
Aparece un mensaje de error indicando que "codigo" es ambiguo.
Por ello, si hacemos referencia a un campo de una tabla que tiene el mismo nombre que el campo de la otra tabla
consultada, debemos especificar a cuál tabla pertenece dicho campo.
Para simplificar la sentencia podemos usar un alias para cada tabla:

select * from libros as l join editoriales as e on l.codigoeditorial=e.codigo;
En la consulta anterior, el código de la editorial aparece 2 veces, desde la tabla "libros" y "editoriales". Podemos solicitar
que nos muestre algunos campos:
select titulo,autor,nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo;
Si queremos ver el código del libro, al presentar el campo "codigo", debemos especificar de qué tabla, porque el campo
"codigo" se repite en ambas tablas ("libros" y "editoriales"):
select l.codigo,titulo,autor,nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo;
Si obviamos la referencia a la tabla, la sentencia no se ejecuta y aparece un mensaje indicando que el campo "codigo" es
ambiguo:
select codigo,titulo,autor,nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo;
Clave-llave foránea.
Trabajamos con las tablas "libros" y "editoriales" de una librería.
Eliminamos las tablas, si existen:
drop table libros, editoriales;
Creamos las tablas:
'Desconocido',
codigoeditorial tinyint unsigned not null, precio decimal(5,2) unsigned, cantidad smallint unsigned default 0,
En este ejemplo, el campo "codigoeditorial" de "libros" es una clave foránea, se emplea para enlazar la tabla "libros" con
"editoriales".
insert into editoriales values(2,'Emece');
insert into editoriales values(15,'Planeta');
insert into editoriales values(23,'Paidos');
insert into libros values(1,'El aleph','Borges',23,4.55,10);
insert into libros values(2,'Alicia en el pais de las maravillas','Lewis Carroll',2,11.55,2);
insert into libros values(3,'Martin Fierro','Jose Hernandez',15,7.12,4);
Si modificamos el tipo, longitud o atributos de una clave foránea, ésta puede quedar inhabilitada para hacer los enlaces.
Veamos un ejemplo:
alter table libros modify codigoeditorial char(1);
Veamos cómo afectó el cambio a la tabla "libros":
El libro con código de editorial "23" ("Paidos") ahora tiene "2" ("Emece") en "codigoeditorial" y el libro con código de
editorial "15" ("Planeta") ahora almacena "1" (valor inexistente en "editoriales").
Si buscamos coincidencia de códigos en la tabla "editoriales":

select l.titulo,e.nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo;
El resultado es erróneo.
Las claves foráneas y las claves primarias deben ser del mismo tipo para poder enlazarse. Si modificamos una, debemos
modificar la otra para que los valores se correspondan.
Intentemos modificar la clave en "editoriales":
alter table editoriales modify codigo char(1);
No lo permite porque si se modifica los valores para el campo clave quedan repetidos.
Varias tablas (left join)
Eliminamos dichas tablas, si existen:
Creamos las siguientes tablas:
'Desconocido', codigoeditorial tinyint unsigned not null, precio decimal(5,2) unsigned, cantidad tinyint unsigned default


Carroll',2,33.5,100);

insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Alicia a traves del espejo','Lewis
Carroll',1,15.5,80);
Casares',3,25.5,300);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Aprenda Java en 10 minutos','Lopez
Juan',5,28,100);
Para obtener la lista de todas las editoriales y los libros de las mismas, incluso de las cuales no tenemos libros usamos:
select * from editoriales left join libros on editoriales.codigo=libros.codigoeditorial;
Un "left join" se usa para hacer coincidir registros en una tabla (izquierda) con otra tabla (derecha), pero, si un valor de la
tabla de la izquierda no encuentra coincidencia en la tabla de la derecha, se genera una fila extra (una por cada valor no
encontrado) con todos los campos seteados a "null".
Recuerde que es importante la posición en que se colocan las tablas en un "left join", la tabla de la izquierda es la que
localiza registros en la tabla de la derecha. Por lo tanto, estos "join" no son iguales:
select * from editoriales left join libros on editoriales.codigo=libros.codigoeditorial;
select * from libros left join editoriales on editoriales.codigo=libros.codigoeditorial;
La primera sentencia busca coincidencia en la tabla "libros" por cada valor de codigo de "editoriales", si no encuentra
coincidencia para algún valor, genera una fila seteada a "null". No hay libros de la editorial "Sudamericana", entonces esa
fila contiene "null" en todos los campos correspondientes a "libros".
La segunda sentencia busca coincidencia en la tabla "editoriales" por cada valor de "codigoeditorial" de "libros", si no
encuentra coincidencia para algún valor, genera una fila seteada a "null". El libro "Aprenda java en 10 minutos" tiene
código de editorial "5", valor inexistente en la tabla "editoriales", por ello, esa fila contiene "null" en todos los campos
correspondientes a "editoriales".
Para encontrar los valores de código de la tabla "editoriales" que están presentes en la tabla "libros" usamos un "where":
select nombre,titulo from editoriales as e left join libros as l on e.codigo=l.codigoeditorial where l.codigoeditorial is not
null;
Para mostrar las editoriales que no están presentes en "libros":
select e.nombre,l.titulo from editoriales as e left join libros as l on e.codigo=l.codigoeditorial where l.codigoeditorial is
null;
Varias tablas (right join)

Carroll',2,33.5,100);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Alicia a traves del espejo','Lewis Carroll',1,15.5,80);
Casares',3,25.5,300);
Necesitamos los títulos y nombres de las editoriales de los libros, incluso de aquellos editoriales que no tienen libros:
select nombre,titulo from editoriales as e left join libros as l on e.codigo=l.codigoeditorial;
Esta sentencia busca los nombres de las editoriales que están presentes en "libros". Podemos realizar la búsqueda de
modo inverso con "right join":
select nombre,titulo from libros as l right join editoriales as e on e.codigo=l.codigoeditorial;
La primera, con "left join", busca valores de "codigo" de la tabla "editoriales" (tabla de la izquierda) coincidentes con los
valores de "codigoeditorial" de la tabla "libros" (tabla de la derecha). La segunda, con "right join", busca valores de
"codigoeditorial" de la tabla "libros" (tabla de la derecha) coincidentes con los valores de "codigo" de la tabla
"editoriales" (tabla de la izquierda).
Varias tablas (cross join)
Un pequeño restaurante tiene almacenados los nombres y precios de sus comidas en una tabla llamada "comidas" y en
una tabla denominada "postres" los mismos datos de sus postres.
drop table if exists comidas, postres;
create table comidas(codigo tinyint unsigned auto_increment, nombre varchar(30), precio decimal(4,2) unsigned,
create table postres(codigo tinyint unsigned auto_increment, nombre varchar(30), precio decimal(4,2) unsigned,

insert into comidas values(1,'milanesa y fritas',3.4);
insert into comidas values(2,'arroz primavera',2.5);
insert into comidas values(3,'pollo',2.8);
insert into postres values(1,'flan',1);
insert into postres values(2,'porcion de torta',2.1);
insert into postres values(3,'gelatina',0.9);
Empleamos "cross join" para obtener el producto cartesiano de ambas tablas:
select c.*,p.* from comidas as c cross join postres as p;
Retorna el mismo resultado que un simple "join" sin parte "on", es decir, si condición de enlace:
select c.*,p.* from comidas as c join postres as p;
Para obtener el nombre del plato principal, del postre y el precio total de cada combinación (menú) tecleamos la
siguiente sentencia:
select c.nombre,p.nombre, c.precio+p.precio as total from comidas as c cross join postres as p;
Hemos aprendido que para realizar un "join" no es necesario utilizar 2 tablas, podemos combinar los registros de una
misma tabla.
Eliminamos las tablas anteriormente creadas:
drop table comidas, postres;
Creamos la tabla "comidas" con la siguiente estructura:
create table comidas(codigo tinyint unsigned auto_increment, nombre varchar(30), rubro varchar(20),/*plato principal y
postre*/ precio decimal (5,2) unsigned, primary key(codigo));

insert into comidas values(1,'milanesa y fritas','plato principal',3.4);
insert into comidas values(2,'arroz primavera','plato principal',2.5);
insert into comidas values(3,'pollo','plato principal',2.8);
insert into comidas values(4,'flan','postre',1);
insert into comidas values(5,'porcion de torta','postre',2.1);
insert into comidas values(6,'gelatina','postre',0.9);
Podemos obtener la combinación de platos principales con postres empleando un "cross join" con una sola tabla:
select c1.nombre,c1.precio,c2.nombre,c2.precio from comidas as c1 cross join comidas as c2 where c1.rubro='plato
principal' and c2.rubro='postre';
Note que utilizamos 2 alias para la misma tabla y empleamos un "where" para combinar el "plato principal" con el
"postre".
Si queremos el monto total de cada combinación:
select c1.nombre,c2.nombre,
c1.precio+c2.precio as total
from comidas as c1
cross join comidas as c2
where c1.rubro='plato principal' and
c2.rubro='postre';
Varias tablas (natural join)
create table editoriales(codigoeditorial tinyint unsigned auto_increment, nombre varchar(20) not null,
primary key(codigoeditorial));

Carroll',2,33.5,100);
insert into libros (titulo, autor,codigoeditorial,precio,cantidad) values('Martin Fierro','Jose Hernandez',1,55.8,50);

Como en ambas tablas, el código de la editorial se denomina "codigoeditorial", podemos omitir la parte "on" que indica
los nombres de los campos por el cual se enlazan las tablas, empleando "natural join", se unirán por el campo que tienen
en común:
select titulo,nombre from libros as l natural join editoriales as e;
La siguiente sentencia tiene la misma salida anterior:

select titulo,nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigoeditorial;
También se puede usar "natural" con "left join" y "right join":

select nombre,titulo from editoriales as e natural left join libros as l;
que tiene la misma salida que:

select nombre,titulo from editoriales as e left join libros as l on e.codigoeditorial=l.codigoeditorial;
Hay que tener cuidado con este tipo de "join" porque si ambas tablas tiene más de un campo con igual nombre, MySQL
no sabrá por cual debe realizar la unión.
Alteremos la tabla "libros" para que el campo "titulo" se denomine "nombre":
alter table libros change titulo nombre varchar(40);
Ahora las tablas tienen 2 campos con igual nombre ("codigoeditorial" y "nombre"). Intentemos realizar un "natural join":
select l.nombre,e.nombre from libros as l natural join editoriales as e;
No hay salida.
Alteramos nuevamente la tabla "libros" para que el campo "nombre" en adelante sea "titulo":
alter table libros change nombre titulo varchar(40);
Alteramos la tabla "editoriales" para que el campo "codigoeditorial" se llame en adelante "codigo":
alter table editoriales change codigoeditorial codigo tinyint unsigned auto_increment;
Si usamos "natural join", unirá las tablas por el campo "codigo", que es el campo que tienen igual nombre, pero el campo
"codigo" de "libros" no hace referencia al código de la editorial sino al del libro, así que la salida será errónea:
select l.*,e.* from libros as l natural join editoriales as e;
Note que el libro con código "3" de editorial "Planeta" aparece como perteneciente a la editorial "Paidos" (código 3)
porque buscó coincidencia del código del libro con el código de editorial.
join, group by y funciones de agrupamiento.
Trabajamos con la tabla "libros" y "editoriales" de una librería.
Eliminamos ambas tablas, si existen.
Creamos las tablas.
create table libros(codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(30) not null default 1,
codigoeditorial tinyint unsigned not null, precio decimal(5,2) unsigned, primary key (codigo));
create table editoriales (codigo tinyint unsigned auto_increment, nombre varchar(20), primary key (codigo) );
Ingresamos algunos registros para la tabla "editoriales":

insert into editoriales (nombre) values ('Planeta');
insert into editoriales (nombre) values ('Emece');
insert into editoriales (nombre) values ('Paidos');
Ingresamos algunos registros en la tabla "libros":
insert into libros (titulo, autor,codigoeditorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll',1,23.5);
insert into libros (titulo, autor,codigoeditorial,precio) values('Alicia a traves del espejo','Lewis Carroll',2,25);
insert into libros (titulo, autor,codigoeditorial,precio) values('El aleph','Borges',2,15);
insert into libros (titulo, autor,codigoeditorial,precio) values('Matemática estas ahi','Paenza',1,10);
Para ver todas las editoriales, agrupadas por nombre, con una columna llamada "cantidad de libros" en la que aparece la
cantidad calculada con "count()" de todos los libros de cada editorial tecleamos:
select e.nombre,count(l.codigoeditorial) as 'cantidad de libros' from editoriales as e left join libros as l
on l.codigoeditorial=e.codigo group by e.nombre;
Note que como usamos "left join" la consulta muestra todas las editoriales, y para la editorial que no encuentra
coincidencia en "libros" coloca "0" en "cantidad de libros". Si usáramos "join" en lugar de "left join":
select e.nombre,count(l.codigoeditorial) as 'cantidad de libros' from editoriales as e join libros as l
on l.codigoeditorial=e.codigo group by e.nombre;
Solamente muestra las editoriales para las cuales encuentra valores coincidentes para el código de la editorial en "libros".
Para conocer el mayor precio de los libros de cada editorial usamos la función "max()", hacemos un "join" y agrupamos
por nombre de la editorial:
select e.nombre, max(l.precio) as 'mayor precio' from editoriales as e left join libros as l on l.codigoeditorial=e.codigo
group by e.nombre;
Igualmente, en la sentencia anterior, muestra, para la editorial de la cual no hay libros, el valor "null" en la columna
calculada; si realizamos un "join":
select e.nombre, max(l.precio) as 'mayor precio' from editoriales as e join libros as l on l.codigoeditorial=e.codigo
group by e.nombre;
sólo mostrará las editoriales para las cuales encuentra correspondencia en "libros".
join con más de dos tablas.
Una biblioteca registra la información de sus libros en una tabla llamada "libros", los datos de sus socios en "socios" y los
préstamos en una tabla "prestamos".
En la tabla "prestamos" se hace referencia al libro y al socio que lo solicita colocando un código que los identifique.
Eliminamos las tablas, si existen.
Creamos las tablas:
create table libros(codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(20) default
'Desconocido', primary key (codigo));
create table socios(documento char(8) not null, nombre varchar(30), domicilio varchar(30), primary key (documento));
create table prestamos(documento char(8) not null, codigolibro int unsigned, fechaprestamo date not null,
fechadevolucion date, primary key (codigolibro,fechaprestamo));
insert into socios values('22333444','Juan Perez','Colon 345');
insert into socios values('23333444','Luis Lopez','Caseros 940');
insert into socios values('25333444','Ana Herrero','Sucre 120');
insert into libros values(1,'Manual de 2º grado','Molina Manuel');

insert into libros values(25,'Aprenda PHP','Oscar Mendez');
insert into libros values(42,'Martin Fierro','Jose Hernandez');
insert into prestamos values('22333444',1,'2006-08-10','2006-08-12');

insert into prestamos values('22333444',1,'2006-08-15',null);
Al recuperar los datos de los prestamos:

select * from prestamos;
aparece el código del libro pero no sabemos el nombre y tampoco el nombre del socio sino su documento. Para obtener
los datos completos de cada préstamo, incluyendo esos datos, necesitamos consultar las tres tablas.
Hacemos un "join" (unión):
select nombre,titulo,fechaprestamo from prestamos as p join socios as s on s.documento=p.documento join libros as l
on codigolibro=codigo;
Muestra todos los prestamos para los cuales encuentra coincidencia en "socios" y "libros".
Para ver todos los prestamos, incluso los que no encuentran coincidencia en las otras tablas, usamos:
select nombre,titulo,fechaprestamo from prestamos as p left join socios as s on p.documento=s.documento
left join libros as l on l.codigo=p.codigolibro;
Note que también se muestran aquellos prestamos para los cuales no se encontró coincidencia en "libros" y "socios", es
decir, hay un código de libro ingresado en "prestamos" que no existe en la tabla "libros", esa fila está seteada a "null" en
"titulo"; también hay un préstamo con un documento que no está en la tabla "socios", esa fila contiene "null" en
"nombre".
Podemos ver aquellos prestamos con valor coincidente para "libros" pero para "socio" con y sin coincidencia:
select nombre,titulo,fechaprestamo
from prestamos as p left join socios as s on p.documento=s.documento join libros as l on p.codigolibro=l.codigo;
Note que el préstamo con código de libro inexistente en la tabla "libros" ya no aparece.
Función de control if con varias tablas.
Creamos las tablas:
create table libros(codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(30) not null default 1,
codigoeditorial tinyint unsigned not null, precio decimal(5,2) unsigned, primary key (codigo));
create table editoriales (codigo tinyint unsigned auto_increment, nombre varchar(20), primary key (codigo));
Ingresamos algunos registros para la tabla "editoriales":

insert into editoriales (nombre) values ('Planeta');
insert into editoriales (nombre) values ('Emece');
insert into editoriales (nombre) values ('Paidos');

insert into libros (titulo, autor,codigoeditorial,precio) values('Alicia en el pais de las maravillas','Lewis Carroll',1,23.5);
insert into libros (titulo, autor,codigoeditorial,precio) values('Alicia a traves del espejo','Lewis Carroll',2,25);
insert into libros (titulo, autor,codigoeditorial,precio) values('El aleph','Borges',2,15);
insert into libros (titulo, autor,codigoeditorial,precio) values('Matemática estas ahi','Paenza',1,10);
Queremos saber si hay libros de cada una de las editoriales, necesitamos consultar ambas tablas:
select e.nombre, if (count(l.codigoeditorial)>0,'Si','No') as hay from editoriales as e left join libros as l
on e.codigo=l.codigoeditorial group by e.nombre;
Podemos obtener una salida similar usando "case" en lugar de "if":
select e.nombre, case count(l.codigoeditorial) when 0 then 'No' else 'Si' end as 'Hay' from editoriales as e left join libros
as l on e.codigo=l.codigoeditorial group by e.nombre;
Variables de usuario.
Trabajamos con la tabla "libros" y "editoriales" de una librería.
Eliminamos las tablas si existen:
Creamos las tablas:
create table libros(codigo int unsigned auto_increment, titulo varchar(30), autor varchar(20), codigoeditorial tinyint
unsigned, precio decimal(5,2) unsigned, primary key(codigo));
create table editoriales(codigo tinyint unsigned auto_increment, nombre varchar(20), primary key(codigo));

insert into libros values (1,'El aleph','Borges',2,23);

insert into libros values (2,'Alicia en el pais de las maravillas', 'Lewis Carroll',1,15);
insert into libros values (3,'Matematica estas ahi','Paenza',2,12);
insert into libros values (4,'Martin Fierro','Jose Hernandez',3,34);
insert into libros values (6,'Aprenda PHP','Molina Mario',1,45);
insert into libros values (7,'Java en 10 minutos','Molina Mario',3,42);
Guardamos en una variable el valor de precio más alto:

select @mayorprecio:=max(precio) from libros;
Mostramos todos los datos de dicho libro empleando la variable anterior:

select * from libros where precio=@mayorprecio;
Empleamos ahora un "join" para ver, además, el nombre de la editorial:

select l.titulo,l.autor,e.nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo
where l.precio = @mayorprecio;
Queremos ver todos los libros de la editorial que tenga el libro más caro.
Almacenamos el precio más alto en una variable llamada "@mayorprecio":
select @mayorprecio:=max(precio) from libros;
Luego almacenamos el nombre de la editorial del libro en la variable denominada "@editorial":

select @editorial:=e.nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo
where precio=@mayorprecio;
Finalmente buscamos todos los libros de la editorial igual a la variable "@editorial":

select l.titulo,l.autor,e.nombre from libros as l join editoriales as e on l.codigoeditorial=e.codigo
where e.nombre=@editorial;
Crear tabla a partir de otra (create - insert)
Tenemos la tabla "libros" de una librería y queremos crear una tabla llamada "editoriales" que contenga los nombres de
las editoriales.
Eliminamos las tablas "libros" y "editoriales", si existen:
create table libros( codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(30) not null default
'Desconocido', editorial varchar(20) not null, precio decimal(5,2) unsigned, primary key (codigo));
La tabla "editoriales" debe tener la siguiente estructura:
-nombre: nombre de la editorial.
No la creamos aún.
Ingresamos algunos registros para "libros":
insert into libros values (1,'El aleph','Borges','Emece',23.5);
insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta',15);
insert into libros values (3,'Matematica estas ahi','Paenza','Emece',34.6);
insert into libros values (4,'Martin Fierro','Jose Hernandez','Paidos',43.5);
insert into libros values (5,'Martin Fierro','Jose Hernandez','Planeta',12);
insert into libros values (6,'Aprenda PHP','Mario Molina','Paidos',21.8);
insert into libros values (7,'Aprenda Java','Mario Molina','Paidos',55.4);
insert into libros values (8,'Alicia a traves del espejo','Lewis Carroll','Emece',18);
insert into libros values (9,'Antologia poetica','Borges','Paidos',47.9);
Podemos lograrlo en 3 pasos: 1º) crear la tabla "editoriales", 2º) realizar la consulta en la tabla "libros" para obtener los
nombres de las distintas editoriales y 3º) insertar los registros necesarios en la tabla "editoriales".
Pero lo haremos de la manera simplificada. Crearemos la tabla "editoriales" con el campo necesario consultando la tabla
"libros" y en el mismo momento insertaremos la información:
create table editoriales select distinct editorial as nombre from libros;
La tabla "editoriales" se ha creado con el campo llamado "nombre" seleccionado del campo "editorial" de "libros".
Seleccionamos todos los registros de la tabla "editoriales":
select * from editoriales;
Visualicemos la estructura de "editoriales":
describe editoriales;
Vemos que el campo "nombre" se creó con el mismo tipo y longitud del campo "editorial" de "libros".
También podemos crear una tabla a partir de una consulta cargando los campos con los valores de otra tabla y una
columna calculada.
Queremos crear una tabla llamada "cantidadporeditorial" que contenga la cantidad de libros de cada editorial.
Eliminamos la tabla "cantidadporeditorial" si existe:
drop table if exists cantidadporeditorial;
La tabla "cantidadporeditorial" debe tener la siguiente estructura:
-nombre: nombre de la editorial,
-cantidad: cantidad de libros.
No la creamos aún.
Podemos lograrlo en 3 pasos: 1º) crear la tabla "cantidadporeditorial", 2º) realizar la consulta en la tabla "libros" para
obtener la cantidad de libros de cada editorial agrupando por "editorial" y calculando la cantidad con "count()", 3º)
insertar los registros necesarios en la tabla "cantidadporeditorial" con "insert into".
Pero lo haremos de la manera simplificada.
Crearemos la tabla "cantidadporeditorial" con los campos necesarios consultando la tabla "libros" y en el mismo
momento insertaremos los registros:
create table cantidadporeditorial
select editorial as nombre,count(*) as cantidad from libros group by editorial;

La tabla "cantidadporeditorial" se ha creado con el campo llamado "nombre" seleccionado del campo "editorial" de
"libros" y con el campo "cantidad" con el valor calculado con count() de la tabla "libros".
Seleccionamos los registros de la tabla "cantidadporeditorial":
select * from cantidadporeditorial;
Visualizamos la estructura de "cantidadporeditorial":
describe cantidadporeditorial;
Crear tabla a partir de otras (create - insert - join)
Tenemos la tabla "libros" y "editoriales" y queremos crear una tabla llamada "cantidadporeditorial" que contenga la
cantidad de libros de cada editorial.
Eliminamos las tablas "libros", "editoriales" y "cantidadporeditorial" si existen:
drop table if exists libros, editoriales,cantidadporeditorial;
Creamos las tablas "libros" y "editoriales" con las siguientes estructuras:
'Desconocido', codigoeditorial tinyint unsigned, precio decimal(5,2) unsigned, primary key (codigo));
La tabla "cantidadporeditorial" debe tener la siguiente estructura:

-nombre: nombre de la editorial,
-cantidad: cantidad de libros.
No la creamos aún.
Ingresamos algunos registros para "libros" y "editoriales":
insert into libros values (1,'El aleph','Borges',1,23.5);

insert into libros values (2,'Alicia en el pais de las maravillas',
'Lewis Carroll',2,15);
insert into libros values (3,'Matematica estas ahi','Paenza',1,34.6);
insert into libros values (4,'Martin Fierro','Jose Hernandez',3,43.5);
insert into libros values (6,'Aprenda PHP','Mario Molina',3,21.8);
insert into libros values (7,'Aprenda Java','Mario Molina',3,55.4);
insert into libros values (8,'Alicia a traves del espejo','Lewis Carroll',1,18);
insert into libros values (9,'Antologia poetica','Borges',3,47.9);
Podemos lograrlo en 3 pasos: 1º) crear la tabla "cantidadporeditorial", 2º) realizar la consulta en la tabla "libros" y
"editoriales" para obtener la cantidad de libros de cada editorial agrupando por el nombre de la editorial y calculando la
cantidad con "count()", 3º) insertar los registros necesarios en la tabla "cantidadporeditorial" con "insert into".
Pero lo haremos de la manera simplificada.
Crearemos la tabla "cantidadporeditorial" con los campos necesarios consultando la tabla "libros" y "editoriales" y en el
mismo momento insertaremos los registros:
create table cantidadporeditorial
select e.nombre,count(*) as cantidad from libros as l join editoriales as e on l.codigoeditorial=e.codigo
group by e.nombre;
La tabla "cantidadporeditorial" se ha creado con el campo llamado "nombre" seleccionado del campo "nombre" de
"editoriales" y con el campo "cantidad" con el valor calculado con count() de la tabla "libros".
Seleccionamos los registros de la tabla "cantidadporeditorial":
Visualizamos la estructura de "cantidadporeditorial":
describe cantidadporeditorial;
Insertar datos en una tabla buscando un valor en otra (insert - select)
Eliminamos las tablas si existen.
Creamos las tablas con las siguientes estructuras:
codigoeditorial tinyint unsigned, precio decimal(5,2) unsigned, primary key (codigo));
create table editoriales(codigo tinyint unsigned auto_increment, nombre varchar(20), domicilio varchar(30),
primary key(codigo));

insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll',1,15);
insert into editoriales values(1,'Planeta','San Martin 222');

insert into editoriales values(2,'Emece','San Martin 590');
insert into editoriales values(3,'Paidos','Colon 245');
Queremos ingresar en "libros", el siguiente libro: Harry Potter y la piedra filosofal, J.K. Rowling, Emece, 45.90.
pero no recordamos el código de la editorial "Emece".
Podemos realizar la consulta del código de la editorial al momento de la inserción:
insert into libros (titulo,autor,codigoeditorial,precio)
select 'Harry Potter y la cámara secreta','J.K.Rowling',codigo,45.90 from editoriales where nombre='Emece';
El registro se cargará con el valor de código de la editorial "Emece".
Si buscamos el código de una editorial que no existe en la tabla "editoriales", la consulta no retornará ningún registro y la
inserción no se realizará. Veamos un ejemplo:
select 'Cervantes y el quijote','Borges',codigo,35 from editoriales where nombre='Plaza & Janes';
Queremos ingresar el siguiente registro: Harry Potter y la camara secreta, J.K. Rowling,54.
Pero no recordamos el código de la editorial ni su nombre, sólo sabemos que su domicilio es en calle "San Martin". Si con
un "select" localizamos el código de todas las editoriales que tengan sede en "San Martin", el resultado retorna 2 filas,
porque hay 2 editoriales en esa dirección ("Planeta" y "Emece"). Digitemos la sentencia:
select 'Harry Potter y la cámara secreta','J.K. Rowling',codigo,54 from editoriales where domicilio like 'San Martin%';
Veamos qué sucedió:
ingresó 2 registros con los mismos datos, excepto el código de la editorial.
Insertar registros con valores de otra tabla (insert - select)
Tenemos la tabla "libros" y "editoriales" de una librería.
La tabla "libros" contiene registros; "editoriales", no.
Creamos las tablas:
create table editoriales(nombre varchar(20));

insert into libros values (1,'El aleph','Borges','Emece',23.5);
insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta',15);
insert into libros values (3,'Matematica estas ahi','Paenza','Emece',34.6);
insert into libros values (4,'Martin Fierro','Jose Hernandez','Paidos',43.5);
insert into libros values (5,'Martin Fierro','Jose Hernandez','Planeta',12);
insert into libros values (6,'Aprenda PHP','Mario Molina','Paidos',21.8);
insert into libros values (7,'Aprenda Java','Mario Molina','Paidos',55.4);
insert into libros values (8,'Alicia a traves del espejo','Lewis Carroll','Emece',18);
insert into libros values (9,'Antologia poetica','Borges','Paidos',47.9);
Queremos insertar registros en la tabla "editoriales", los nombres de las distintas editoriales de las cuales tenemos libros.
Podemos lograrlo en 2 pasos, con 4 sentencias: 1º) realizar la consulta de los nombres de las distintas editoriales de
"libros" y 2º) insertar los registros uno a uno en la tabla "editoriales" (3 "insert").
O podemos lograrlo en un solo paso, realizando el "insert" y el "select" en una misma sentencia:
insert into editoriales (nombre)
select distinct editorial from libros;
Veamos los registros de "editoriales":
Queremos conocer la cantidad de libros por editorial, realizamos una consulta:
select editorial,count(*) from libros group by editorial;
Queremos guardar esa información en una tabla llamada "cantidadporeditorial".

Eliminamos la tabla "cantidadporeditorial" si existe:
drop table if exists cantidadporeditorial;
Creamos la tabla "cantidadporeditorial" con la siguiente estructura:
create table cantidadporeditorial(nombre varchar(20), cantidad smallint unsigned);
Recuerde que los campos presentados entre paréntesis deben ser del mismo tipo y cantidad que las columnas devueltas
por la consulta.
Veamos lo que sucede si presentamos 1 solo campo y la consulta retorna 2 columnas:

insert into cantidadporeditorial (nombre)
select editorial,count(*) as cantidad from libros group by editorial;
aparece un mensaje de error y la sentencia no se ejecuta.
Ingresamos correctamente la información:

insert into cantidadporeditorial (nombre,cantidad)
select editorial,count(*) as cantidad from libros group by editorial;
Veamos los registros de la tabla "cantidadporeditorial":

Los datos fueron cargados correctamente.
Insertar registros con valores de otra tabla (insert - select - join)
Tenemos las tablas "libros", "editoriales" y "cantidadporeditorial".
Eliminamos las 3 tablas si existen:
drop table libros, editoriales, cantidadporeditorial;
Creamos las tablas:
create table cantidadporeditorial(nombre varchar(20), cantidad smallint unsigned);
Ingresamos algunos registros para las 2 primeras tablas:

insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll',1,15);

insert into editoriales values(4,'Plaza & Janes');
Queremos insertar registros en la tabla "cantidadporeditorial", los nombres de las distintas editoriales de las cuales
tenemos libros y la cantidad de libros de cada una de ellas.
Podemos lograrlo en 2 pasos: 1º) realizar la consulta a las tablas "libros" y "editoriales" para obtener el nombre y la
cantidad de cada editorial y 2º) insertar los registros uno a uno en la tabla "cantidadporeditorial".
O podemos lograrlo en un solo paso, realizando el "insert" y el "select" en una misma sentencia:
insert into cantidadporeditorial
select e.nombre,count(l.codigoeditorial) from editoriales as e left join libros as l on e.codigo=l.codigoeditorial
group by e.nombre;
Note que usamos "left join" porque hay una editorial de la cual no tenemos libros; si usáramos "join", esa editorial no
aparecería en la lista porque no encontraría coincidencia de códigos.
Actualizar datos con valores de otra tabla (update)
Tenemos la tabla "libros" en la cual almacenamos los datos de los libros de nuestra biblioteca y la tabla "editoriales" que
almacena el nombre de las distintas editoriales y sus códigos.
Eliminamos ambas tablas si existen:
Creamos las tablas:
insert into libros values (1,'El aleph','Borges',2);

insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll',1);
insert into libros values (3,'Matematica estas ahi','Paenza',2);
insert into libros values (4,'Martin Fierro','Jose Hernandez',3);
Queremos unir los datos de ambas tablas en una sola: "libros", es decir, alterar la tabla "libros" para que almacene el
nombre de la editorial, no su código y eliminar la tabla "editoriales".
En primer lugar debemos alterar la tabla "libros", vamos a agregarle un campo llamado "editorial" en el cual guardaremos
el nombre de la editorial.
alter table libros add editorial varchar(20);
describe libros;
Vemos que la tabla "libros" contiene un nuevo campo "editorial".
Veamos los registros:
Vemos que todos los registros tienen el campo "editorial" con valor "null".
Ahora debemos actualizar los valores para ese campo.
Podemos hacerlo en 2 pasos: 1º) consultar los códigos de las editoriales con un "select" y 2º) actualizar el campo
"editorial" de los registros de "libros" uno a uno. Luego, eliminar el campo "codigoeditorial" de "libros" y la tabla
"editoriales".
Pero podemos simplificar la tarea actualizando el campo "editorial" de todos los registros de la tabla "libros" al mismo
tiempo que realizamos el "join" para que localice los códigos de las editoriales (paso 1 y 2 en una sola sentencia). Lo
hacemos de esta manera:
update libros join editoriales on libros.codigoeditorial=editoriales.codigo set libros.editorial=editoriales.nombre;
Veamos cómo quedaron los registros luego de la actualización:

Ahora si, eliminamos el campo "codigoeditorial" de "libros":
alter table libros drop codigoeditorial;
y finalmente eliminamos la tabla "editoriales":
drop table editoriales;
Veamos todos los registros y todos los campos:

Actualización en cascada (update - join)
Eliminamos las tablas si existen:
Creamos las tablas con las siguientes estructuras:

insert into libros values (2,'Alicia en el pais de las maravillas','Lewis Carroll',1,12.33);
Queremos modificar el código de la editorial "Emece" a "9" y también todos los "codigoeditorial" de los libros de dicha
editorial. Podemos hacerlo en 3 pasos: 1) buscar el código de la editorial "Emece" (nos retorna 2); 2) actualizar el código
en la tabla "editoriales" y 3) actualizar todos los libros de dicha editorial con el valor "9". O podemos hacerlo en una sola
sentencia:
update libros as l join editoriales as e on l.codigoeditorial=e.codigo set l.codigoeditorial=9, e.codigo=9
where e.nombre='Emece';
Verificamos el cambio en ambas tablas:
Borrar registros consultando otras tablas (delete - join)
Creamos las tablas:

Queremos eliminar todos los libros de la editorial "Emece" pero no recordamos el código de dicha editorial.
Podemos hacerlo en 2 pasos:
1) consultamos el código de la editorial "Emece" y recordamos el valor devuelto (valor 2) y
2) borramos todos los libros con código de editorial "2".
O podemos realizar todo en una sola consulta:
delete libros from libros join editoriales on libros.codigoeditorial=editoriales.codigo where editoriales.nombre='Emece';
Veamos si se eliminaron los registros solicitados:
Borrar registros buscando coincidencias en otras tablas (delete - join)
Creamos las tablas:

insert into libros values (6,'Aprenda PHP','Mario Molina',9);
Queremos eliminar todos los libros cuyo código de editorial no exista en la tabla "editoriales". Podemos hacerlo en 2
pasos: 1) realizamos un left join para ver qué "codigoeditorial" en "libros" no existe en "editoriales", nos retorna el libro
con código "5", recordamos el valor, y 2) borramos todos los libros mostrados en la consulta anterior (uno solo, con
código 5).
O podemos realizar la eliminación en el mismo momento que realizamos el "left join":
delete libros from libros left join editoriales on libros.codigoeditorial=editoriales.codigo where editoriales.codigo is null;
Veamos si el libro se ha eliminado:
Eliminemos todas las editoriales de las cuales no haya libros:
delete editoriales from editoriales left join libros on libros.codigoeditorial=editoriales.codigo where libros.codigo is null;
Veamos si se ha eliminado:
Borrar registros en cascada (delete - join)
almacena el nombre de las distintas editoriales y sus códigos. Eliminamos ambas tablas si existen:
Creamos las tablas:

La librería ya no trabaja con la editorial "Emece", entonces quiere eliminar dicha editorial de la tabla "editoriales" y todos
los libros de "libros" de esta editorial. Podemos hacerlo en 2 pasos: 1) buscar el código de la editorial "Emece" y
almacenarlo en una variable, 2) eliminar la editorial con código igual al valor de la variable de "editoriales" y 3) eliminar
todos los libros cuyo código de editorial sea igual a la variable, de la tabla "libros".
O podemos hacerlo en una sola consulta:
delete libros,editoriales from libros join editoriales on libros.codigoeditorial=editoriales.codigo
where editoriales.nombre='Emece';
La sentencia anterior elimina de la tabla "editoriales" la editorial "Emece" y de la tabla "libros" todos los registros con
código de editorial correspondiente a "Emece".
Chequear y reparar tablas (check - repair)
Eliminamos la tabla "libros" si existe:
Creamos la tabla:
create table libros(codigo int unsigned auto_increment, titulo varchar(40), autor varchar(30), precio decimal(5,2)
Vamos a chequear el estado de la tabla:
check table libros;
Nos devuelve la siguiente información:
"Table" "Op" "Msg_type" "Msg_text"
libros check status OK
Para realizar un chequeo rápido de la tabla "libros" y verificar si se cerró correctamente tecleamos:
check table libros fast quick;
Si el resultado indica que la tabla está corrupta podemos emplear "repair table" para repararla:
repair table libros;
Encriptación de datos (encode - decode)
Retomamos la tabla "usuarios".
Creamos la tabla:
create table usuarios (nombre varchar(30),clave varchar(10));
Podemos ingresar registros encriptando la clave:
insert into usuarios values ('MarioPerez',encode('Marito','octubre'));
La forma más segura es no transferir la contraseña a través de la conexión, para ello podemos almacenar la clave en una
variable y luego insertar la clave encriptada:
select @clave:=encode('RealMadrid','ganador');
insert into usuarios values ('MariaGarcia',@clave);
Veamos los registros ingresados:
Desencriptamos la clave del usuario "MarioPerez":
select decode(clave,'octubre') from usuarios where nombre='MarioPerez';
Desencriptamos la clave del usuario "MariaGarcia":
select decode(clave,'ganador') from usuarios where nombre='MariaGarcia';
Guardamos la clave para el siguiente usuario en una variable llamada "@clavecodificada" y luego ingresamos el registro
con la clave encriptada:
select @clavecodificada:=encode('River','SQL');
insert into usuarios values ('JuanJoseTorres',@clavecodificada);
Guardamos la clave para el siguiente usuario en una variable llamada "@clavecodificada" y luego ingresamos el registro
con la clave encriptada, usamos la misma contraseña para la encriptación:
select @clavecodificada:=encode('Boca','SQL');
insert into usuarios values ('AnaMariaJuarez',@clavecodificada);
Ahora desencriptamos las claves al momento de la consulta los usuarios:
select decode(clave,'SQL') from usuarios;
Note que se muestran aquellas claves que fueron encriptadas con la contraseña "SQL", las demás fueron mal
desencriptadas porque la contraseña al encriptarlas fue otra.
Otras sentencias
ALTER TABLE `clientes` AUTO_INCREMENT=10
Sirve para resetear el auto incrementable, se continúa con el siguiente número del último registro encontrado.
Otra forma de borrar y resetar a la vez es usar la función TRUNCATE de MySQL, esta función limpia la tabla de registros y
si tiene un campo autoincremental lo resetea.
TRUNCATE `clientes`

Taller de Sentencias Utiles en MySQL PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Taller de Sentencias Utiles en MySQL PDF

Caricato da

Copyright:

Formati disponibili

PROGRAMACION DE SOFTWARE TALLER DE BASES DE DATOS - SQL

drop table if exists usuarios;

drop table if exists usuarios;

Ingresemos algunos registros con valores inválidos y veamos qué sucede:

Visualizamos la estructura de la tabla:

Ingresamos algunos registros:

Ingresamos algunos registros:

Ingresamos algunos registros:

Los libros se prestan por 5 días.

insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('El aleph','22543987','2006-08-

insert into prestamos (titulo,documento,fechaPrestamo,fechaDevolucion) values ('Manual de geografia 5

Ahora utilizaremos la función "current_date" para la fecha de préstamo:

Instructor Victor Rincon

Ingresamos algunos registros:

Muestra un registro, porque sólo uno cumple con ambas condiciones.

Ingresamos algunos registros:

Ahora usamos "between" y confirmamos que la salida es la misma:

Seleccionamos los libros cuyo autor no es 'Paenza' ni 'Borges' usamos:

Realizamos la misma consulta, pero esta vez con "in" :

Ingresamos algunos registros:

Recuperamos los libros cuyo autor sea igual a la cadena "Borges":

Recuperamos todos los registros cuyo autor contenga la cadena "Borges":

Para seleccionar todos los libros que comiencen con "A":

Para seleccionar todos los libros que no comiencen con "A":

Buscamos todos los libros de "Harry Potter":

Todos los libros sobre "PHP":

Búsqueda de patrones (regexp)

Ingresamos algunos registros:

Para buscar libros cuyos títulos contengan la cadena "Ma" usamos:

Para ver los títulos que comienzan con "A" tecleamos:

Para ver los títulos que terminan en "HP" usamos:

Para buscar autores que tengan 6 caracteres exactamente usamos:

Para buscar autores que tengan al menos 6 caracteres usamos:

Para buscar títulos que contengan 2 letras "a" usamos:

Ingresamos algunos registros:

Para averiguar la cantidad de registros de la tabla "libros" usamos la función "count(*)":

Para saber la cantidad de libros de la editorial "Planeta" tecleamos:

Para averiguar la cantidad de libros que contienen la cadena "Borges" tecleamos:

Funciones de agrupamiento (count - max - min - sum - avg)

Solicitamos la suma de las cantidades de los libros de la editorial "Planeta":

Si queremos saber cuál es el mayor precio de los libros usamos:

Verifiquemos el resultado seleccionado los libros de "PHP" y calculando el promedio manualmente:

Ingresamos algunos registros:

Para saber la cantidad de visitantes que tenemos de cada ciudad tecleamos:

Queremos conocer el total de las compras agrupadas por sexo:

Para obtener el máximo y mínimo valor de compra agrupados por sexo:

Queremos saber el promedio del valor de compra agrupados por ciudad:

Contamos los registros y agrupamos por 2 campos, "ciudad" y "sexo":

Instructor Victor Rincon

Usando la palabra clave "desc" obtenemos la salida ordenada en forma descendente:

Agregamos algunos registros:

Queremos averiguar la cantidad de libros agrupados por editorial:

Necesitamos el promedio de los precios de los libros agrupados por editorial:

Ahora, sólo queremos aquellos cuyo promedio supere los 25 pesos:

Ingresamos algunos registros:

Para obtener la lista de autores sin repetición usamos "distinct":

Esta sentencia cuenta los registros que tienen autor.

Para una consulta en la cual los nombres no se repitan tecleamos:

Instructor Victor Rincon

Queremos conocer los distintos autores de la editorial "Planeta":

Trabajamos con la tabla "libros" de una librería.

Agregamos algunos registros:

Colocamos el alias "Nombre de editorial" para el campo "editorial":