jueves, 8 de noviembre de 2012

60 - Funciones de control de flujo (if)


Trabajamos con las tablas "libros" de una librería.

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.
También podemos usar la función "if".

"if" es una función a la cual se le envían 3 argumentos: el segundo y tercer argumento corresponden a los valores que retornará en caso que el primer argumento (una expresión de comparación) sea "verdadero" o "falso"; es decir, si el primer argumento es verdadero, retorna el segundo argumento, sino retorna el tercero.
Veamos el ejemplo:

 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").

Veamos otros ejemplos.

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").

Queremos saber si la cantidad de libros por editorial supera los 4 o no:

 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").


PROBLEMA RESUELTO

Trabajamos con las tablas "libros" de una librería.

Eliminamos la tabla, si existe.

Creamos la tabla:

 create table libros(
  codigo int unsigned auto_increment,
  titulo varchar(40) not null,
  autor varchar(30),
  editorial varchar(30),
  precio decimal(5,2) unsigned,
  primary key (codigo)
 );

Ingresamos algunos registros:

 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".



PROBLEMA PROPUESTO


Una empresa registra los datos de sus empleados en una tabla llamada "empleados".

1- Elimine la tabla "empleados" si existe:

2- Cree la tabla:
 create table empleados(
  documento char(8) not null,
  nombre varchar(30) not null,
  sexo char(1),
  domicilio varchar(30),
  fechaingreso date,
  fechanacimiento date,
  sueldobasico decimal(5,2) unsigned,
  primary key(documento)
);

3- Ingrese algunos registros:
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('22333111','Juan Perez','m','Colon 123','1990-02-01','1970-05-10',550,0);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('25444444','Susana Morales','f','Avellaneda 345','1995-04-01','1975-11-06',650,2);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('20111222','Hector Pereyra','m','Caseros 987','1995-04-01','1965-03-25',510,1);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('30000222','Luis LUque','m','Urquiza 456','1980-09-01','1980-03-29',700,3);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('20555444','Maria Laura Torres','f','San Martin 1122','2000-05-15','1965-12-22',400,3);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('30000234','Alberto Soto','m','Peru 232','2003-08-15','1989-10-10',420,1);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('20125478','Ana Gomez','f','Sarmiento 975','2004-06-14','1976-09-21',350,2);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaingreso,fechanacimiento,sueldobasico,hijos)
  values ('24154269','Ofelia Garcia','f','Triunvirato 628','2004-09-23','1974-05-12',390,0);
 insert into empleados 
(documento,nombre,sexo,domicilio,fechaIngreso,fechaNacimiento,sueldoBasico,hijos)
  values ('304154269','Oscar Torres','m','Hernandez 1234','1996-04-10','1978-05-02',400,0);

4- Es política de la empresa festejar cada fin de mes, los cumpleaños de todos los empleados que 
cumplen ese mes. Si los empleados son de sexo femenino, se les regala un ramo de rosas, si son de 
sexo masculino, una corbata. La secretaria de la Gerencia necesita saber cuántos ramos de rosas y 
cuántas corbatas debe comprar para el mes de mayo:
 5- Además, si el empleado cumple 10,20,30,40... años de servicio, se le regala una placa 
recordatoria. La secretaria de Gerencia necesita saber la cantidad de años de servicio que cumplen 
los empleados que ingresaron en el mes de abril para encargar dichas placas:
 
6- La empresa paga un sueldo adicional por hijos a cargos. para un sueldo básico menor o igual a 
$500 el salario familiar por hijo es de $300, para un sueldo superior, el monto es de $150 por 
hijo. Muestre el nombre del empleado, el sueldo básico, la cantidad de hijos a cargo, el valor del 
salario por hijo, el valor total del salario familiar y el sueldo final con el salario familiar 
incluido de todos los empleados con hijos a cargo:
 


Otros problemas:

 

A) La empresa que provee de luz a los usuarios de un municipio, almacena en una tabla algunos datos 
de los usuarios y el monto a cobrar:
- documento,
- domicilio, 
- monto a pagar,
- fecha de vencimiento.
Si la boleta no se paga hasta el día del vencimiento, inclusive, se incrementa al monto, un 1% del 
monto cada día de atraso.

1- Elimine la tabla "luz", si existe.

2- Cree la tabla:
 create table luz(
  documento char(8) not null,
  domicilio varchar(30),
  monto decimal(5,2) unsigned,
  vencimiento date
);

3- Ingrese algunos registros con fechas de vencimiento anterior a la fecha actual (vencidas) y 
posteriores a la fecha actual (no vencidas).

4- Ingrese para el mismo usuario (igual documento) 2 boletas vencidas.

5- Muestre el documento del usuario, la fecha de vencimiento, la fecha actual (en que efectúa el 
pago) y si debe pagar recargo o no.:
 
La función "datediff()" retorna la cantidad de días de diferencia entre las fecha enviadas como 
argumento, si el primer argumento es anterior al segundo, el valor retornado es negativo, por ello, 
colocamos como condición que el valor retornado por esta función sea mayor a cero, es decir, que la 
fecha actual sea posterior a la del vencimiento, así las vencidas mostrarán "Si" y las que no hayan 
vencido "No".

6- Si un usuario tiene más de una boleta vencida se le corta el servicio. Muestre el documento y la 
cantidad de boletas vencidas de cada usuario que tenga boletas vencidas y muestre un 
mensaje "Cortar servicio" si tiene 2 o más vencidas:
 

B) Un profesor guarda los promedios de sus alumnos de un curso en una tabla llamada "alumnos".

1- Elimine la tabla si existe.

2- cree la tabla:
 create table alumnos(
  legajo char(5) not null,
  nombre varchar(30),
  promedio decimal(4,2)
);

3- Ingrese los siguientes registros:
 insert into alumnos values(3456,'Perez Luis',8.5);
 insert into alumnos values(3556,'Garcia Ana',7.0);
 insert into alumnos values(3656,'Ludueña Juan',9.6);
 insert into alumnos values(2756,'Moreno Gabriela',4.8);
 insert into alumnos values(4856,'Morales Hugo',3.2);

4- Si el alumno tiene un promedio superior o igual a 4, muestre un mensaje "aprobado" en caso 
contrario "reprobado":
 5- Es política del profesor entregar una medalla a quienes tengan un promedio igual o superior a 9. 
Muestre los nombres y promedios de los alumnos y un mensaje "medalla" a quienes cumplan con ese 
requisito:
 
C) Una playa de estacionamiento guarda cada día los datos de los vehículos que ingresan a la playa 
en una tabla llamada "vehiculos".

1- Elimine la tabla, si existe.

2- Cree la tabla:
 create table vehiculos(
  patente char(6) not null,
  tipo char(4),
  horallegada time not null,
  horasalida time,
  primary key(patente,horallegada)
 );

3- Ingrese algunos 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','15:10');
 insert into vehiculos (patente,tipo,horallegada,horasalida)
  values('HGF123','auto','9:30','18: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');

4- Muestre la patente, la hora de llegada y de salida de todos los vehículos, más una columna que 
calcule la cantidad de horas que estuvo cada vehículo en la playa, sin considerar los que aún no se 
retiraron de la playa:
 
5- Se cobra 1 peso por hora. Pero si un vehículo permanece en la playa 4 horas, se le cobran 3 
pesos, es decir, no se le cobra la cuarta hora; si está 8 horas, se cobran 6 pesos, y así 
sucesivamente. Muestre la patente, la hora de llegada y de salida de todos los vehículos, más la 
columna que calcule la cantidad de horas que estuvo cada vehículo en la playa (sin considerar los 
que aún no se retiraron de la playa) y otra columna utilizando "if" que muestre la cantidad de 
horas gratis:
 

D) Un teatro con varias salas guarda la información de las entradas vendidas en una tabla 
llamada "entradas".

1- Elimine la tabla, si existe.

2- Cree la tabla:
 create table entradas(
  sala tinyint unsigned,
  fecha date,
  hora time,
  capacidad smallint unsigned,
  entradasvendidas smallint unsigned,
  primary key(sala,fecha,hora)
 );

3- Ingrese algunos registros:
 insert into entradas values(1,'2006-05-10','20:00',300,50);
 insert into entradas values(1,'2006-05-10','23:00',300,250);
 insert into entradas values(2,'2006-05-10','20:00',400,350);
 insert into entradas values(2,'2006-05-11','20:00',400,380);
 insert into entradas values(2,'2006-05-11','23:00',400,400);
 insert into entradas values(3,'2006-05-12','20:00',350,350);
 insert into entradas values(3,'2006-05-12','22:30',350,100);
 insert into entradas values(4,'2006-05-12','20:00',250,0);

4- Muestre todos los registros y un mensaje si las entradas para una función están agotadas:
5- Muestre todos los datos de las funciones que tienen vendidad entradas y muestre un mensaje si se 
vendió más o menos de la mitad de la capacidad de la sala:
 

59 - Tipos de datos blob y text.


Los tipos "blob" o "text" son bloques de datos. Tienen una longitud de 65535 caracteres.

Un "blob" (Binary Large Object) puede almacenar un volumen variable de datos. La diferencia entre "blob" y "text" es que "text" diferencia mayúsculas y minúsculas y "blob" no; esto es porque "text" almacena cadenas de caracteres no binarias (caracteres), en cambio "blob" contiene cadenas de caracteres binarias (de bytes).

No permiten valores "default".

Existen subtipos:

- tinyblob o tinytext: longitud máxima de 255 caracteres.
- mediumblob o mediumtext: longitud de 16777215 caracteres.
- longblob o longtext: longitud para 4294967295 caracteres.

Se utiliza este tipo de datos cuando se necesita almacenar imágenes, sonidos o textos muy largos.

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.

La tabla contiene un campo de tipo "text" llamado "sinopsis":

- codigo: int unsigned auto_increment, clave primaria,
- nombre: varchar(40),
- actor: varchar(30),
- duracion: tinyint unsigned,
- sinopsis: text,

Se ingresan los datos en un campo "text" o "blob" como si fuera de tipo cadena de caracteres, es decir, entre comillas:

 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');

Para buscar un texto en un campo de este tipo usamos "like":

 select * from peliculas
  where sinopsis like '%Drama%';

No se pueden establecer valores por defecto a los campos de tipo "blob" o "text", es decir, no aceptan la cláusula "default" en la definición del campo.


PROBLEMA RESUELTO

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.

Eliminamos la tabla si existe:

 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)  
 );

Ingresamos algunos registros:

 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%'; 



PROBLEMA PROPUESTO

Una inmobiliaria guarda los datos de sus inmuebles en venta en una tabla llamada "inmuebles".

1- Elimine la tabla si existe:
 
2- Cree la tabla:
 create table inmuebles(
  codigo int unsigned auto_increment,
  domicilio varchar(30),
  barrio varchar(20),
  detalles text,
  primary key(codigo)
 );

3- Ingrsee algunos registros:
 insert into inmuebles values(1,'Colon 123','Centro','patio, 3 dormitorios, garage doble, pileta, 
asador, living, cocina, comedor, escritorio, 2 baños');
 insert into inmuebles values(2,'Caseros 345','Centro','patio, 2 dormitorios, cocina- comedor, 
living');
 insert into inmuebles values(3,'Sucre 346','Alberdi','2 dormitorios, problemas de humedad');
 insert into inmuebles values(4,'Sarmiento 832','Gral. Paz','3 dormitorios, garage, 2 patios');
 insert into inmuebles values(5,'Avellaneda 384','Centro',' 2 patios, 2 dormitorios, garage');

4- Busque todos los inmuebles que tengan "patio":
 


Otros problemas:

 

Una librería guarda la información de sus libros en una tabla llamada "libros".

1- Elimine la tabla si existe:
 
2- Cree la tabla con un campo "blob" en el cual se pueda almacenar los temas principales que trata 
el libro:
 create table libros(
  codigo int unsigned auto_increment,
  titulo varchar(40),
  autor varchar(30),
  editorial varchar(20),
  temas blob,
  precio decimal(5,2) unsigned,
  primary key(codigo)
 );

3- Ingrese algunos registros.:
 insert into libros values(1,'Aprenda PHP','Mario Molina','Emece',
 'Instalacion de PHP.
  Palabras reservadas.
  Sentencias basicas.
  Definicion de variables.',
 45.6);
 
 insert into libros values(2,'Java en 10 minutos','Mario Molina','Planeta',
 'Instalacion de Java en Windows.
  Instalacion de Java en Linux.
  Palabras reservadas.
  Sentencias basicas.
  Definir variables.',
 55);

 insert into libros values(3,'PHP desde cero','Joaquin Perez','Planeta',
 'Instalacion de PHP.
  Instrucciones basicas.
  Definición de variables.',
 50);

4- Busque todos los libros sobre "PHP" que incluyan el tema "variables":
 
5- Busque los libros de "Java" que incluyan el tema "Instalacion" o "Instalar":
 

58 - Tipo de dato set.


El tipo de dato "set" representa un conjunto de cadenas.

Puede tener 1 ó más valores que se eligen de una lista de valores permitidos que se especifican al definir el campo y se separan con comas. Puede tener un máximo de 64 miembros. Ejemplo: un campo definido como set ('a', 'b') not null, permite los valores 'a', 'b' y 'a,b'. Si carga un valor no incluido en el conjunto "set", se ignora y almacena cadena vacía.

Es similar al tipo "enum" excepto que puede almacenar más de un valor en el campo.

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.

Para definir un campo de tipo "set" usamos 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');

Para ingresar un valor que contenga más de un elemento del conjunto, se separan por comas, por ejemplo:

 insert into postulantes (documento,nombre,idioma)
  values('23555444','Juana Pereyra','ingles,italiano');

No importa el orden en el que se inserten, se almacenan en el orden que han sido definidos, por ejemplo, si ingresamos:

 insert into postulantes (documento,nombre,idioma)
  values('23555444','Juana Pereyra','italiano,ingles');

en el campo "idioma" guardará 'ingles,italiano'.

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, por ejemplo, si ingresamos:

 insert into postulantes (documento,nombre,idioma)
  values('23555444','Juana Pereyra','italiano,ingles,italiano');
en el campo "idioma" guardará 'ingles,italiano'.

Si ingresamos un valor que no está en la lista "set", se ignora y se almacena una cadena vacía, por ejemplo:

 insert into postulantes (documento,nombre,idioma) 
  values('22255265','Juana Pereyra','frances');

Si un "set" permite valores nulos, el valor por defecto es "null"; si no permite valores nulos, el valor por defecto es una cadena vacía.

Si se ingresa un valor de índice fuera de rango, coloca una cadena vacía. Por ejemplo:

 insert into postulantes (documento,nombre,idioma)
  values('22255265','Juana Pereyra',0);
 insert into postulantes (documento,nombre,idioma)
  values('22255265','Juana Pereyra',8);

Si se ingresa 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. Los valores de índice se definen en el siguiente orden, en este ejemplo:

1='ingles',
2='italiano',
3='ingles,italiano',
4='portugues',
5='ingles,portugues',
6='italiano,portugues',
7='ingles,italiano,portugues'.

Ingresamos algunos registros con valores de índice:

 insert into postulantes (documento,nombre,idioma)
   values('22255265','Juana Pereyra',2);
 insert into postulantes (documento,nombre,idioma)
  values('22555888','Juana Pereyra',3);

En el campo "idioma", con la primera inserción se almacenará "italiano" que es valor de índice 2 y con la segunda inserción, "ingles,italiano" que es el valor con índice 3.

Para búsquedas de valores en campos "set" se utiliza el operador "like" o la función "find_in_set()".

Para recuperar todos los valores que contengan la cadena "ingles" podemos usar cualquiera de las siguientes sentencias:

 select * from postulantes
  where idioma like '%ingles%';
 select * from postulantes
  where find_in_set('ingles',idioma)>0;

La función "find_in_set()" retorna 0 si el primer argumento (cadena) no se encuentra en el campo set colocado como segundo argumento. Esta función no funciona correctamente si el primer argumento contiene una coma.

Para recuperar todos los valores que incluyan "ingles,italiano" tipeamos:

 select * from postulantes
  where idioma like '%ingles,italiano%';

Para realizar búsquedas, es importante respetar el orden en que se presentaron los valores en la definición del campo; por ejemplo, si se busca el valor "italiano,ingles" en lugar de "ingles,italiano", no retornará registros.

Para buscar registros que contengan sólo 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" podemos utilizar cualquiera de las siguientes sentencias:

 select * from postulantes
  where idioma='ingles,italiano'; 
 select * from postulantes
  where idioma=3;

También podemos usar el operador "not". 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;

Los tipos "set" admiten cláusula "default".

Los bytes de almacenamiento del tipo "set" depende del número de miembros, se calcula así: (cantidad de miembros+7)/8 bytes; entonces puede ser 1,2,3,4 u 8 bytes.


PROBLEMA RESUELTO


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.

Eliminamos la tabla, si existe.

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", tipeamos:

 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;


PROBLEMA PROPUESTO

Una academia de enseñanza dicta distintos cursos de informática. Los cursos se dictan por la mañana 
(de 8 a 12 hs.) o por la tarde (de 16 a 20 hs.), distintos días a la semana. La academia guarda los 
datos de los cursos en una tabla llamada "cursos" en la cual almacena el código del curso, el tema, 
los días de la semana que se dicta, el horario, por la mañana (AM) o por la tarde (PM), la cantidad 
de clases que incluye cada curso (clases), la fecha de inicio y el costo del curso.

1- Elimine la tabla "cursos", si existe.

2- Cree la tabla "cursos" con la siguiente estructura:
 create table cursos(
  codigo tinyint unsigned auto_increment,
  tema varchar(20) not null,
  dias set ('lunes','martes','miercoles','jueves','viernes','sabado') not null,
  horario enum ('AM','PM') not null,
  clases tinyint unsigned default 1,
  fechainicio date,
  costo decimal(5,2) unsigned,
  primary key(codigo)
 );

3- Ingrese los siguientes registros:
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('PHP básico','lunes,martes,miercoles','AM',18,'2006-08-07',200);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('PHP básico','lunes,martes,miercoles','PM',18,'2006-08-14',200);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('PHP básico','sabado','AM',18,'2006-08-05',280);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('PHP avanzado','martes,jueves','AM',20,'2006-08-01',350);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('JavaScript','lunes,martes,miercoles','PM',15,'2006-09-11',150);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('Paginas web','martes,jueves','PM',10,'2006-08-08',250);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('Paginas web','sabado','AM',10,'2006-08-12',280);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('Paginas web','lunes,viernes','AM',10,'2006-08-21',200);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('Paginas web','lunes,martes,miercoles,jueves,viernes','AM',10,'2006-09-18',180);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('Paginas web','lunes,viernes','PM',10,'2006-09-25',280);
 insert into cursos (tema, dias,horario,clases,fechainicio,costo)
  values('JavaScript','lunes,martes,viernes,sabado','PM',12,'2006-09-18',150);

4- Una persona quiere inscribirse en un curso de "PHP" y sólo tiene disponibles los sábados. 
Localice los cursos de "PHP" que se dictan solamente los sábados:
 
5- Otra persona quiere aprender a diseñar páginas web, tiene disponibles todas las mañanas excepto 
los miércoles. Vea si existe algún curso que cumpla con sus necesidades:
 
6- Otra persona necesita aprender JavaScript, tiene disponibles todos las tardes excepto los jueves 
y quiere un curso que no supere las 15 clases para el mes de setiembre. Busque algún curso para 
esta persona:
 

Otros problemas:
 
A) Trabaje con la tabla "inmuebles" en la cual una inmobiliaria almacena la información referente a 
sus departamentos en venta.

1- Elimine la tabla "inmuebles" si existe.

2- Cree la tabla "inmuebles":
 create table inmuebles(
  detalles set ('estacionamiento','terraza','pileta','patio','ascensor'),
  domicilio varchar(30),
  propietario varchar(30),
  precio decimal (9,2) unsigned
 );

3- Ingrese algunos registros:
 insert into inmuebles (detalles,precio) 
  values('terraza,pileta',50000);
 insert into inmuebles (detalles,precio) 
  values('patio,terraza,pileta',60000);
 insert into inmuebles (detalles,precio) 
  values('ascensor,terraza,pileta',80000);
 insert into inmuebles (detalles,precio) 
  values('patio,estacionamiento',65000);
 insert into inmuebles (detalles,precio) 
  values('estacionamiento',90000);

4- Seleccione todos los datos de los departamentos con terraza:
 
5- Seleccione los departamentos que no tiene ascensor:
 
6- Muestre los inmuebles que tengan terraza y pileta solamente:
7-Muestre los inmuebles que no tengan ascensor y si estacionamiento, además de otros detalles:
 
8- Ingrese un registro con valor inexistente en "detalles":
 
9 Ingrese un registro sin valor para "detalles":
 

B) Una empresa de turismo vende paquetes de viajes a México y almacena la información referente a 
los mismos en una tabla llamada "viajes":

1- Elimine la tabla si existe.

2- Cree la tabla:
 create table viajes(
  codigo int unsigned auto_increment,
  nombre varchar(50),
  pension enum ('no','media','completa') not null,
  ciudades set ('Acapulco','DF','Cancun','Puerto Vallarta','Cuernavaca') not null,
  dias tinyint unsigned,
  salida date,
  precioporpersona decimal(8,2) unsigned,
  primary key(codigo)
 );

3- Ingrese los siguientes registros:
 insert into viajes (nombre,pension,ciudades,dias,salida)
  values ('Mexico mágico','completa','DF,Acapulco',15,'2005-12-01');
 insert into viajes (nombre,pension,ciudades,dias,salida)
  values ('Mexico especial','media','DF,Acapulco,Cuernavaca',28,'2005-05-10');
 insert into viajes (nombre,pension,ciudades,dias,salida)
  values ('Mexico unico','no','Acapulco,Puerto Vallarta',7,'2005-11-15');
 insert into viajes (nombre,pension,ciudades,dias,salida)
  values ('Mexico DF','no','DF',5,'2005-10-25');
 insert into viajes (nombre,pension,ciudades,dias,salida)
  values ('Mexico caribeño','completa','Cancun',15,'2005-10-25');

4- Ingrese un registro sin valor para el campo "ciudades":
 insert into viajes (nombre,pension,dias,salida)
  values ('Mexico maravilloso','completa',5,'2005-10-25');

5- Seleccione todos los viajes que incluyan "Acapulco":

6- Seleccione todos los viajes que no incluyan "Acapulco" y que incluyan pensión completa:
 
7- Muestre los viajes que incluyan "Puerto Vallarta" o "Cuernavaca":

57 - Tipo de dato enum.


Además de los tipos de datos ya conocidos, existen otros que analizaremos ahora, los tipos "enum" y "set".

El tipo de dato "enum" representa una enumeración. Puede tener un máximo de 65535 valores distintos. Es una cadena cuyo valor se elige de una lista enumerada de valores permitidos que se especifica al definir el campo. Puede ser una cadena vacía, incluso "null".

Los valores presentados como permitidos tienen un valor de índice que comienza en 1.

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.

Para definir un campo de tipo "enum" usamos la siguiente sintaxis al crear la tabla:

 create table postulantes(
  numero int unsigned auto_increment,
  documento char(8),
  nombre varchar(30),
  estudios enum('ninguno','primario','secundario', 'terciario','universitario'),
  primary key(numero)
 );

Los valores presentados deben ser cadenas de caracteres.

Si un "enum" permite valores nulos, el valor por defecto el "null"; si no permite valores nulos, el valor por defecto es el primer valor de la lista de permitidos.

Si se ingresa 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,estudios)
 values('22255265','Juana Pereyra',5);

En el campo "estudios" almacenará "universitario" que es valor de índice 5.

Si se ingresa un valor inválido, puede ser un valor no presente en la lista o un valor de índice fuera de rango, coloca una cadena vacía. Por ejemplo:

 insert into postulantes (documento,nombre,estudios)
  values('22255265','Juana Pereyra',0);
 insert into postulantes (documento,nombre,estudios)
  values('22255265','Juana Pereyra',6);
 insert into postulantes (documento,nombre,estudios)
  values('22255265','Juana Pereyra','PostGrado');

En los 3 casos guarda una cadena vacía, en los 2 primeros porque los índices ingresados están fuera de rango y en el tercero porque el valor no está incluido en la lista de permitidos.

Esta cadena vacía de error, se diferencia de una cadena vacía permitida porque la primera 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;

El índice de un valor "null" es "null".

Para seleccionar registros con un valor específico de un campo enumerado usamos "where", por ejemplo, queremos todos los postulantes con estudios universitarios:

 select * from postulantes
  where estudios='universitario';

Los tipos "enum" aceptan cláusula "default".

Si el campo está definido como "not null" e intenta almacenar el valor "null" aparece un mensaje de error y la sentencia no se ejecuta.

Los bytes de almacenamiento del tipo "enum" depende del número de valores enumerados.


PROBLEMA RESUELTO

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)
 );

Ingresamos algunos registros:

 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);


PROBLEMA PROPUESTO


Trabajamos con la tabla "empleados" de una empresa.

1- Elimine la tabla empleados, si existe.

2- Cree la tabla con la siguiente estructura:
 create table empleados(
  documento char(8),
  nombre varchar(30),
  sexo char(1),
  estadocivil enum('soltero','casado','divorciado','viudo') not null,
  sueldobasico decimal(6,2),
  primary key(documento)
);

3- Ingrese algunos registros:
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('22333444','Juan Lopez','m','soltero',300);
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('23333444','Ana Acosta','f','viudo',400);

4- Intente ingresar un valor "null" para el campo enumerado:
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('25333444','Ana Acosta','f',null,400);

5- Ingrese resgistros con valores de índice para el campo "estadocivil":
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('26333444','Luis Perez','m',1,400);
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('26336444','Marcelo Torres','m',3,460);

6- Ingrese un valor inválido, uno no presente en la lista y un valor de índice fuera de rango 
(guarda una cadena vacía):
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('29333444','Lucas Perez','m',0,400);
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('30336444','Federico Garcia','m',5,450);
 insert into empleados (documento,nombre,sexo,estadocivil,sueldobasico)
  values ('31333444','Karina Sosa','f','Concubino',500);

7- Seleccione todos los empleados solteros:
 
8- Seleccione todos los empleados viudos usando el número de índice de la enumeración:
 


Otros problemas:

 

A) Una empresa de turismo vende paquetes de viajes y almacena la información referente a los mismos 
en una tabla llamada "viajes":

1- Elimine la tabla si existe.

2- Cree la tabla:
 create table viajes(
  codigo int unsigned auto_increment,
  nombre varchar(50),
  pension enum ('no','media','completa') not null,
  hotel enum ('1','2','3','4','5'),/* cantidad de estrellas*/
  dias tinyint unsigned,
  salida date,
  precioporpersona decimal(8,2) unsigned,
  primary key(codigo)
 );

4- Ingrese algunos registros:
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Mexico mágico','completa','4',15,'2005-12-01');
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Europa fantastica','media','5',28,'2005-05-10');
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Caribe especial','no','3',7,'2005-11-25');

5- Intente ingresar un valor "null" para el campo "pension":
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Mexico maravilloso',null,'4',15,'2005-12-01');

6- Ingrese valor nulo para el campo "hotel"
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Mexico especial','media',3,18,'2005-11-01');

7- Ingrese un valor inválido, no presente en la lista de "pension" (guarda una cadena vacía):
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Caribe especial','ninguna','4',18,'2005-11-01');

8- Ingrese un valor de índice fuera de rango para el campo "hotel":
 insert into viajes (nombre,pension,hotel,dias,salida)
  values ('Venezuela única','no',6,18,'2005-11-01');

9- Seleccione todos los viajes que incluyen media pensión:
 
10- Seleccione todos los viajes que incluyen un hotel de 4 estrellas:
 

B) Una inmobiliaria vende inmuebles; los inmuebles pueden ser: casa, departamento, local o terreno.

1- Elimine la tabla "inmuebles" si existe.

2- Cree la tabla "inmuebles" para registrar la siguiente información:
 - tipo de inmueble: tipo enum (casa,dpto,local,terreno), not null,
 - domicilio: varchar(30),
 - propietario: nombre del dueño,
 - precio: decimal hasta $999999.99 positivo.

3- Ingrese algunos registros.

4- Seleccione el domicilio y precio de todos los departamentos en alquiler.

5- Seleccione el domicilio, propietario y precio de todos los locales en venta.

6- Seleccione el domicilio y precio de todas las casas disponibles.

56 - renombrar tablas (alter table - rename - rename table)


Podemos cambiar el nombre de una tabla con "alter table".

Para cambiar el nombre de una tabla llamada "amigos" por "contactos" usamos esta sintaxis:

 alter table amigos rename contactos;

Entonces usamos "alter table" seguido del nombre actual, "rename" y el nuevo nombre.

También podemos cambiar el nombre a una tabla usando la siguiente sintaxis:

 rename table amigos to contactos;

La renombración se hace de izquierda a derecha, con lo cual, si queremos intercambiar los nombres de dos tablas, debemos tipear lo siguiente:

 rename table amigos to auxiliar,
  contactos to amigos,
  auxiliar to contactos;

PROBLEMA RESUELTO

Eliminamos las tablas "amigos" y "contactos" si existen.

Creamos la tabla "amigos" con la siguiente estructura:

 create table amigos(
  nombre varchar(30),
  domicilio varchar(30),
  telefono varchar (11)
 );

Para cambiar el nombre de nuestra tabla "amigos" por "contactos" usamos esta sintaxis:

 alter table amigos rename contactos;

Veamos si existen las tablas "amigos" y "contactos":

 show tables;

La tabla "amigos" ya no existe, si "contactos".

También podemos cambiar el nombre a una tabla usando la siguiente sintaxis:

 rename table contactos to amigos;

Así cambiamos el nombre de la tabla "contactos" por "amigos".

Veamos si existen las tablas "amigos" y "contactos":

 show tables;

La tabla "contactos" ya no existe, si "amigos".

Podemos intercambiar los nombres de dos tablas. Por ejemplo, tenemos una tabla llamada "amigos" con los datos de nuestros amigos y otra tabla "contactos" con los datos de compañeros de trabajo, ambas con la misma estructura.

Elimine las tablas "amigos" y "contactos" si existen.

Créelas:

 create table amigos(
  nombre varchar(30),
  domicilio varchar(30),
  telefono varchar (11)
 );
 create table contactos(
  nombre varchar(30),
  domicilio varchar(30),
  telefono varchar (11)
 );

Ingresemos algunos registros:

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

 insert into amigos (nombre,telefono)
  values('Perez Luis','4565657'); 
 insert into amigos (nombre,telefono)
  values('Lopez','4223344'); 

Para intercambiar los nombres de estas dos tablas, debemos tipear lo siguiente:

 rename table amigos to auxiliar,
  contactos to amigos,
  auxiliar to contactos;

Verifiquemos el cambio de nombre:

 select * from amigos;
 select * from contactos;


PROBLEMA PROPUESTO

Trabajamos con la tabla "peliculas" de un video club.

1- Elimine la tabla, si existe.

2- Cree la tabla "peliculas":
 create table peliculas(
  codigo int unsigned auto_increment,
  titulo varchar(40),
  duracion tinyint unsigned
 );

3- Cambie el nombre de la tabla por "films" con "alter table":
 
4- Vea si existen las tablas "peliculas" y "films":
 
5- Cambie nuevamente el nombre, de la tabla "films" por "peliculas" usando "rename":

6- vea si existen las tablas:
 


Otros problemas:

 

Una empresa tiene almacenados los datos de sus clientes en una tabla llamada "clientes" y los datos 
de sus empleados en otra tabla denominada "empleados".

1- Elimine ambas tablas si existen.

2- Cree las tablas dándoles el nombre equivocado, es decir, de el nombre "clientes" a la tabla que 
contiene los datos de los empleados y el nombre "empleados" a la tabla con la informaciómn de los 
clientes:
 create table clientes(
  documento char(8) not null,
  nombre varchar(30),
  domicilio varchar(30),
  fechaingreso date,
  sueldo decimal(6,2) unsigned
 );

 create table empleados(
  documento char(8) not null,
  nombre varchar(30),
  domicilio varchar(30),
  ciudad varchar(30),
  provincia varchar(30)
 );

3- Vea la estructura de ambas tablas:
 
4- Intercambie los nombres de las dos tablas:
 
5- Verifique el cambio de nombre:
 
6- Vea si existe la tabla "auxiliar":
  

martes, 6 de noviembre de 2012

55 - Borrado de índices (alter table - drop index)



Los índices común y únicos se eliminan con "alter table".

Trabajamos con la tabla "libros" de una librería, que tiene los siguientes campos e índices:

 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),
  unique i_tituloeditorial (titulo,editorial)
 );

Para eliminar un índice usamos la siguiente sintaxis:

 alter table libros
  drop index i_editorial;

Usamos "alter table" y "drop index" seguido del nombre del índice a 
borrar.

Para eliminar un índice único usamos la misma sintaxis:

 alter table libros
  drop index i_tituloeditorial;



PROBLEMA RESUELTO


Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla "libros" si existe.
Creamos la tabla "libros", con los siguientes campos e índices:
 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),
  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:
 show index from libros;
vemos que solamente queda el índice "PRIMARY", este índice no se puede eliminar; se elimina automáticamente al eliminar la clave primaria.
PROBLEMA PROPUESTO

Trabajamos con la tabla "alumnos" en la cual un instituto de enseñanza guarda 
los datos de sus alumnos.

1- Elimine la tabla "alumnos" si existe.

2- Cree la tabla con los siguientes índices:
 create table alumnos(
  año year not null,
  numero int unsigned not null,
  nombre varchar(30),
  documento char(8) not null,
  domicilio varchar(30),
  ciudad varchar(20),
  provincia varchar(20),  
  primary key(año,numero),
  unique i_documento (documento),
  index i_ciudadprovincia (ciudad,provincia),
 );

3- Vea los índices de la tabla.

4- Elimine el índice único:
 
5- Elimine el índice común:
 
6- Vea los índices:
 

Otros problemas: 

Una clínica registra las consultas de los pacientes en una tabla llamada 
"consultas".

1- Elimine la tabla si existe.

2- Cree la tabla con la siguiente estructura:
create table consultas(
  fecha date,
  numero int unsigned,
  documento char(8) not null,
  obrasocial varchar(30),
  medico varchar(30),
  primary key(fecha,numero),
  unique i_consulta(documento,fecha,medico),
  index i_medico (medico),
  index i_obrasocial (obrasocial)
 );

3- Vea los índices de la tabla.

4- Elimine el índice único:
 
5- Elimine los índices comumes:
 
6- Vea los índices:
 


54 - Agregar índices(alter table - add index)



Aprendimos a crear índices al momento de crear una tabla. También a crearlos luego de haber creado la tabla, con "create index". También podemos agregarlos a una tabla usando "alter table".

Creamos la tabla "libros":

 create table libros(
  codigo int unsigned,
  titulo varchar(40),
  autor varchar(30),
  editorial varchar (20),
  precio decimal(5,2) unsigned,
  cantidad smallint unsigned
 );

Para agregar un índice común por el campo "editorial" usamos la siguiente 
sentencia:

 alter table libros
  add index i_editorial (editorial);

Usamos "alter table" junto con "add index" seguido del nombre que le daremos 
al índice y entre paréntesis el nombre de el o los campos por los cuales se 
indexará.

Para agregar un índice único multicampo, por los campos "titulo" y "editorial", usamos la siguiente sentencia:

 alter table libros
  add unique index i_tituloeditorial (titulo,editorial);

Usamos "alter table" junto con "add unique index" seguido del nombre que le 
daremos al índice y entre paréntesis el nombre de el o los campos por los cuales 
se indexará.

En ambos casos, para índices comunes o únicos, si no colocamos nombre de índice, se coloca uno por defecto, como cuando los creamos junto con la tabla.


PROBLEMA RESUELTO


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

Eliminamos la tabla si existe.

Creamos la tabla "libros" con la siguiente estructura:

 create table libros(
  codigo int unsigned,
  titulo varchar(40),
  autor varchar(30),
  editorial varchar (20),
  precio decimal(5,2) unsigned,
  cantidad smallint unsigned
 );

Para agregar un índice común por el campo "editorial" tipeamos:

 alter table libros
  add index i_editorial (editorial);

Para agregar un índice único multicolumna por los campos "titulo" y 
"editorial", tipeamos:

 alter table libros
  add unique index i_tituloeditorial (titulo,editorial);

Visualicemos los índices con:

 show index from libros;

Aparecen nuestros 2 índices agregados.


PROBLEMA PROPUESTO


Trabaje con la tabla "alumnos" en el cual un instituto de enseñanza guarda los 
datos de sus alumnos.

1- Elimine la tabla "alumnos" si existe.

2- Cree la tabla:
 create table alumnos(
  legajo int unsigned auto_increment,
  nombre varchar(30),
  documento char(8) not null,
  domicilio varchar(30),
  ciudad varchar(20),
  provincia varchar(20),
  primary key(legajo)
 );

3- Vea los índices de la tabla.

4- Agregue un índice común por los campos "ciudad" y "provincia" (que pueden repetirse):
 
5- Agregue un índice único (no pueden repetirse los valores) por el campo 
"documento":
  
6- Visualice los índices:
 

Otros problemas: 

Una clínica registra las consultas de los pacientes en una tabla llamada 
"consultas".

1- Elimine la tabla si existe.

2- Cree la tabla con una clave primaria compuesta (fecha y número de consulta):
 create table consultas(
  fecha date,
  numero int unsigned,
  documento char(8) not null,
  obrasocial varchar(30),
  medico varchar(30),
  primary key(fecha,numero)
 );

3- Agregue un índice único llamado "i_consulta" compuesto por los campos "documento", "fecha" y "medico":
 
4- Hay 2 campos por los cuales podemos realizar consultas frecuentemente: "medico" y "obrasocial", cree índices comunes para esos campos:
 
5- Vea los índices.


53 - Agregar y eliminar la clave primaria (alter table)



Hasta ahora hemos aprendido a definir una clave primaria al momento de crear una tabla. Con "alter table" podemos agregar una clave primaria a una tabla existente.

Continuamos con nuestra tabla "libros", definida con la siguiente estructura:

 - código, int unsigned auto_increment,
 - titulo, varchar(40),
 - autor, varchar(30),
 - editorial, varchar (20),
 - precio, decimal(5,2) unsigned,
 - cantidad smallint unsigned.

Para agregar una clave primaria a una tabla existente usamos:

 alter table libros
  add primary key (codigo);

Usamos "alter table" con "add primary key" y entre paréntesis el nombre del 
campo que será clave.
Si intentamos agregar otra clave primaria, aparecerá un mensaje de error porque (recuerde) una tabla solamente puede tener una clave primaria.

Para que un campo agregado como clave primaria sea autoincrementable, es necesario agregarlo como clave y luego redefinirlo con "modify" como "auto_increment". No se puede agregar una clave y al mismo tiempo definir el campo autoincrementable. Tampoco es posible definir un campo como autoincrementable y luego agregarlo como clave porque para definir un campo "auto_increment" éste debe ser clave primaria.
También usamos "alter table" para eliminar una clave primaria.

Para eliminar una clave primaria usamos:

 alter table libros
  drop primary key;

Con "alter table" y "drop primary key" eliminamos una clave primaria definida 
al crear la tabla o agregada luego.

Si queremos eliminar la clave primaria establecida en un campo "auto_increment" aparece un mensaje de error y la sentencia no se ejecuta porque si existe un campo con este atributo DEBE ser clave primaria. Primero se debe modificar el campo quitándole el atributo "auto_increment" y luego se podrá eliminar la clave.

Si intentamos establecer como clave primaria un campo que tiene valores repetidos, aparece un mensaje de error y la operación no se realiza.


PROBLEMA RESUELTO


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

Eliminamos la tabla si existe.

Creamos la tabla "libros" con la siguiente estructura:

 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:

 alter table libros
  drop primary key;

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:

 alter table libros
  drop primary key;

Si visualizamos la estructura de la tabla:

 describe libros;
vemos que la tabla ya no tiene clave primaria.


PROBLEMA PROPUESTO


Trabaje con la tabla llamada "medicamentos" de una farmacia.

1- Elimine la tabla, si existe:
 2- Cree la tabla con la siguiente estructura:
 create table medicamentos(
  codigo int unsigned not null,
  nombre varchar(20) not null,
  laboratorio varchar(20),
  precio decimal(6,2) unsigned
);

3- Visualice la estructura de la tabla "medicamentos".

4- Agregue una clave primaria por "codigo":
 
La clave agregada, no es auto_increment, por ello, al agregar registros debemos
ingresar el código, si no lo hacemos, se almacenará el valor "0" en el primer 
registro agregado:
y si intentamos agregar más registros, aparecerá un mensaje indicando que la 
clave está repetida:
 
5- Para solucionar esto podemos modificar el campo convirtiéndolo en 
autoincrementable:
 
6- Veamos los registros:
 
El código se alteró, ahora tiene el valor "1".

7- Ingrese más registros:
 insert into medicamentos (nombre, laboratorio,precio)
  values('Paracetamol 500','Bago',1.90);
 insert into medicamentos (nombre, laboratorio,precio)
  values('Bayaspirina','Bayer',2.10);

8- Intente eliminar la clave primaria:
 
Aparece un mensaje de error. La clave no se puede eliminar porque el campo 
"codigo" es "auto_increment" y si existe un campo con este atributo DEBE ser 
clave primaria.

9- Modifique el campo "codigo" quitándole el atributo "auto_increment":
 
10- Elimine la clave primaria:
 


Otros problemas: 

Una pequeña biblioteca de barrio registra los préstamos de sus libros en una 
tabla llamada "prestamos".

1- Elimine la tabla "prestamos" si existe.

2- Cree la tabla:
 create table prestamos(
  codigo int unsigned,
  titulo varchar(40) not null,
  documento char(8) not null,
  fechaprestamo date not null,
  fechadevolucion date,
  devuelto char(1) /* si se devolvió 's' sino 'n'*/
 );

3- Agregue una clave primaria compuesta por "codigo" y "fechaprestamo":
 
4- Intente agregar un registro con clave repetida.

5- Elimine la clave primaria:
 


52 - Cambiar el nombre de un campo de una tabla (alter table - change)



Con "alter table" podemos cambiar el nombre de los campos de una tabla.

Continuamos con nuestra tabla "libros", definida con la siguiente estructura:

- código, int unsigned auto_increment,
- nombre, varchar(40),
- autor, varchar(30),
- editorial, varchar (20),
- costo, decimal(5,2) unsigned,
- cantidad int unsigned,
- clave primaria: código.

Queremos cambiar el nombre del campo "costo" por "precio", tipeamos:

 alter table libros
  change costo precio decimal (5,2);

Usamos "alter table" seguido del nombre de la tabla y "change" seguido del 
nombre actual y el nombre nuevo con su tipo y los modificadores.

Con "change" cambiamos el nombre de un campo y también podemos cambiar el tipo y sus modificadores. Por ejemplo, queremos cambiar el nombre del campo "nombre" por "titulo" y redefinirlo como "not null", tipeamos:

 alter table libros
  change nombre titulo varchar(40) not null;


PROBLEMA RESUELTO


Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla si existe.
Creamos la tabla "libros" con la siguiente estructura:
 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", tipeamos:
 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", tipeamos:
 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.
PROBLEMA PROPUESTO

Un comercio que vende por mayor artículos de librería y papelería tiene una tabla 
llamada "articulos".

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 create table articulos(
  codigo int unsigned auto_increment,
  nombre varchar(20) not null,
  descripcion varchar(30),
  precio decimal(4,2) unsigned,
  primary key(codigo)
 );

3- Ingrese los siguientes registros:
 insert into articulos (nombre,descripcion,precio)
  values('escuadra','plastico 20 cm.',3.50);
 insert into articulos (nombre,descripcion,precio)
  values('lápices colores','Faber x12',4.50);
 insert into articulos (nombre,descripcion,precio)
  values('lápices colores','Faber x24',7.50);
 insert into articulos (nombre,descripcion,precio)
  values('regla','30 cm.',2.50);
 insert into articulos (nombre,descripcion,precio)
  values('fibras','Faber x12',10.30);
 insert into articulos (nombre,descripcion,precio)
  values('fibras','Faber x6',5.10);

4- El comercio, que hasta ahora ha vendido sus artículos por mayor comenzará la venta por menor. 
Necesita alterar la tabla modificando el nombre del campo "precio" por "preciopormayor" además desea redefinirlo como no nulo:
 
5- También necesita alterar la tabla agregando un campo para almacenar el precio por menor para cada artículo. Agrege un campo llamado "preciopormenor" que no 
permita valores nulos:
6- Muestre todos los registros:

7- Actualice el campo "preciopormenor" de todos los registros, dándole el valor del campo "precio" incrementado en un 10%:

8- Muestre todos los registros:




Otros problemas:
 
Trabaje con la tabla "peliculas" de un video club.

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 create table peliculas(
  codigo int unsigned,
  nombre varchar(40) not null,
  actor varchar(20),
  director varchar(25),
  duracion tinyint unsigned
 );

3- Cambie el nombre del campo "actor" por "protagonista" y modifíquelo para que 
permita valores nulos:
4- Cambie el campo "nombre" por "titulo" sin alterar los otros atributos:

5- Cambie el nombre del campo "duracion" por "minutos":

51 - Modificar campos de una tabla (alter table - modify)



Con "alter table" podemos modificar el tipo de algún campo incluidos sus atributos.

Continuamos con nuestra tabla "libros", definida con la siguiente estructura:


 - código, int unsigned,
 - titulo, varchar(30) not null,
 - autor, varchar(30),
 - editorial, varchar (20),
 - precio, decimal(5,2) unsigned,
 - cantidad int unsigned.

Queremos modificar el tipo del campo "cantidad", como guardaremos valores que 
no superarán los 50000 usaremos smallint unsigned, tipeamos:

 alter table libros
  modify cantidad smallint unsigned;

Usamos "alter table" seguido del nombre de la tabla y "modify" seguido del 
nombre del nuevo campo con su tipo y los modificadores.

Queremos modificar el tipo del campo "titulo" para poder almacenar una longitud de 40 caracteres y que no permita valores nulos, tipeamos:

 alter table libros
  modify titulo varchar(40) not null;

Hay que tener cuidado al alterar los tipos de los campos de una tabla que ya 
tiene registros cargados. Si tenemos un campo de texto de longitud 50 y lo 
cambiamos a 30 de longitud, los registros cargados en ese campo que superen los 
30 caracteres, se cortarán.

Igualmente, si un campo fue definido permitiendo valores nulos, se cargaron registros con valores nulos y luego se lo define "not null", todos los registros con valor nulo para ese campo cambiarán al valor por defecto según el tipo (cadena vacía para tipo texto y 0 para numéricos), ya que "null" se convierte en un valor inválido.

Si definimos un campo de tipo decimal(5,2) y tenemos un registro con el valor "900.00" y luego modificamos el campo a "decimal(4,2)", el valor "900.00" 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. Por ejemplo:

 alter table libros
  modify codigo int unsigned auto_increment;

"alter table" combinado con "modify" permite agregar y quitar campos y 
atributos de campos. Para modificar el valor por defecto ("default") de un campo 
podemos usar también "modify" pero debemos colocar el tipo y sus modificadores, 
entonces resulta muy extenso, podemos setear sólo el valor por defecto con la 
siguienmte sintaxis:

 alter table libros
 alter autor set default 'Varios';

Para eliminar el valor por defecto podemos emplear:

 alter table libros
 alter autor drop default;



PROBLEMA RESUELTO


Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla "libros" si existe.
Creamos la tabla "libros" con la siguiente estructura:
 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", tipeamos:
 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, tipeamos:
 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.
Ingresemos algunos registros:
 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:
 select * from libros;
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;
Mostramos todos los registros:
 select * from libros;
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);
Mostramos todos los registros:
 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.
PROBLEMA PROPUESTO
Trabaje con la tabla "peliculas" de un video club.

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 create table peliculas(
  codigo int unsigned,
  nombre varchar(20) not null,
  actor varchar(20),
  director varchar(25),
  duracion tinyint
 );

3- Modifique el campo "duracion" por tinyint unsigned.
 

4- Modifique el campo "nombre" para poder almacenar una longitud de 40 caracteres   y que no permita valores nulos:
5- Modifique el campo "actor" para que no permita valores nulos:
 
6- Intente definir "auto_increment" el campo "codigo" (mensaje de error):
 

Otros problemas: 

Un comercio que vende artículos de computación registra los datos de sus artículos en una tabla con ese nombre.

1- Elimine "articulos", si existe.

2- Cree la tabla, con la siguiente estructura:
create table articulos(
  codigo int unsigned,
  nombre varchar(25) not null,
  descripcion varchar(30),
  precio decimal(4,2) unsigned,
  cantidad tinyint,
  primary key(codigo)
 );

3- Modifique el campo "precio" para que pueda guardar valores hasta "9999.99".

4- Modifique el campo "codigo" para que se autoincremente.

5- Modifique el campo "cantidad" para que no permita valores negativos.




lunes, 5 de noviembre de 2012

50 - Eliminar campos de una tabla (alter table - drop)


"alter table" nos permite alterar la estructura de la tabla, podemos usarla para eliminar un campo.
Continuamos con nuestra tabla "libros".

Para eliminar el campo "edicion" tipeamos:

 alter table libros
  drop edicion;
 
Entonces, para borrar un campo de una tabla usamos "alter table" junto con "drop" y el nombre del campo a eliminar.

Si intentamos borrar un campo inexistente aparece un mensaje de error y la acción no se realiza.
Podemos eliminar 2 campos en una misma sentencia:

 alter table libros
  drop editorial, drop cantidad;
 
Si se borra un campo de una tabla que es parte de un índice, también se borra el índice.

Si una tabla tiene sólo un campo, éste no puede ser borrado.

Hay que tener cuidado al eliminar un campo, éste puede ser clave primaria. Es posible eliminar un campo que es clave primaria, no aparece ningún mensaje:

 alter table libros
  drop codigo;
 
Si eliminamos un campo clave, la clave también se elimina.


PROBLEMA RESUELTO

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

Eliminamos la tabla "libros" si existe.

Creamos la tabla "libros" con la siguiente estructura:

 create table libros(
  codigo int unsigned auto_increment,
  titulo varchar(40) not null,
  autor varchar(30),
  editorial varchar (20),
  edicion date,
  precio decimal(5,2) unsigned,
  cantidad int unsigned,
  primary key(codigo)
 );
Para eliminar el campo "edicion" tipeamos:

 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 tipeamos:

 alter table libros
  drop editorial, drop cantidad;
 
Elimine el campo clave:

 alter table libros
  drop codigo;
 
 
 
PROBLEMA PROPUESTO
 
 
Trabaje con la tabla "peliculas" de un video club.

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 
 create table peliculas(
  codigo int unsigned auto_increment,
  nombre varchar(30) not null,
  protagonista varchar(20),
  actorsecundario varchar(20),
  director varchar(25),
  duracion tinyint unsigned,
  primary key(codigo),
  index i_director (director)
 );

3- Ingrese algunos registros.

4- Vea los índices:
 
5- Elimine el campo "director":
 
6- Visualice la estructura modificada:
 
7- Vea los índices:
 
Note que el índice por "editorial" ya no existe, esto es porque si borra 
un campo que es parte de un índice, también se borra el índice.

8- Intente eliminar un campo inexistente. Aparece un mensaje de error:
 
9- Elimine los campos "actorsecundario" y "duracion" en una misma sentencia:
  
 
 
Otros problemas: 

Trabajamos con nuestra tabla "usuarios" que almacena los nombres de los 
usuarios y sus claves.

1- Elimine la tabla si existe.

2- Cree la tabla:
 
 create table usuarios (
  nombre varchar(30),
  clave varchar(10)
 );

3- Elimine el campo "clave":
 
4- Visualice la estructura de la tabla:
 
5- Intente eliminar el único campo de la tabla:

Aparece un mensaje de error y la sentencia no se ejecuta, esto es porque 
no se puede dejar una tabla vacía de campos.
 

49 - Agregar campos a una tabla (alter table - add)


Para modificar la estructura de una tabla existente, usamos "alter table".

"alter table" se usa para:

- agregar nuevos campos,
- eliminar campos existentes,
- modificar el tipo de dato de un campo,
- agregar o quitar modificadores como "null", "unsigned", "auto_increment",
- cambiar el nombre de un campo,
- agregar o eliminar la clave primaria,
- agregar y eliminar índices,
- renombrar una tabla.

"alter table" hace una copia temporal de la tabla original, realiza los cambios en la copia, luego borra la tabla original y renombra la copia.

Aprenderemos a agregar campos a una tabla.

Para ello utilizamos nuestra tabla "libros", definida con la siguiente estructura:

 - código, int unsigned auto_increment, clave primaria,
 - titulo, varchar(40) not null,
 - autor, varchar(30),
 - editorial, varchar (20),
 - precio, decimal(5,2) unsigned.
 
Necesitamos agregar el campo "cantidad", de tipo smallint unsigned not null, tipeamos:

 alter table libros
  add cantidad smallint unsigned not null;
 
Usamos "alter table" seguido del nombre de la tabla y "add" seguido del nombre del nuevo campo con su tipo y los modificadores.

Agreguemos otro campo a la tabla:

 alter table libros
  add edicion date;
 
Si intentamos agregar un campo con un nombre existente, aparece un mensaje de error indicando que el campo ya existe y la sentencia no se ejecuta.

Cuando se agrega un campo, si no especificamos, lo coloca al final, después de todos los campos existentes; podemos indicar su posición (luego de qué campo debe aparecer) con "after":

 alter table libros
 add cantidad tinyint unsigned after autor;
 
 
 
PROBLEMA RESUELTO
 


Trabajamos con la tabla "libros".

Eliminamos la tabla "libros" si existe.

Creamos la tabla "libros" con la siguiente estructura:

 create table libros(
  codigo int unsigned auto_increment,
  titulo varchar(40) not null,
  autor varchar(30),
  editorial varchar (20),
  precio decimal(5,2) unsigned,
  primary key(codigo)
 );
 
Para agregar el campo "cantidad" de tipo smallint unsigned not null, tipeamos:

 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;
 
 
 
PROBLEMA PROPUESTO
 
 
Trabaje con la tabla "peliculas" de un video club.

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 
 create table peliculas(
  codigo int unsigned auto_increment,
  nombre varchar(30) not null,
  actor varchar(20),
  primary key(codigo)
 );

3- Ingrese algunos registros.

4- Agregue un campo para almacenar la duración de la película, de tipo 
tinyint unsigned:
  
5- Visualice la estructura de la tabla con "describe".

6- Agregue el campo "director" para almacenar el nombre del director, 
de tipo varchar(20):
 
7- Visualice la estructura de la tabla con su nuevo campo:
 
8- Intente agregar un campo existente. Aparece un mensaje de error: 
 
 
 
Otros problemas:
 
 
 
Un comercio que vende por mayor artículos de librería y papelería tiene una tabla 
llamada "articulos".

1- Elimine la tabla, si existe.

2- Cree la tabla con la siguiente estructura:
 
 create table articulos(
  codigo int unsigned auto_increment,
  nombre varchar(20) not null,
  descripcion varchar(30),
  precio decimal(4,2) unsigned,
  primary key(codigo)
 );

3- Ingrese los siguientes registros:
 
 insert into articulos (nombre,descripcion,precio)
  values('escuadra','plastico 20 cm.',3.50);
 insert into articulos (nombre,descripcion,precio)
  values('lápices colores','Join x12',4.50);
 insert into articulos (nombre,descripcion,precio)
  values('lápices colores','Join x24',7.50);
 insert into articulos (nombre,descripcion,precio)
  values('regla','30 cm.',2.50);
 insert into articulos (nombre,descripcion,precio)
  values('fibras','Join x12',10.30);
 insert into articulos (nombre,descripcion,precio)
  values('fibras','Join x6',5.10);

4- El comercio, que hasta ahora ha vendido sus artículos por mayor, comenzará la venta por menor. 
Necesita alterar la tabla agregando un campo para almacenar el precio por menor para cada artículo. 
Agrege un campo llamado "preciopormenor":

5- Muestre todos los registros:
 
Note que para el nuevo campo los valores se setearon en "null".

6- Actualice el campo "preciopormenor" de todos los registros, dándole el valor del campo "precio" 
incrementado en un 10%:
 
7- Muestre todos los registros:
 
 

 
 
 

jueves, 1 de noviembre de 2012

48 - Remplazar registros (replace)


"replace" reemplaza un registro por otro.

Cuando intentamos ingresar con "insert" un registro que repite el valor de un campo clave o indexado con índice único, aparece un mensaje de error indicando que el valor está duplicado. Si empleamos "replace" en lugar de "insert", el registro existente se borra y se ingresa el nuevo, de esta manera no se duplica el valor único.

Si tenemos la tabla "libros" con el campo "codigo" establecido como clave primaria e intentamos ingresar ("insert") un valor de código existente, aparece un mensaje de error porque no está permitido repetir los valores del campo clave. Si empleamos "replace" en lugar de "insert", la sentencia se ejecuta reemplazando el registro con el valor de código existente por el nuevo registro.

Veamos un ejemplo. Tenemos los siguientes registros almacenados en "libros":

codigo  titulo  autor  editorial precio
_______________________________________________________________
10 Alicia en .. Lewis Carroll Emece  15.4
15 Aprenda PHP Mario Molina Planeta  45.8
23 El aleph Borges  Planeta  23.0

Intentamos insertar 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.

Si empleamos "replace":

 replace into libros values(23,'Java en 10 minutos','Mario Molina','Emece',25.5);

la sentencia se ejecuta y aparece un mensaje indicando que se afectaron 2 
filas, esto es porque un registro se eliminó y otro se insertó.

"replace" funciona como "insert" en los siguientes casos: - si los datos ingresados no afectan al campo único, es decir no se ingresa valor para el campo indexado:

 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.

- si el dato para el campo indexado que se ingresa 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.

- si la tabla no tiene indexación. Si la tabla "libros" no tuviera establecida ninguna clave primaria (ni índice único), podríamos ingresar varios registros con igual código:

 replace into libros values(1,'Harry Potter ya la piedra filosofal','Hawking','Emece',48);

aparecería un mensaje indicando que se afectó 1 registro (el ingresado), no 
se reemplazó ninguno y ahora habría 2 libros con código 1.



PROBLEMA RESUELTO:


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

Eliminamos la tabla si existe:

 drop table if exists libros;

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)
 );

Ingresamos algunos registros:

 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.


PROBLEMA PROPUESTO:


Un instituto de enseñanza guarda los datos de sus alumnos en la tabla "alumnos".

1- Elimine la tabla si existe:
 
2- Cree la tabla:
 create table alumnos(
  legajo int(10) unsigned auto_increment,
  nombre varchar(30),
  documento char(8),
  domicilio varchar(30),
  primary key(legajo),
  unique i_documento (documento)
 );

3- Ingrese algunos registros:
 insert into alumnos values('1353','Juan Lopez','22333444','Colon 123');
 insert into alumnos values('2345','Ana Acosta','24000555','Caseros 456');
 insert into alumnos values('2356','Jose Torres','26888777','Sucre 312');
 insert into alumnos values('3567','Luis Perez','28020020','Rivadavia 234');

4- Intente ingresar un registro con clave primaria repetida (legajo "3567"):
 
aparece un mensaje de error.

5- Ingrese el registro anterior reemplazando el existente:
 
6- Intente ingresar un alumno con documento repetido:
 

7- Reemplace el registro:
 
note que el alumno con documento "30000333" se eliminó y se reemplazó por el nuevo registro.

8- Elimine el índice único:
 
9- Ingrese con "replace" el siguiente registro con documento existente:
 
un registro afectado, no hubo eliminación solamente inserción.

10- Muestre todos los registros:
 
note que hay dos alumnos con el mismo número de documento.





47 - Recuperación de registros en forma aleatoria(rand)


Una librería que tiene almacenados los datos de sus libros en una tabla llamada "libros" quiere donar a una institución 5 libros tomados al azar.

Para recuperar de una tabla registros aleatorios se puede utilizar la función "rand()" combinada con "order by" y "limit":

 select * from libros
  order by rand()
  limit 5;

Nos devuelve 5 registros 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.


PROBLEMA RESUELTO:


Trabajamos con la tabla "libros" en el cual una librería guarda los datos de sus libros.

Eliminamos la tabla "libros" si existe:

 drop table if exists libros;

Creamos la tabla:

 create table libros(
  codigo int unsigned auto_increment,
  titulo varchar(40),
  autor varchar(30),
  editorial varchar(20),
  precio decimal(5,2) unsigned,
  primary key(codigo)
 );

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:

 select * from libros order by rand() limit 5;
 select * from libros order by rand() limit 5;
 select * from libros order by rand() limit 5;



PROBLEMA PROPUESTO:


Trabajamos con la tabla "alumnos" en el cual un instituto de enseñanza guarda los datos de sus alumnos.
Eliminamos la tabla "alumnos" si existe:

Creamos la tabla:
  create table alumnos(
  documento char(8) not null,
  nombre varchar(30),
  domicilio varchar(30),
  ciudad varchar(20),
  provincia varchar(20),
  primary key(documento)
 );
Agregamos varios registros:
 insert into alumnos values('22333444','Juan Perez','Colon 123','Cordoba','Cordoba');
 insert into alumnos values('23456789','Ana Acosta','Caseros 456','Cordoba','Cordoba');
 insert into alumnos values('24123123','Patricia Morales','Sucre 234','Villa del Rosario','Cordoba');
 insert into alumnos values('25000333','Jose Torres','Sarmiento 980','Carlos Paz','Cordoba');
 insert into alumnos values('26333444','Susana Molina','Avellaneda 234','Rosario','Santa Fe');
 insert into alumnos values('27987654','Marta Herrero','San Martin 356','Villa del Rosario','Cordoba');
 insert into alumnos values('28321321','Marcos Ferreyra','Urquiza 357','Cordoba','Cordoba');
 insert into alumnos values('30987464','Marta Perez','Rivadavia 234','Cordoba','Cordoba');

El instituto quiere tomar 3 alumnos al azar para que representen al instituto en una feria de ciencias. Para recuperar de una tabla registros aleatorios se puede utilizar la función "rand()" combinada con "order by" y "limit":
Nos devuelve los nombres y documentos de 3 alumnos tomados al azar de la tabla "alumnos". Podemos ejecutar la sentencia anterior varias veces seguidas y veremos que los registros recuperados son diferentes en cada ocasión:
 select documento,nombre from alumnos order by rand() limit 3;
 select documento,nombre from alumnos order by rand() limit 3;
 select documento,nombre from alumnos order by rand() limit 3;


Otros problemas:

 
Un comercio que vende artículos de computación registra los datos de sus artículos en una tabla con ese nombre.

1- Elimine "articulos", si existe:

2- Cree la tabla, con la siguiente estructura:
  create table articulos(
  codigo int unsigned auto_increment,
  nombre varchar(25) not null,
  descripcion varchar(30),
  precio decimal(6,2) unsigned,
  cantidad tinyint unsigned,
  primary key(codigo)
 );

3- Ingrese algunos registros:
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('impresora','Epson Stylus C45',400.80,20);
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('impresora','Epson Stylus C85',500,30);
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('monitor','Samsung 14',800,10);
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('teclado','ingles Biswal',100,50);
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('teclado','español Biswal',90,50);
 insert into articulos (nombre, descripcion, precio,cantidad)
  values ('impresora multifuncion','HP 1410',300,20);

4- El comercio quiere tomar 2 artículos al azar para ofrecer una oferta especial haciendo un descuento. Seleccione 2 registros al azar de la tabla "articulos":
 
Ejecute la sentencia varias veces para verificar que los registros seleccionados son diferentes.