Manual de MySQL

CARRERA: Técnico en OFIMÁTICA
Módulo IV
Diseña y gestiona bases de datos ofimáticas
Submódulo 1 - Diseña bases de datos ofimáticas
Submódulo 2 - Gestiona información mediante el uso de sistemas manejadores

de bases de datos ofimática
Manual Básico de MySQL - Ejercicios Guiados Parte I -1-

1.- Introducción.
SQL, Structure Query Language
(Lenguaje de Consulta Estructurado) es un lenguaje de programación para trabajar con base de datos
relacionales como MySQL, Oracle, etc.
MySQL es un interpretador de SQL, es un servidor de base de datos.
MySQL permite crear base de datos y tablas, insertar datos, modificarlos, eliminarlos, ordenarlos, hacer
consultas y realizar muchas operaciones, etc., resumiendo: administrar bases de datos.
Ingresando instrucciones en la línea de comandos o embebidas en un lenguaje como PHP nos comunicamos
con el servidor. Cada sentencia debe acabar con punto y coma (;).
La sensibilidad a mayúsculas y minúsculas, es decir, si hace diferencia entre ellas, depende del sistema
operativo, Windows no es sensible, pero Linux sí. Por ejemplo Windows interpreta igualmente las siguientes
sentencias:
create database administracion;

Create DataBase administracion;
Pero Linux interpretará como un error la segunda.
Se recomienda usar siempre minúsculas.
“Diseña y gestiona bases de datos ofimáticas” -8-

Crear una base de datos
Cada conjunto de relaciones que componen un modelo completo forma una base de datos. Desde el punto
de vista de SQL, una base de datos es sólo un conjunto de relaciones (o tablas), y para organizarlas o
distinguirlas se accede a ellas mediante su nombre. A nivel de sistema operativo, cada base de datos se
guarda en un directorio diferente.
Debido a esto, crear una base de datos es una tarea muy simple. Claro que, en el momento de crearla, la base
de datos estará vacía, es decir, no contendrá ninguna tabla.
Vamos a crear y manipular nuestra propia base de datos, al tiempo que nos familiarizamos con la forma de
trabajar de MySQL.
Para empezar, crearemos una base de datos para nosotros solos, y la llamaremos "prueba". Para crear una
base de datos se usa una sentencia:
CREATE DATABASE:
Para seleccionar una base de datos se usa el comando USE, que no es exactamente una sentencia SQL, sino
más bien de una opción de MySQL:
USE “<<DATABASE>>”;
Manual Básico de MySQL - Ejercicios Guiados Parte I -9-

2 - show databases
Una base de datos es un conjunto de tablas. Una base de datos tiene un nombre con el cual accederemos a
ella.
Para que el servidor nos muestre las bases de datos existentes, se lo solicitamos enviando la instrucción:
show databases;
Nos mostrará los nombres de las bases de datos.
Problema: Mostrar las bases de datos existentes en el servidor de base de datos del sitio
show databases;
3 - Creación de una tabla y mostrar sus campos

(create table - show tables - describe - drop table)
Una base de datos almacena sus datos en tablas.
Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada columna es un campo
(o atributo) y cada fila, un registro. La intersección de una columna con una fila, contiene un dato específico,
un solo valor.
Cada registro contiene un dato por cada columna de la tabla.
Cada campo (columna) debe tener un nombre. El nombre del campo hace referencia a la información que
almacenará.
Cada campo (columna) también debe definir el tipo de dato que almacenará.
nombre clave
MarioPerez Marito
MariaGarcia Mary
DiegoRodriguez x8080
Gráficamente acá tenemos la tabla usuarios, que contiene dos campos llamados: nombre y clave.
Luego tenemos tres registros almacenados en esta tabla, el primero almacena en el campo nombre el valor
"MarioPerez" y en el campo clave "Marito", y así sucesivamente con los otros dos registros.
Las tablas forman parte de una base de datos.
“Diseña y gestiona bases de datos ofimáticas” - 10 -

Nosotros trabajaremos con la base de datos llamada "administracion", que ya hemos creado en el servidor.
Para ver las tablas existentes en una base de datos tipeamos:
show tables;
Deben aparecer todas las tablas que han creado los visitantes al sitio.
Al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de datos almacenarán cada
uno de ellos, es decir, su estructura.
La tabla debe ser definida con un nombre que la identifique y con el cual accederemos a ella.
Creamos una tabla llamada "usuarios", tipeamos:
create table usuarios (

nombre varchar(30),
clave varchar(10)
);
Si intentamos crear una tabla con un nombre ya existente (existe otra tabla con ese nombre), mostrará un
mensaje de error indicando que la acción no se realizó porque ya existe una tabla con el mismo nombre.
Para ver las tablas existentes en una base de datos tipeamos nuevamente:
show tables;
Ahora aparece "usuarios" entre otras que ya pueden estar creadas.
Cuando se crea una tabla debemos indicar su nombre y definir sus campos con su tipo de dato. En esta tabla
"usuarios" definimos 2 campos:
- nombre: que contendrá una cadena de hasta 30 caracteres de longitud, que almacenará el nombre de
usuario y
- clave: otra cadena de caracteres de 10 de longitud, que guardará la clave de cada usuario.
Cada usuario ocupará un registro de esta tabla, con su respectivo nombre y clave.
Para ver la estructura de una tabla usamos el comando "describe" junto al nombre de la tabla:
describe usuarios;
Manual Básico de MySQL - Ejercicios Guiados Parte I - 11 -

Aparece lo siguiente:
Field Type Null

_________________________
nombre varchar(30) YES
clave varchar(10) YES
Esta es la estructura de la tabla "usuarios"; nos muestra cada campo, su tipo, lo que ocupa en bytes y otros
datos como la aceptación de valores nulos etc, que veremos más adelante en detalle.
Para eliminar una tabla usamos "drop table". Tipeamos:
drop table usuarios;
Si tipeamos nuevamente:
drop table usuarios;
Aparece un mensaje de error, indicando que no existe, ya que intentamos borrar una tabla inexistente.
Para evitar este mensaje podemos tipear:
drop table if exists usuarios;
En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.
Problema 1: Crear la tabla usuarios con los campos nombre y clave. Previamente borrar la tabla
usuarios si ya existe en el servidor. Finalmente mostrar la estructura de la tabla usuarios que acabamos
de crear.
Importante: Pruebe luego de borrar el comando drop y vea que ocurre si trata de crear una tabla ya
existente en nuestra base de datos.

nombre varchar(30),
clave varchar(10)
);
describe usuarios;

Problema 2:
A) Queremos almacenar los datos de nuestros amigos.
1- Elimine la tabla "agenda" si existe:
drop table if exists agenda;
2- Cree una tabla llamada "agenda", debe tener los siguientes campos:
nombre varchar(20)
domicilio varchar(30)
y telefono varchar(11)
create table agenda(

nombre varchar(20),
domicilio varchar(30),
telefono varchar(11)
);
3- Intente crearla nuevamente. Aparece mensaje de error.
4- Visualice las tablas existentes (show tables).
5- Visualice la estructura de la tabla "agenda" (describe agenda).
6- Elimine la tabla, si existe (drop table, if exists).
7- Intente eliminar la tabla sin la cláusula if exists (drop table agenda).

Debe aparecer un mensaje de error cuando no existe la tabla.
Problema 3: Queremos almacenar información referente a nuestros libros.
1- Elimine la tabla "libros", si existe.
2- Cree una tabla llamada "libros".
Debe definirse con los siguientes campos:

titulo varchar(20),
autor varchar(30),
y editorial varchar(15)
3- Intente crearla nuevamente. Aparece mensaje de error.

4- Visualice las tablas existentes.
5- Visualice la estructura de la tabla "libros".
6- Elimine la tabla, si existe.
7- Intente eliminar la tabla
4 - Carga de registros a una tabla y su recuperación (insert into - select)
Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro tiene un dato
por cada columna.
Recordemos como crear la tabla "usuarios":

nombre varchar(30),
clave varchar(10)
);
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los campos.
Ahora vamos a agregar un registro a la tabla:
insert into usuarios (nombre, clave) values ('MarioPerez','Marito');
Usamos "insert into". Especificamos los nombres de los campos entre paréntesis y separados por comas y
luego los valores para cada campo, también entre paréntesis y separados por comas.
La tabla usuarios ahora la podemos graficar de la siguiente forma:
nombre clave
MarioPerez Marito
Es importante ingresar los valores en el mismo orden en que se nombran los campos, si ingresamos los
datos en otro orden, no aparece un mensaje de error y los datos se guardan de modo incorrecto.
Note que los datos ingresados, como corresponden a campos de cadenas de caracteres se colocan entre
comillas simples. Las comillas simples son OBLIGATORIAS.
Para ver los registros de una tabla usamos "select":
select nombre,clave from usuarios;

Aparece un registro.
El comando "select" recupera los registros de una tabla. Luego del comando select indicamos los nombres
de los campos a rescatar.
Problema 1: Insertar tres registros en la tabla usuarios y luego mostrar todos los registros de la
tabla. Primeramente eliminamos la tabla, si existe:
Creamos la tabla:

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:
Problema 2:
Trabaje con la tabla "agenda".
1- Elimine la tabla "agenda", si existe:
2- Cree una tabla llamada "agenda". Debe tener los siguientes campos:
nombre (cadena de 20), domicilio (cadena de 30) y telefono (cadena de 11):

nombre varchar(20),
);

3- Visualice las tablas existentes para verificar la creación de "agenda".
(show tables).
4- Visualice la estructura de la tabla "agenda". (describe).
5- Ingrese los siguientes registros:
Insert into agenda (nombre, domicilio, telefono) values

('Alberto Mores','Colon 123','4234567');
insert into agenda (nombre, domicilio, telefono) values
('Juan Torres','Avellaneda 135','4458787');
6- Seleccione y mustre todos los registros de la tabla:
select nombre, domicilio, telefono from agenda;
7- Elimine la tabla "agenda", si existe:
8- Intente eliminar la tabla nuevamente, sin especificar "si existe":
drop table agenda;
5 - Tipos de datos básicos de un campo de una tabla.
Ya explicamos que al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de datos
almacenará cada uno de ellos, es decir, su estructura. Estos son algunos tipos de datos básicos:
- varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de caracteres. Se
coloca entre comillas (simples): 'Hola'. El tipo "varchar" define una cadena de longitud variable en la cual
determinamos el máximo de caracteres. Puede guardar hasta 255 caracteres. Para almacenar cadenas de
hasta 30 caracteres, definimos un campo de tipo varchar(30). Si asignamos una cadena de caracteres de
mayor longitud que la definida, la cadena se corta. Por ejemplo, si definimos un campo de tipo varchar(10) y
le asignamos la cadena 'Buenas tardes', se almacenará 'Buenas tar' ajustándose a la longitud de 10
caracteres.
- integer: se usa para guardar valores numéricos enteros, de -2000000000 a 2000000000 aprox.
Definimos campos de este tipo cuando queremos representar, por ejemplo, cantidades.
- float: se usa para almacenar valores numéricos decimales. Se utiliza como separador el punto (.).
Definimos campos de este tipo para precios, por ejemplo.

Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato adecuado para cada
uno de ellos. Por ejemplo, si en un campo almacenaremos números enteros, el tipo "float" sería una mala
elección; si vamos a guardar precios, el tipo "float" es correcto, no así "integer" que no tiene decimales.
Problema 1: 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);
values ('Alicia en el pais de las maravillas','Lewis Carroll',
'Planeta',25,200);
values ('Matematica 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;
Es una forma resumida de indicar que seleccione todos los campos de la tabla.
Problema 2: Un videoclub que alquila películas en video almacena la información de sus películas en una
tabla llamada "peliculas"; para cada película necesita los siguientes datos:
-nombre, cadena de caracteres de 20 de longitud,

-actor, cadena de caracteres de 20 de longitud,
-duración, valor numérico entero.
-cantidad de copias: valor entero.
1- Elimine la tabla, si existe:
drop table if exists peliculas;
2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo:
create table peliculas(

nombre varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
3- Vea la estructura de la tabla:
describe peliculas;
insert into peliculas (nombre, actor, duracion, cantidad)

values ('Mision imposible','Tom Cruise',120,3);
values ('Mision imposible 2','Tom Cruise',180,2);
values ('Mujer bonita','Julia R.',90,3);
values ('Elsa y Fred','China Zorrilla',90,2);

5- Muestre todos los registros:
select * from peliculas;
6 - Recuperación de algunos campos (select)

Hemos aprendido cómo ver todos los registros de una tabla:
El comando "select" recupera los registros de una tabla. Con el asterisco (*) indicamos que seleccione todos
los campos de la tabla que nombramos.
Podemos especificar el nombre de los campos que queremos ver separándolos por comas:
select titulo,autor,editorial from libros;
En la sentencia anterior la consulta mostrará sólo los campos "titulo", "autor" y "editorial". En la siguiente
sentencia, veremos los campos correspondientes al título y precio de todos los libros:
select titulo,precio from libros;
Para ver solamente la editorial y la cantidad de libros tipeamos:
select editorial,cantidad from libros;
Problema 1: 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":

titulo varchar(20),
autor varchar(30),
precio float,
cantidad integer
);
Veamos la estructura de la tabla:

describe libros;

values ('El aleph','Borges','Emece',45.50,100);
values ('Alicia en el pais de las maravillas','Lewis Carroll','Planeta',25,200);
values ('Matematica estas ahi','Paenza','Planeta',15.8,200);
Para ver todos los campos de una tabla tipeamos:
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 tipeamos:
select editorial,cantidad from libros;
Problema 2: Un videoclub que alquila películas en video almacena la información de sus películas en
alquiler en una tabla llamada "peliculas".
drop table if exists peliculas;
2- Cree la tabla:
create table peliculas(

titulo varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);

describe peliculas;
insert into peliculas (titulo, actor, duracion, cantidad)

values ('Mision imposible','Tom Cruise',120,3);
values ('Mision imposible 2','Tom Cruise',180,2);
values ('Mujer bonita','Julia R.',90,3);
values ('Elsa y Fred','China Zorrilla',90,2);
5- Realice un "select" mostrando solamente el título y actor de todas las películas:
select titulo,actor from peliculas;
6- Muestre el título y duración de todas las peliculas.
7- Muestre el título y la cantidad de copias.
7 - Recuperación de registros específicos (select - where)

Hemos aprendido cómo ver todos los registros de una tabla:
select nombre, clave from usuarios;
El comando "select" recupera los registros de una tabla. Detallando los nombres de los campos separados
por comas, indicamos que seleccione todos los campos de la tabla que nombramos.
Existe una cláusula, "where" que es opcional, con ella podemos especificar condiciones para la consulta
"select". Es decir, podemos recuperar algunos registros, sólo los que cumplan con ciertas condiciones
indicadas con la cláusula "where". Por ejemplo, queremos ver el usuario cuyo nombre es "MarioPerez", para
ello utilizamos "where" y luego de ella, la condición:
select nombre, clave from usuarios where nombre='MarioPerez';
Para las condiciones se utilizan operadores relacionales (tema que trataremos más adelante en detalle). El
signo igual(=) es un operador relacional. Para la siguiente selección de registros especificamos una condición
que solicita los usuarios cuya clave es igual a 'Guadalajaraa':
select nombre, clave from usuarios where clave='Guadalajaraa';

Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún registro.
Problema 1:
Borramos la tabla si existe
Creamos la tabla:

nombre varchar(30),
clave varchar(10)
);
describe usuarios;
insert into usuarios (nombre, clave) values ('Leonardo','payaso');

insert into usuarios (nombre, clave) values ('Marcelo','Guadalajaraa');
insert into usuarios (nombre, clave) values ('Gustavo','Guadalajara');
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 'Guadalajara':
select nombre, clave from usuarios where clave='Guadalajara';
Realizamos un "select" de los usuarios cuya clave es 'Leon':
select nombre, clave from usuarios where clave='Leon';
No aparece ninguno pues ningún registro cumple la condición.

Problema 2:
Trabajamos con nuestra tabla "agenda".
1- Eliminamos "agenda", si existe:
2- Creamos la tabla, con los siguientes campos:
nombre (cadena de 20), domicilio (cadena de 30) y telefono (cadena de 11).
3- Visualice la estructura de la tabla "agenda".(describe).
'Alberto Mores','Colon 123','4234567',

'Juan Torres','Avellaneda 135','4458787',
'Mariana Lopez','Urquiza 333','4545454',
'Fernando Lopez','Urquiza 333','4545454'.
5- Seleccione todos los registros de la tabla. (select).
6- Seleccione el registro cuyo nombre sea 'Juan Torres'.
7- Seleccione el registro cuyo domicilio sea 'Colon 123'.
8- Muestre los datos de quienes tengan el teléfono '4545454'.
9- Elimine la tabla "agenda".
8 - Operadores Relacionales = <> < <= > >=

Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de una tabla; por ejemplo:
select titulo,autor,editorial from libros where autor='Borges';
Utilizamos el operador relacional de igualdad.
Los operadores relacionales vinculan un campo con un valor para que MySQL compare cada registro (el
campo especificado) con el valor dado.
Los operadores relacionales son los siguientes:

= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual
Podemos seleccionar los registros cuyo autor sea diferente de 'Borges', para ello usamos la condición:
select titulo,autor,editorial from libros where autor<>'Borges';
Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los libros cuyos precios sean
mayores a 20 pesos:
select titulo,autor,editorial,precio from libros where precio>20;
También, los libros cuyo precio sea menor o igual a 30:
slect titulo,autor,editorial,precio from libros where precio<=30;
Problema 1: Borramos la tabla libros si existe
La creamos con la siguiente estructura:

titulo varchar(20),
autor varchar(30),
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);
('Martin Fierro','Jose Hernandez','Emece',16.00);
('Aprenda PHP','Mario Molina','Emece',35.40);
('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.
Problema 2: 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:
drop table if exists articulos;
2- Cree la tabla, con la siguiente estructura:
create table articulos(

codigo integer,
nombre varchar(20),
descripcion varchar(30),
precio float,
cantidad integer
);
3- Vea la estructura de la tabla (describe).
4- Ingrese algunos registros:

insert into articulos (codigo, nombre, descripcion, precio,cantidad)
values (1,'impresora','Epson Stylus C45',400.80,20);
values (2,'impresora','Epson Stylus C85',500,30);
values (3,'monitor','Samsung 14',800,10);
values (4,'teclado','ingles Biswal',100,50);
values (5,'teclado','español Biswal',90,50);
5- Seleccione todos los registros de la tabla. (select).
6- Muestre los datos de las impresoras.
7- Seleccione los artículos cuyo precio sea mayor o igual a 500:
select * from articulos where precio>=500;
8- Seleccione los artículos cuya cantidad sea menor a 30:
select nombre,descripcion, precio,cantidad from artículos where cantidad<20;
9- Selecciones el nombre y descripción de los artículos que no cuesten $100:
select nombre, descripción from artículos where precio<>100;
9 - Borrado de registros de una tabla (delete)

Para eliminar los registros de una tabla usamos el comando "delete":
delete from usuarios;
La ejecución del comando indicado en la línea anterior borra TODOS los registros de la tabla.
Si queremos eliminar uno o varios registros debemos indicar cuál o cuáles, para ello utilizamos el comando
"delete" junto con la clausula "where" con la cual establecemos la condición que deben cumplir los registros
a borrar. Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es 'Leonardo':
delete from usuarios where nombre='Leonardo';
Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple con la condición
especificada, no se borrarán registros, pues no encontró registros con ese dato.

Problema 1: Trabajamos con la tabla "usuarios".
Creamos la tabla:

nombre varchar(30),
clave varchar(10)
);

insert into usuarios (nombre, clave) values ('Marcelo','Leon');
insert into usuarios (nombre, clave) values ('Gustavo','Leon');
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 'Leon':
delete from usuarios where clave='Leon';
Eliminemos todos los registros:
delete from usuarios;

Problema 2: Trabaje con la tabla "agenda" que registra la información referente a sus amigos.
1- Elimine la tabla (drop table) si existe (if exists).
2- Cree la tabla con los siguientes campos: apellido (cadena de 30), nombre (cadena de 20),
domicilio (cadena de 30) y telefono (cadena de 11):

apellido varchar(30),
nombre varchar(20),
);
3- Visualice la estructura de la tabla "agenda" (describe).
4- Ingrese los siguientes registros (insert into):
Mores,Alberto,Colon 123,4234567,
Torres,Juan,Avellaneda 135,4458787,
Lopez,Mariana,Urquiza 333,4545454,
Lopez,Jose,Urquiza 333,4545454,
Peralta,Susana,Gral. Paz 1234,4123456.
5- Elimine el registro cuyo nombre sea 'Juan' (delete - where).
6- Elimine los registros cuyo número telefónico sea igual a '4545454'.
10 - Modificación de registros de una tabla (update)

Para modificar uno o varios datos de uno o varios registros utilizamos "update" (actualizar).
Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las claves, por "RealMadrid":
update usuarios set clave='RealMadrid';
Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su nuevo valor.
El cambio afectará a todos los registros.
Podemos modificar algunos registros, para ello debemos establecer condiciones de selección con "where".

Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario llamado 'MarioPerez',
queremos como nueva clave 'Mape', necesitamos una condición "where" que afecte solamente a este
registro:
update usuarios set clave='Mape' where nombre='MarioPerez';
Si no encuentra registros que cumplan con la condición del "where", ningún registro es afectado. Las
condiciones no son obligatorias, pero si omitimos la cláusula "where", la actualización afectará a todos los
registros.
También se puede actualizar varios campos en una sola instrucción:
update usuarios set nombre='MarceloDuarte', clave='Marce' where nombre='Marcelo';
Para ello colocamos "update", el nombre de la tabla, "set" junto al nombre del campo y el nuevo valor y
separado por coma, el otro nombre del campo con su nuevo valor.
Problema 1: Trabajamos con la tabla "usuarios" que guarda el nombre de usuario y su clave.
Creamos la tabla:

nombre varchar(30),
clave varchar(10)
);

insert into usuarios (nombre, clave) values ('Marcelo','River');
insert into usuarios (nombre, clave) values ('Gustavo','River');
Visualizamos todos los registros:
select * from usuarios;
Para actualizar los valores de todas las claves, por 'RealMadrid' tipeamos:
update usuarios set clave='RealMadrid';

Visualizamos todos los registros para verificar la actualización:
select * from usuarios;
Cambiamos el valor correspondiente a la clave de nuestro usuario llamado 'MarioPerez', por 'Mape':
update usuarios set clave=' Mape ' 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';
Problema 2: Trabaje con la tabla "agenda" que almacena los datos de sus amigos.
1- Elimine la tabla si existe.
2- Cree la tabla:

apellido varchar(30),
nombre varchar(20),
);
3- Visualice la estructura de la tabla "agenda" (describe).
Mores,Alberto,Colon 123,4234567,
Torres,Juan,Avellaneda 135,4458787,
Lopez,Mariana,Urquiza 333,4545454,
Lopez,Jose,Urquiza 333,4545454,
Peralta,Susana,Gral. Paz 1234,4123456.
5- Modifique el registro cuyo nombre sea "Juan" por "Juan Jose"(update- where):

update agenda set nombre='Juan Jose' where nombre='Juan';
6- Actualice los registros cuyo número telefónico sea igual a '4545454' por '4445566':
update agenda set telefono='4445566' where telefono='4545454';
7- Actualice los registros que tengan en el campo "nombre" el valor "Juan" por "Juan Jose"
(ningún registro afectado porque ninguno cumple con la condición del "where"):
update agenda set nombre='Juan Jose' where nombre='Juan';
11 - Clave primaria.
Una clave primaria es un campo (o varios) que identifica 1 solo registro (fila) en una tabla.
Para un valor del campo clave existe solamente 1 registro. Los valores no se repiten ni pueden ser nulos.
Veamos un ejemplo, si tenemos una tabla con datos de personas, el número de documento puede
establecerse como clave primaria, es un valor que no se repite; puede haber personas con igual apellido y
nombre, incluso el mismo domicilio (padre e hijo por ejemplo), pero su documento será siempre distinto.
Si tenemos la tabla "usuarios", el nombre de cada usuario puede establecerse como clave primaria, es un
valor que no se repite; puede haber usuarios con igual clave, pero su nombre de usuario será siempre distinto.
Establecemos que un campo sea clave primaria al momento de creación de la tabla:

nombre varchar(20),
clave varchar(10),
primary key(nombre)
);
Para definir un campo como clave primaria agregamos "primary key" luego de la definición de todos los
campos y entre paréntesis colocamos el nombre del campo que queremos como clave.
Si visualizamos la estructura de la tabla con "describe" vemos que el campo "nombre" es clave primaria y no
acepta valores nulos(más adelante explicaremos esto detalladamente).


Si intentamos ingresar un valor para el campo clave que ya existe, aparece un mensaje de error indicando
que el registro no se cargó pues el dato clave existe. Esto sucede porque los campos definidos como clave
primaria no pueden repetirse.
Ingresamos un registro con un nombre de usuario repetido, por ejemplo:
Una tabla sólo puede tener una clave primaria. Cualquier campo (de cualquier tipo) puede ser clave primaria,
debe cumplir como requisito, que sus valores no se repitan.
Al establecer una clave primaria estamos indexando la tabla, es decir, creando un índice para dicha tabla; a
este tema lo veremos más adelante.
Problema 1: Trabajamos con la tabla "usuarios" que contiene el nombre de usuario y su clave.
Creamos la tabla:

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. Ingresamos algunos registros:

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

Problema 2: Trabaje con la tabla "libros" de una librería.
2- Créela con los siguientes campos y clave: codigo (integer),

titulo (cadena de 20 caracteres de longitud), autor (cadena de 30),
editorial (cadena de 15), codigo será clave primaria:
create table libros(codigo integer, titulo varchar(20), autor varchar(30), editorial varchar(15),
primary key(codigo) );
3- Visualice la estructura de la tabla "libros", compruebe la clave primaria.
1,El aleph,Borges,Planeta;
2,Martin Fierro,Jose Hernandez,Emece;
3,Aprenda PHP,Mario Molina,Emece;
4,Cervantes y el quijote,Borges,Paidos;
5,Matematica estas ahi, Paenza, Paidos;
5- Seleccione todos los registros.
6- Ingrese un registro con código no repetido y nombre de autor repetido.
7- Ingrese un registro con código no repetido y título y editorial repetidos.
8- Intente ingresar un registro que repita el campo clave (aparece mensaje de error por clave repetida).
12 - Campo entero con autoincremento.

Un campo de tipo entero puede tener otro atributo extra 'auto_increment'. Los valores de un campo
'auto_increment', se inician en 1 y se incrementan en 1 automáticamente.
Se utiliza generalmente en campos correspondientes a códigos de identificación para generar valores

únicos para cada nuevo registro que se inserta.
Sólo puede haber un campo "auto_increment" y debe ser clave primaria (o estar indexado).
Para establecer que un campo autoincremente sus valores automáticamente, éste debe ser entero
(integer) y debe ser clave primaria:

codigo int auto_increment,
titulo varchar(20),
autor varchar(30),
primary key (codigo)
);
Para definir un campo autoincrementable colocamos "auto_increment" luego de la definición del campo al
crear la tabla. Hasta ahora, al ingresar registros, colocamos el nombre de todos los campos antes de los
valores; es posible ingresar valores para algunos de los campos de la tabla, pero recuerde que al ingresar los
valores debemos tener en cuenta los campos que detallamos y el orden en que lo hacemos.
Cuando un campo tiene el atributo "auto_increment" no es necesario ingresar valor para él, porque se inserta
automáticamente tomando el último valor como referencia, o 1 si es el primero.
Para ingresar registros omitimos el campo definido como "auto_increment", por ejemplo:
insert into libros (titulo,autor,editorial) values('El aleph','Borges','Planeta');
Este primer registro ingresado guardará el valor 1 en el campo correspondiente al código.
Si continuamos ingresando registros, el código (dato que no ingresamos) se cargará automáticamente

siguiendo la secuencia de autoincremento.
Un campo "auto_increment" funciona correctamente sólo cuando contiene únicamente valores positivos.
Más adelante explicaremos cómo definir un campo con sólo valores positivos.
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','Paidos');
Pero debemos tener cuidado con la inserción de un dato en campos "auto_increment". Debemos tener en
cuenta que:
- si el valor está repetido aparecerá un mensaje de error y el registro no se ingresará.

- si el valor dado saltea la secuencia, lo toma igualmente y en las siguientes inserciones, continuará la
secuencia tomando el valor más alto.
- si el valor ingresado es 0, no lo toma y guarda el registro continuando la secuencia.
- si el valor ingresado es negativo (y el campo no está definido para aceptar sólo valores positivos), lo
ingresa.
Para que este atributo funcione correctamente, el campo debe contener solamente valores positivos; más
adelante trataremos este tema.

Problema 1: 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 PHP','Mario Molina','Emece');
insert into libros (titulo,autor,editorial) values('Cervantes y el quijote','Borges','Paidos');
insert into libros (titulo,autor,editorial) values('Matematica estas ahi', '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','Paidos');
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 camara 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 maravillas','Lewis

Carroll','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');
Problema 2: Una farmacia guarda información referente a sus medicamentos en una tabla llamada
"medicamentos".
1- Elimine la tabla,si existe:
drop table if exists medicamentos;
2- Cree la tabla con la siguiente estructura:

create table medicamentos(codigo integer auto_increment, nombre varchar(20), laboratorio
varchar(20), precio float, cantidad integer, primary key (codigo) );
3- Visualice la estructura de la tabla "medicamentos" (describe).
insert into medicamentos (nombre, laboratorio,precio,cantidad) values ('Sertal','Roche',5.2,100);

insert into medicamentos (nombre, laboratorio,precio,cantidad) values ('Buscapina','Roche',4.10,200);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values ('Amoxidal 500','Bayer',15.60,100);
5- Verifique que el campo "código" generó los valores de modo automático:
select codigo,nombre,laboratorio,precio,cantidad from medicamentos;
6- Intente ingresar un registro con un valor de clave primaria repetido.
7- Ingrese un registro con un valor de clave primaria no repetido salteando la secuencia:
insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values (12,'Paracetamol

500','Bago',1.90,200);
8- Ingrese el siguiente registro:
insert into medicamentos (nombre, laboratorio,precio,cantidad) values

('Bayaspirina','Bayer',2.10,150);
Note que sigue la secuencia.
13 - Comando truncate table.

Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin condición "where".
También podemos eliminar todos los registros de una tabla con "truncate table". Por ejemplo, queremos
vaciar la tabla "libros", usamos:
truncate table libros;
La sentencia "truncate table" vacía la tabla (elimina todos los registros) y vuelve a crear la tabla con la
misma estructura.
La diferencia con "drop table" es que esta sentencia borra la tabla, "truncate table" la vacía.
La diferencia con "delete" es la velocidad, es más rápido "truncate table" que "delete" (se nota cuando la
cantidad de registros es muy grande) ya que éste borra los registros uno a uno.

Otra diferencia es la siguiente: cuando la tabla tiene un campo "auto_increment", si borramos todos los
registros con "delete" y luego ingresamos un registro, al cargarse el valor en el campo autoincrementable,
continúa con la secuencia teniendo en cuenta el valor mayor que se había guardado; si usamos "truncate
table" para borrar todos los registros, al ingresar otra vez un registro, la secuencia del campo
autoincrementable vuelve a iniciarse en 1.
Por ejemplo, tenemos la tabla "libros" con el campo "codigo" definido "auto_increment", y el valor más alto de
ese campo es "5", si borramos todos los registros con "delete" y luego ingresamos un registro sin valor de
código, se guardará el valor "6"; si en cambio, vaciamos la tabla con "truncate table", al ingresar un nuevo
registro sin valor para el código, iniciará la secuencia en 1 nuevamente.
Creamos la tabla:
create table libros(codigo integer auto_increment, titulo varchar(20), autor varchar(30), editorial
varchar(15), primary key (codigo) );
insert into libros (titulo,autor,editorial) values('Martin Fierro','Jose Hernandez','Planeta');

insert into libros (titulo,autor,editorial) values('Aprenda PHP','Mario Molina','Emece');
insert into libros (titulo,autor,editorial) values('Cervantes y el quijote','Borges','Paidos');
insert into libros (titulo,autor,editorial) values('Matematica estas ahi', '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 poetica', 'Borges', 'Emece');
Vemos que la secuencia de "codigo" empezó en 1 nuevamente.
Ejecutamos entonces:
Problema 2: Una farmacia guarda información referente a sus medicamentos en una tabla llamada
"medicamentos".
create table medicamentos(codigo integer auto_increment, nombre varchar(20), laboratorio

varchar(20), precio float, cantidad integer, primary key (codigo) );
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100);

insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100);
4- Elimine todos los registros con "delete":
delete from medicamentos;
5- Ingrese 2 registros:

6- Vea los registros para verificar que continuó la secuencia al generar el valor para "codigo":
select * from medicamentos;
7- Vacíe la tabla:
truncate table medicamentos;
8- Ingrese el siguiente registro:
9- Vea los registros para verificar que al cargar el código reinició la secuencia en 1.
14 - Valores null.
Analizaremos la estructura de una tabla que vemos al utilizar el comando "describe". Tomamos como ejemplo
la tabla "libros":
Field Type Null Key Default Extra

______________________________________________________________________
codigo int(11) 7 b.. NO PRI auto_increment
titulo varchar(20) 11 b.. YES (NULL)
autor varchar(30) 11 b.. YES (NULL)
editorial varchar(15) 11 b.. YES (NULL)
precio float 5 b.. YES (NULL)
La primera columna indica el tipo de dato de cada campo.
La segunda columna "Null" especifica si el campo permite valores nulos; vemos que en el campo "codigo",
aparece "NO" y en las demás "YES", esto significa que el primer campo no acepta valores nulos (porque es
clave primaria) y los otros si los permiten.
La tercera columna "Key", muestra los campos que son clave primaria; en el campo "codigo" aparece "PRI" (es
clave primaria) y los otros están vacíos, porque no son clave primaria.
La cuarta columna "Default", muestra los valores por defecto, esto es, los valores que MySQL ingresa
cuando omitimos un dato o colocamos un valor inválido; para todos los campos, excepto para el que es clave
primaria, el valor por defecto es "null".
La quinta columna "Extra", muestra algunos atributos extra de los campos; el campo "codigo" es
"auto_increment".

Vamos a explicar los valores nulos.
"null' significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor 0, una cadena vacía o una
cadena literal "null".
A veces, puede desconocerse o no existir el dato correspondiente a algún campo de un registro. En estos
casos decimos que el campo puede contener valores nulos. Por ejemplo, en nuestra tabla de libros, podemos
tener valores nulos en el campo "precio" porque es posible que para algunos libros no le hayamos establecido
el precio para la venta.
En contraposición, tenemos campos que no pueden estar vacíos jamás, por ejemplo, los campos que
identifican cada registro, como los códigos de identificación, que son clave primaria.
Por defecto, es decir, si no lo aclaramos en la creación de la tabla, los campos permiten valores nulos.
Imaginemos que ingresamos los datos de un libro, para el cual aún no hemos definido el precio:
insert into libros (titulo,autor,editorial,precio) values ('El aleph','Borges','Planeta',null);
Note que el valor "null" no es una cadena de caracteres, no se coloca entre comillas.
Si un campo acepta valores nulos, podemos ingresar "null" cuando no conocemos el valor.
Los campos establecidos como clave primaria no aceptan valores nulos. Nuestro campo clave primaria, está
definido "auto_increment"; si intentamos ingresar el valor "null" para este campo, no lo tomará y seguirá la
secuencia de incremento.
El campo "titulo", no debería aceptar valores nulos, para establecer este atributo debemos crear la tabla
con la siguiente sentencia:
create table libros(codigo int auto_increment, titulo varchar(20) not null autor varchar(30), editorial
varchar(15), precio float, primary key (codigo) );
Entonces, para que un campo no permita valores nulos debemos especificarlo luego de definir el campo,
agregando "not null". Por defecto, los campos permiten valores nulos, pero podemos especificarlo
igualmente agregando "null".
Explicamos que "null" no es lo mismo que una cadena vacía o un valor 0 (cero).
Para recuperar los registros que contengan el valor "null" en el campo "precio" no podemos utilizar los
operadores relacionales vistos anteriormente: = (igual) y <> (distinto); debemos utilizar los operadores "is
null" (es igual a null) y "is not null" (no es null):
select * from libros where precio is null;

La sentencia anterior tendrá una salida diferente a la siguiente:
select * from libros where precio=0;
Con la primera sentencia veremos los libros cuyo precio es igual a "null" (desconocido); con la segunda, los
libros cuyo precio es 0.
Igualmente para campos de tipo cadena, las siguientes sentencias "select" no retornan los mismos
registros:
select * from libros where editorial is null;

select * from libros where editorial='';
Con la primera sentencia veremos los libros cuya editorial es igual a "null", con la segunda, los libros cuya
editorial guarda una cadena vacía.
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 ('Matematica 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" tipeamos:
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.
Problema 2: Retome la tabla llamada "medicamentos" que almacena la información de los productos
que se venden en una farmacia.
create table medicamentos(codigo integer auto_increment, nombre varchar(20) not null, laboratorio
varchar(20), precio float, cantidad integer not null, primary key (codigo) );
3- Visualice la estructura de la tabla "medicamentos".
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Sertal gotas','Roche',5.2,100);

insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Sertal compuesto','Roche',7.1,150);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Buscapina','Roche',null,200);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,0);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Amoxidal jarabe','Bayer',25,120);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Amoxinil',null,25,120);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Bayaspirina','',0,150);
5- Verifique que el campo "codigo" generó los valores de modo automático (select).
6- Recupere los registros que contengan valor "null" en el campo "laboratorio", luego los que tengan una
cadena vacía en el mismo campo. Note que el resultado es diferente:
select * from medicamentos where laboratorio is null;

select * from medicamentos where laboratorio='';
7- Recupere los registros que contengan valor "null" en el campo "precio", luego los que tengan el valor 0 en
el mismo campo. Note que el resultado es diferente:
select * from medicamentos where precio is null;

select * from medicamentos where precio=0;
8- Intente ingresar el siguiente registro con valor "null" para el campo "nombre":
insert into medicamentos (nombre, laboratorio,precio,cantidad) values(null,'Bayer',10.20,100);
Aparece un mensaje de error.
8- Intente ingresar el siguiente registro con valor "null" para el campo "cantidad":
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Benadryl

comprimidos','Bayer',10.20,null);
Aparece un mensaje de error.

9- Ingrese el siguiente registro con valor "null" para el campo correspondiente al código:
insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(null,'Benadryl

comprimidos','Bayer',10.20,null);
No muestra un mensaje de error. Si recuperamos todos los registros, verá que almacenó
el siguiente valor de la secuencia de autoincremento.
10- Recupere los registros cuyo precio sea distinto de 0, luego los que sean distintos de "null":
select * from medicamentos where precio<>0;

select * from medicamentos where precio is not null;
Note que la salida de la primera sentencia no muestra los registros con valor 0 y tampoco los que tienen
valor nulo; el resultado de la segunda sentencia muestra los registros con valor para el campo precio (incluso
el valor 0). Esto es porque los valores "null" no pueden compararse con operadores relacionales.
11- Recupere los registros en los cuales el laboratorio no contenga una cadena vacía, luego los que sean
distintos de "null":
select * from medicamentos where laboratorio<>'';

select * from medicamentos where laboratorio is not null;
Note que la primera sentencia solicita los registros que no tengan cadena vacía, es decir, los que guardan
una cadena, como "null" no es una cadena, no retorna los registros con valor nulo.
El resultado de la segunda sentencia solicita que no muestre los valores nulos, es decir, que muestre
cualquier cadena, incluso vacía.
15 - Valores numéricos sin signo (unsigned)

Hemos visto algunos atributos extra para los campos.
Los campos de tipo entero pueden tener el atributo "auto_increment", que incrementa automáticamente el
valor del campo en 1.
Los campos de cualquier tipo aceptan el atributo "null" y "not null" con lo cual permiten o no valores nulos.
Otro atributo que permiten los campos de tipo numérico es "unsigned".
El atributo "unsigned" (sin signo) permite sólo valores positivos.
Si necesitamos almacenar edades, por ejemplo, nunca guardaremos valores negativos, entonces sería
adecuado definir un campo "edad" de tipo entero sin signo:

edad integer unsigned;
Si necesitamos almacenar el precio de los libros, definimos un campo de tipo "float unsigned" porque jamás
guardaremos un valor negativo.
Hemos aprendido que al crear una tabla, es importante elegir el tipo de dato adecuado, el más preciso, según
el caso. Si un campo almacenará sólo valores positivos, es útil definir dicho campo con este atributo.
En los tipos enteros, "unsigned" duplica el rango, es decir, el tipo "integer" permite valores de -
2000000000 a 2000000000 aprox., si se define "integer unsigned" el rango va de 0 a 4000000000
aprox.
Los tipos de coma flotante (float por ejemplo) también aceptan el atributo "unsigned", pero el valor del límite
superior del rango se mantiene.
Problema 1: 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.
Problema 2: Trabaje con la tabla que almacena los datos sobre películas.
1- Elimine la tabla "peliculas", si existe.
2- Tenga en cuenta el rango de valores que almacenará cada campo:
-codigo: entero a partir de 1, autoincrementable,

-titulo: caracteres de 40 de longitud, no nulo,
-actor: cadena de 20,
-duracion: entero positivo,
-clave primaria: codigo.
3- Cree la tabla y defina cada campo según el rango de valores que almacenará:
create table peliculas(codigo integer unsigned auto_increment, titulo varchar(40) not null, actor
varchar(20), duracion integer unsigned, primary key(codigo) );
4- Visualice la estructura de la tabla.
16 - Tipos de datos
Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y
sus tipos más precisos, según el caso. Por ejemplo, si un campo numérico almacenará solamente valores
enteros positivos el tipo "integer" con el atributo "unsigned" es más adecuado que, por ejemplo un "float".
Hasta ahora hemos visto 3 tipos de datos: varchar, integer (con y sin signo) y float (con y sin signo). Hay
más tipos, incluso, subtipos. Los valores que podemos guardar son:
A) TEXTO: Para almacenar texto usamos cadenas de caracteres. Las cadenas se colocan entre comillas
simples. Podemos almacenar dígitos con los que no se realizan operaciones matemáticas, por ejemplo,
códigos de identificación, números de documentos, números telefónicos. Tenemos los siguientes tipos:
varchar, char y text.
B) NUMEROS: Existe variedad de tipos numéricos para representar enteros, negativos, decimales. Para
almacenar valores enteros, por ejemplo, en campos que hacen referencia a cantidades, precios, etc., usamos
el tipo integer. Para almacenar valores con decimales utilizamos: float o decimal.

C) FECHAS Y HORAS: para guardar fechas y horas dispone de varios tipos: date (fecha), datetime (fecha
y hora), time (hora), year (año) y timestamp.
D) OTROS TIPOS: enum y set representan una enumeración y un conjunto respectivamente. Lo veremos
más adelante.
E) Otro valor que podemos almacenar es el valor "null". El valor 'null' significa “valor desconocido” o "dato
inexistente", ya lo estudiamos. No es lo mismo que 0 o una cadena vacía.
17 - Tipos de datos (texto)

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y
sus tipos más precisos, según el caso.
Hasta ahora hemos visto 3 tipos de datos: varchar, integer (con y sin signo) y float (con y sin signo). Hay
más tipos, incluso, subtipos.
Para almacenar TEXTO usamos cadenas de caracteres. Las cadenas se colocan entre comillas simples.
Podemos almacenar dígitos con los que no se realizan operaciones matemáticas, por ejemplo, códigos de
identificación, números de documentos, números telefónicos. Tenemos los siguientes tipos:
1) varchar(x): define una cadena de caracteres de longitud variable en la cual determinamos el máximo de
caracteres con el argumento "x" que va entre paréntesis. Su rango va de 1 a 255 caracteres. Un
varchar(10) ocupa 11 bytes, pues en uno de ellos almacena la longitud de la cadena. Ocupa un byte más que
la cantidad definida.
2) char(x): define una cadena de longitud fija, su rango es de 1 a 255 caracteres. Si la cadena ingresada es
menor a la longitud definida (por ejemplo cargamos 'Juan' en un char(10)), almacena espacios en blanco a la
derecha, tales espacios se eliminan al recuperarse el dato. Un char(10) ocupa 10 bytes, pues al ser fija su
longitud, no necesita ese byte adicional donde guardar la longitud. Por ello, si la longitud es invariable, es
conveniente utilizar el tipo char; caso contrario, el tipo varchar.
Ocupa tantos bytes como se definen con el argumento "x". Si ingresa un argumento mayor al permitido
(255) aparece un mensaje indicando que no se permite y sugiriendo que use "blob" o "text". Si omite el
argumento, coloca 1 por defecto.
3) blob o text: bloques de datos de 60000 caracteres de longitud aprox. No lo veremos por ahora.
Para los tipos que almacenan cadenas, si asignamos una cadena de caracteres de mayor longitud que la
permitida o definida, la cadena se corta. Por ejemplo, si definimos un campo de tipo varchar(10) y le
asignamos la cadena 'Buenas tardes', se almacenará 'Buenas tar' ajustándose a la longitud de 10.
Es importante elegir el tipo de dato adecuado según el caso, el más preciso. Por ejemplo, si vamos a
almacenar un caracter, conviene usar char(1), que ocupa 1 byte y no varchar(1), que ocupa 2 bytes.

Tipo Bytes de almacenamiento
_______________________________________
char(x) x
varchar(x) x+1
Problema 1: 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.
Problema 2: Una concesionaria de autos vende autos usados y almacena los datos de los autos en
una tabla llamada "autos".
1- Elimine la tabla "autos" si existe.
create table autos(patente char(6), marca varchar(20), modelo char(4), precio float unsigned, primary
key(patente) );
insert into autos (patente,marca,modelo,precio) values('ACD123','Fiat 128','1970',15000);

insert into autos (patente,marca,modelo,precio) values('ACG234','Renault 11','1990',40000);
insert into autos (patente,marca,modelo,precio) values('BCD333','Peugeot 505','1990',80000);
insert into autos (patente,marca,modelo,precio) values('GCD123','Renault Clio','1990',70000);
insert into autos (patente,marca,modelo,precio) values('BCC333','Renault Megane','1998',95000);
insert into autos (patente,marca,modelo,precio) values('BVF543','Fiat 128','1975',20000);
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 "modelo", en el cual almacenaremos el
año, necesitamos 4 caracteres fijos. Para el campo "precio" definimos un float sin signo porque los valores
nunca serán negativos.

4- Seleccione todos los autos del año 1990:
select * from autos where modelo='1990';
5- Seleccione todos los autos con precio superior a 50000:
select * from autos where precio>50000;
18 - Tipos de datos (numéricos)

Hasta ahora hemos visto 2 tipos de datos para almacenar valores numéricos: integer (con y sin signo) y
float (con y sin signo). Existe variedad de tipos numéricos para representar enteros, negativos, decimales.
Para almacenar valores enteros, por ejemplo, en campos que hacen referencia a cantidades, precios, etc.,
usamos:
1) integer(x) o int(x): su rango es de -2000000000 a 2000000000 aprox. El tipo "int unsigned" va de
0 a 4000000000. El tipo "integer" tiene subtipos:
- mediumint(x): va de –8000000 a 8000000 aprox. Sin signo va de 0 a 16000000 aprox.
- smallint(x): va de –30000 a 30000 aprox., sin signo, de 0 a 60000 aprox.
- tinyint(x): define un valor entero pequeño, cuyo rango es de -128 a 127. El tipo sin signo va de 0 a 255.
- bool o boolean: sinónimos de tinyint(1). Un valor cero se considera falso, los valores distintos de cero,
verdadero.
- bigint(x): es un entero largo. Va de –9000000000000000000 a 9000000000000000000

aprox. Sin signo es de 0 a 10000000000000000000.
Para almacenar valores con decimales utilizamos:
2) float (t,d): número de coma flotante. Su rango es de -3.4e+38 a –1.1e-38 (9 cifras).
3) decimal o numeric (t,d): el primer argumento indica el total de dígitos y el segundo, la cantidad de
decimales. El rango depende de los argumentos, también los bytes que ocupa. Si queremos almacenar
valores entre 0.00 y 99.99 debemos definir el campo como tipo "decimal (4,2)". Si no se indica el valor del
segundo argumento, por defecto es 0. Para los tipos "float" y "decimal" se utiliza el punto como separador
de decimales.
Todos los tipos enteros pueden tener el atributo "unsigned", esto permite sólo valores positivos y duplica el
rango. Los tipos de coma flotante también aceptan el atributo "unsigned", pero el valor del límite superior
del rango no se modifica.

Es importante elegir el tipo de dato adecuado según el caso, el más preciso. Por ejemplo, si un campo
numérico almacenará valores positivos menores a 10000, el tipo "int" no es el más adecuado, porque su
rango va de -2000000000 a 2000000000 aprox., conviene el tipo "smallint unsigned", cuyo rango va de
0 a 60000 aprox. De esta manera usamos el menor espacio de almacenamiento posible.

_______________________________________
tinyint 1
smallint 2
mediumint 3
int 4
bigint 8
float 4
decimal(t,d) t+2 si d>0, t+1 si d=0 y d+2 si t<d
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".

editorial varchar(15), precio decimal(5,2) unsigned, cantidad smallint unsigned, primary key (codigo));
describe libros;
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".
Problema 2: Un comercio que envía pizzas y empanadas a domicilio registra los pedidos diariamente
en una tabla llamada "pedidos" con los siguientes datos:
- numero de pedido, autoincrementable, entero positivo comienza en 1 y menor a 200 aprox.

- nombre: piza o empanada,
- tipo: por ejemplo, si es pizza: especial, muzarela, etc., si son empanadas: salteñas, picantes,
arabes, etc.
- precio: precio por unidad, valor con decimales que no supera los $99.99 y será siempre mayor a 0,
- cantidad: cantidad de articulos, entero positivo desde 1 e inferior a 200 aprox.
- domicilio del cliente.
1- Elimine la tabla "pedidos" si existe.
2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo.
19 - Tipos de datos (fechas y horas)

Para guardar fechas y horas dispone de varios tipos:
1) date: representa una fecha con formato "YYYY-MM-DD". El rango va de "1000-01-01" a "9999-12-
31".
2) datetime: almacena fecha y hora, su formato es "YYYY-MM-DD HH:MM:SS". El rango es de "1000-01-

01 00:00:00" a "9999-12-31 23:59:59".
3) time: una hora. Su formato es "HH:MM:SS". El rango va de "-838:59:59" a "838:59:59".
4) year(2) y year(4): un año. Su formato es "YYYY" o "YY". Permite valores desde 1901 a 2155 (en
formato de 4 dígitos) y desde 1970 a 2069 (en formato de 2 dígitos).

Si ingresamos los valores como cadenas, un valor entre "00" y "69" es convertido a valores "year" en el rango
de 2000 a 2069; si el valor está entre "70" y "99", se convierten a valores "year" en el rango 1970 a 1999.
Si ingresamos un valor numérico 0, se convierte en "0000"; entre 1 y 69, se convierte a valores "year" entre
2001 a 2069; entre 70 y 99, es convertido a valores "year" de 1970 a 1999.
Para almacenar valores de tipo fecha se permiten como separadores "/", "-" y ".".
Si ingresamos '06-12-31' (año de 2 dígitos), lo toma como '2006-12-31'.
Si ingresamos '2006-2-1' (mes y día de 1 dígito), lo toma como '2006-02-01'.
Si ingresamos '20061231' (cadena sin separador), lo toma como '2006-12-31'.
Si ingresamos 20061231 (numérico), lo toma como '2006-12-31'.
Si ingresamos '20061231153021' (cadena sin separadores), lo toma como '2006-12-31 15:30:21'.
Si ingresamos '200612311530' (cadena sin separadores con un dato faltante) no lo reconoce como
fechahora y almacena ceros.
Si ingresamos '2006123' (cadena sin separadores con un dato faltante) no lo reconoce como fecha y
almacena ceros.
Si ingresamos '2006-12-31 11:30:21' (valor date time) en un campo 'date', toma sólo la parte de la fecha,
la hora se corta, se guarda '2006-12-31'.
Es importante elegir el tipo de dato adecuado según el caso, el más preciso. Por ejemplo, si sólo necesitamos
registrar un año (sin día ni mes), el tipo adecuado es "year" y no "date".

_______________________________________
date 3
datetime 8
time 3
year 1
Problema1: 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".
Problema 2: Una concesionaria de autos vende autos usados. Guarda los siguientes datos en la tabla
"autos":
- marca (fiat 128, renault 11, peugeot 505, etc.)

- modelo (año)
- dueño (nombre del dueño)
- precio (valor con decimales positivo que puede llegar hasta 999999.99 aprox.).
2- Cree la tabla eligiendo el tipo de dato adecuado para almacenar estos datos:
create table autos(marca varchar(15), modelo year, dueño varchar(30), precio decimal (8,2)
unsigned);
insert into autos values('Fiat 128','1970','Juan Lopez',50000);

insert into autos values('Renault 11','1990','Juan Lopez',80000);
insert into autos values('Fiat 128','1971','Ana Ferreyra',51000);
insert into autos values('Peugeot 505','1998','Luis Luque',99000);
insert into autos values('Peugeot 505','1997','Carola Perez',85000);
4- Seleccione todos los autos cuyo modelo sea menor a "1995":
select * from autos where modelo<1995;
5- Muestre la marca y modelo de los autos que no sean de "1970":
select marca,modelo from autos where modelo<>1970;
6- Ingrese un auto con el valor para "modelo" de tipo numérico:
insert into autos values('Peugeot 505',1995,'Carlos Lopez',88000);

20 - Valores por defecto.
Hemos visto los valores por defecto de los distintos tipos de datos. Ahora que conocemos más tipos de
datos, vamos a ampliar la información referente a ellos y a repasar los conocidos.
Para campos de cualquier tipo no declarados "not null" el valor por defecto es "null" (excepto para tipos
"timestamp" que no trataremos aquí).
Para campos declarados "not null", el valor por defecto depende del tipo de dato. Para cadenas de
caracteres el valor por defecto es una cadena vacía. Para valores numéricos el valor por defecto es 0; en
caso de ser "auto_increment" es el valor mayor existente+1 comenzando en 1. Para campos de tipo fecha
y hora, el valor por defecto es 0 (por ejemplo, en un campo "date" es "0000-00-00").
Para todos los tipos, excepto "blob", "text" y "auto_increment" se pueden explicitar valores por defecto con
la cláusula "default"; tema que veremos más adelante.
Un valor por defecto se inserta cuando no está presente al ingresar un registro y en algunos casos en que
el dato ingresado es inválido.
Los campos para los cuales no se ingresaron valores tomarán los valores por defecto según el tipo de dato
del campo, en el campo "codigo" ingresará el siguiente valor de la secuencia porque es "auto_increment"; en
el campo "titulo", ingresará una cadena vacía porque es "varchar not null"; en el campo "editorial" almacenará
"null", porque no está definido "not null"; en el campo "precio" guardará "null" porque es el valor por defecto de
los campos no definidos como "not null" y en el campo "cantidad" ingresará 0 porque es el valor por defecto
de los campos numéricos que no admiten valores nulos.
Tipo Valor por defecto Cláusula "default"

____________________________________________________________________________
caracter not null cadena vacía permite
numerico not null 0 permite
fecha not null 0000-00-00 permite
hora not null 00:00:00 permite
auto_increment siguiente de la sec., empieza en 1 no permite
carac.,numer.,fecha,hora null null permite

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 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.
Problema 2: Trabaje con la tabla que almacena los datos sobre películas, llamada "peliculas".
2- Créela con la siguiente estructura:
-codigo (entero sin signo, autoincrementable),

-titulo (cadena de 30, not nulo),
-actor (cadena de 20),
-duracion (entero positivo hasta 200 apox.),
-clave primaria (codigo).
3- Agregue los siguientes registros para ver cómo guarda MySQL los valores no ingresados:
insert into peliculas (titulo,actor,duracion) values ('Mision imposible','Tom Cruise',120);

insert into peliculas (codigo,duracion) values (5,90);
insert into peliculas (titulo,actor) values ('Harry Potter y la piedra filosofal','Daniel R.');
insert into peliculas (titulo,actor,duracion) values ('Harry Potter y la piedra filosofal','Daniel R.',120);
4- Seleccione todos los datos de las películas para ver cómo guardó MySQL los valores no ingresados. En
el primer registro ingresado, en el campo "codigo" ingresará "1", el primer valor para campos
"auto_increment". En el segundo registro ingresado se almacena una cadena vacía para el título y el valor

"null" para el actor. En el tercer registro guarda "6" en "codigo", el siguiente valor de la secuencia tomando el
valor más alto y en "duracion" almacena "0". En el cuarto registro sigue la secuencia del código.
21 - Valores inválidos.
Hemos visto los valores por defecto de los distintos tipos de datos.
Un valor por defecto se inserta cuando no está presente al ingresar un registro y en algunos casos en que
el dato ingresado es inválido.
Un valor es inválido por tener un tipo de dato incorrecto para el campo o por estar fuera de rango.
Veamos los distintos tipos de datos inválidos.
Para campos de tipo caracter:
-valor numérico: si en un campo definido de tipo caracter ingresamos un valor numérico, lo convierte
automáticamente a cadena. Por ejemplo, si guardamos 234 en un varchar, almacena '234'.
-mayor longitud: si intentamos guardar una cadena de caracteres mayor a la longitud definida, la cadena
se corta guardando sólo la cantidad de caracteres que quepa. Por ejemplo, si definimos un campo de tipo
varchar(10) y le asignamos la cadena 'Buenas tardes', se almacenará 'Buenas tar' ajustándose a la longitud
de 10.
Para campos numéricos:
-cadenas: si en un campo numérico ingresamos una cadena, lo pasa por alto y coloca 0. Por ejemplo, si en un
campo de tipo "integer" guardamos 'abc', almacenará 0.
-valores fuera de rango: si en un campo numérico intentamos guardar un valor fuera de rango, se almacena
el valor límite del rango más cercano (menor o mayor). Por ejemplo, si definimos un campo 'tinyint' (cuyo rango
va de -128 a 127) e intentamos guardar el valor 200, se almacenará 127, es decir el máximo permitido
del rango; si intentamos guardar -200, se guardará -128, el mínimo permitido por el rango. Otro ejemplo, si
intentamos guardar el valor 1000.00 en un campo definido como decimal(5,2) guardará 999.99 que es el
mayor del rango.
-valores incorrectos: si cargamos en un campo definido de tipo decimal un valor con más decimales que los
permitidos en la definición, el valor es redondeado al más cercano. Por ejemplo, si cargamos en un campo
definido como decimal(4,2) el valor 22.229, se guardará 22.23, si cargamos 22.221 se guardará 22.22.
Para campos definidos auto_increment el tratamiento es el siguiente:
- Pasa por alto los valores fuera del rango, 0 en caso de no ser "unsigned" y todos los menores a 1 en caso
de ser "unsigned".

- Si ingresamos un valor fuera de rango continúa la secuencia.
- Si ingresamos un valor existente, aparece un mensaje de error indicando que el valor ya existe.
Para campos de fecha y hora:
-valores incorrectos: si intentamos almacenar un valor que MySql no reconoce como fecha (sea fuera de
rango o un valor inválido), convierte el valor en ceros (según el tipo y formato). Por ejemplo, si intentamos
guardar '20/07/2006' en un campo definido de tipo "date", se almacena '0000-00-00'. Si intentamos
guardar '20/07/2006 15:30' en un campo definido de tipo "datetime", se almacena '0000-00-00
00:00:00'. Si intentamos almacenar un valor inválido en un campo de tipo "time", se
guarda ceros. Para "time", si intentamos cargar un valor fuera de rango, se guarda el menor o mayor valor
permitido (según sea uno u otro el más cercano).
Para campos de cualquier tipo:
-valor "null": si un campo está definido "not null" e intentamos ingresar "null", aparece un mensaje de error y
la sentencia no se ejecuta. (Los valores inválidos para otros tipos de campos lo trataremos más adelante.)
RESUMEN:
Tipo Valor inválido Resultado

__________________________________________________________________________________
caracter null/ not null 123 '123'
caracter null/ not null mayor longitud se corta
caracter not null null error
numérico null/ not null '123' 0
numérico null/ not null fuera de rango límite más cercano
numérico not null null error
numérico decimal null/ not null más decimales que los definidos redondea al más cercano
num. auto_incr. c/signo null/not null 0 siguiente de la secuencia
num. auto_incr. s/signo null/not null todos los menores a 1 siguiente de la secuencia
num. auto_incr. c/s signo null null siguiente de la secuencia
num. auto_incr. c/s signo null/not null valor existente error
fecha fuera de rango 0000-00-00
fecha '20-07-2006' (otro orden) 0000-00-00
hora fuera de rango límite más cercano
fecha y hora not null null error
Problema 1:Trabajamos con la tabla "libros" de una librería.

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 ('Matematica estas

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 poetica','Borges',null);
Muestra un mensaje de error indicando que el campo "cantidad" no acepta valores nulos.
Problema 2: 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, domicilio
varchar(30), fechaingreso date not null, fechanacimiento date, primary key(documento) );
3- Intente ingresar la fecha "20-10-2005" para la fecha de ingreso:
insert into empleados (documento,fechaiIngreso,fechanacimiento) values('22333444','20-10-

2005',null);
Se almacenan ceros.
4- Intente almacenar "null" en "fechaingreso":
insert into empleados (documento,fechaingreso,fechanacimiento) values('22333444',null,'2005-

10-10');
Muestra un mensaje de error.
5- Intente almacenar valores nulos en los campos "documento" y " nombre".

6- Almacene un valor numérico en un campo de tipo caracter.
7- Almacene en "documento" el valor "22.345.678".
22 - Atributo default en una columna de una tabla.

Si al insertar registros no se especifica un valor para un campo, se inserta su valor por defecto implícito
según el tipo de dato del campo. Por ejemplo:
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", MySQL insertará el valor por defecto, como "codigo" es
un campo "auto_increment", el valor por defecto es el siguiente de la secuencia.
Si omitimos el valor correspondiente al autor:
insert into libros (titulo,editorial,precio,cantidad) values('Java en 10 minutos','Paidos',25.7,200);
MySQL insertará "null", porque el valor por defecto de un campo (de cualquier tipo) que acepta valores nulos,
es "null".
Lo mismo sucede si no ingresamos el valor del precio:
insert into libros (titulo,autor,editorial,cantidad) values('Java en 10 minutos','Juan

Pereyra',Paidos',150);
MySQL insertará el valor "null" porque el valor por defecto de un campo (de cualquier tipo) que acepta valores
nulos, es "null".
Si omitimos el valor correspondiente al título:
insert into libros (autor,editorial,precio,cantidad) values ('Borges','Paidos',25.7,200);
MySQL guardará una cadena vacía, ya que éste es el valor por defecto de un campo de tipo cadena definido
como "not null" (no acepta valores nulos).
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 el campo "precio" es de tipo numérico "not null" y el valor por defecto
de los tipos numéricos que no aceptan valores nulos es 0.

Podemos establecer valores por defecto para los campos cuando creamos la tabla. Para ello utilizamos
"default" al definir el campo. Por ejemplo, queremos que el valor por defecto del campo "precio" sea 1.11 y el
valor por defecto del campo "autor" sea "Desconocido":
codigo int unsigned auto_increment, titulo varchar(40) not null, autor varchar(30) default
'Desconocido', precio decimal(5,2) unsigned default 1.11, cantidad int unsigned not null, primary key
(codigo) );
Si al ingresar un nuevo registro omitimos los valores para el campo "autor" y "precio", MySQL insertará los
valores por defecto definidos con la palabra clave "default":
insert into libros (titulo,editorial,cantidad) values('Java en 10 minutos','Paidos',200);
MySQL insertará el registro con el siguiente valor de la secuencia en "codigo", con el título, editorial y
cantidad ingresados, en "autor" colocará "Desconocido" y en precio "1.11".
Entonces, si al definir el campo explicitamos un valor mediante la cláusula "default", ése será el valor por
defecto; sino insertará el valor por defecto implícito según el tipo de dato del campo.
Los campos definidos "auto_increment" no pueden explicitar un valor con "default", tampoco los de tipo
"blob" y "text".
Los valores por defecto implícitos son los siguientes:
-para campos de cualquier tipo que admiten valores nulos, el valor por defecto "null";
-para campos que no admiten valores nulos, es decir, definidos "not null", el valor por defecto depende del
tipo de dato:
-para campos numéricos no declarados "auto_increment": 0;
-para campos numéricos definidos "auto_increment": el valor siguiente de la secuencia, comenzando en 1;
-para los tipos cadena: cadena vacía.
Ahora al visualizar la estructura de la tabla con "describe" podemos entender un poco más lo que informa
cada columna:
describe libros;
"Field" contiene el nombre del campo; "Type", el tipo de dato; "NULL" indica si el campo admite valores nulos;
"Key" indica si el campo está indexado (lo veremos más adelante); "Default" muestra el valor por defecto del

campo y "Extra" muestra información adicional respecto al campo, por ejemplo, aquí indica que "codigo" está
definido "auto_increment".
También se puede utilizar "default" para dar el valor por defecto a los campos en sentencias "insert", por
ejemplo:
insert into libros (titulo,autor,precio,cantidad) values ('El gato con botas',default,default,100);
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 PHP','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áuslua "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);
Problema 2: Un comercio que envía pizzas y empanadas a domicilio registra los pedidos diariamente
en una tabla llamada "pedidos" con los siguientes datos:
- numero de pedido, autoincrementable, entero positivo comienza en 1 y menor a 200 aprox.

- nombre: pizza o empanada, por defecto "empanada",
- tipo: por ejemplo, si es pizza: especial, muzarela, etc., si son empanadas: arabes, pollo, jamón
y queso, criollas, etc.
- precio: precio por unidad, valor con decimales que no supera los $99.99 y será siempre mayor a
0, por defecto "1",
- cantidad: cantidad de articulos, entero positivo desde 1 e inferior a 200 aprox., por
defecto "12"
- domicilio del cliente.
1- Elimine la tabla "pedidos" si existe.
2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo.
insert into pedidos (nombre,tipo,precio,cantidad,domicilio) values('piza','muzarela','4.00',3,'Sarmiento 235');

insert into pedidos (tipo,precio,cantidad,domicilio) values('arabe','1.00',24,'Urquiza 296');
insert into pedidos (nombre,tipo,domicilio) values('empanada','salteña','Colon 309');
insert into pedidos (tipo,domicilio) values('arabe','San Martin 444');
insert into pedidos (nombre,tipo,precio,domicilio) values('piza','especial','4.00','Avellaneda 395');

4- Muestre todos los campos de todos los pedidos para ver cómo se guardaron los datos no ingresados.
Otro problema: 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.
1- Elimine la tabla "visitantes", si existe.
create table visitantes(nombre varchar(30) not null, edad tinyint unsigned, sexo char(1) default 'f',
domicilio varchar(30), ciudad varchar(20) default 'Cordoba', telefono varchar(11),
mail varchar(30) default 'no tiene', montocompra decimal (6,2) );
4- Ingrese algunos registros sin especificar valores para algunos campos para ver cómo opera la
cláusula "default".
5- Muestre todos los registros.
B) 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 en que tiene que
devolver el libro y si el libro ha sido o no devuelto.
1- Elimine la tabla "prestamos" si existe.
2- Cree 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' );
insert into prestamos (titulo,documento,fechaprestamo,fechadevolucion)

values ('Manual de 1 grado','23456789','2006-08-10','2006-08-12');
values ('Alicia en el pais de las maravillas','23456789','2006-08-12','2006-08-14');
values ('El aleph','22543987','2006-08-15','2006-08-17');
values ('Manual de geografia 5 grado','25555666','2006-08-30','2006-09-01');
4- Seleccione todos los registros para ver qué se guardó en el campo "devuelto" para el cual no ingresamos
datos.

23 - Atributo zerofill en una columna de una tabla.
Cualquier campo numérico puede tener otro atributo extra "zerofill".
"zerofill" rellena con ceros los espacios disponibles a la izquierda.
Por ejemplo, creamos la tabla "libros", definiendo los campos "codigo" y "cantidad" con el atributo "zerofill":
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) );
Note que especificamos el tamaño del tipo "int" entre paréntesis para que muestre por la izquierda ceros,
cuando los valores son inferiores al indicado; dicho parámetro no restringe el rango de valores que se pueden
almacenar ni el número de digitos.
Al ingresar un valor de código con menos cifras que las especificadas (6), aparecerán ceros a la izquierda
rellenando los espacios; por ejemplo, si ingresamos "33", aparecerá "000033". Al ingresar un valor para el
campo "cantidad", sucederá lo mismo.
Si especificamos "zerofill" a un campo numérico, se coloca automáticamente el atributo "unsigned".
Cualquier valor negativo ingresado en un campo definido "zerofill" es un valor inválido.
Problema 1: rabajamos con la tabla "libros" de una librería.
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:

values('Martin Fierro','Jose Hernandez','Planeta',34.5,200);
values('Aprenda PHP','Mario Molina','Emece',45.7,50);
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,'Matematica estas ahi', '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".
Problema 2: Un banco tiene registrados las cuentas corrientes de sus clientes en una tabla llamada
"cuentas".
2- Cree la tabla:

create table cuentas(numero int(8) zerofill auto_increment, documento char(8) not null, nombre
varchar(30), saldo decimal(9,2), primary key(numero) );
3- Visualice la estructura de la tabla:
describe cuentas;
note que en la columna que muestra el tipo aparece "zerofill" en el campo "numero".
insert into cuentas (numero,documento,nombre,saldo)

values(1234,'22333444','Juan Perez',2000.60);
values(2566,'23333444','Maria Pereyra',5050);
values(5987,'24333444','Marcos Torres',200);
values(14434,'25333444','Ana Juarez',8000.60);
5- Vea cómo se guardaron los números de cuenta:
select * from cuentas;
6- Ingrese un valor negativo para el número de cuenta:

values(-1234,'27333444','Luis Duarte',2800);
note que no lo toma y sigue la secuencia.
Otro problema: Trabaje con la tabla que almacena los datos sobre películas, llamada "peliculas".
2- Créela con la siguiente estructura:
create table peliculas(codigo int(4) zerofill auto_increment, titulo varchar(30) not null, actor
varchar(20), duracion tinyint zerofill default 90, primary key (codigo) );
describe peliculas;

note que el atributo "zerofill" aparece en los campos "codigo" y "duracion", en la columna que describe el tipo
de cada dato.
4- Ingrese algunos registros.
5- Ingrese un valor de código negativo.
6- Ingrese un valor de duración negativo.
24 - Columnas calculadas.
Es posible obtener salidas en las cuales una columna sea el resultado de un cálculo y no un campo de una
tabla.
Si queremos ver los títulos, precio y cantidad de cada libro escribimos la siguiente sentencia:
select titulo,precio,cantidad from libros;
Si queremos saber el monto total en dinero de un título podemos multiplicar el precio por la cantidad por
cada título, pero también podemos hacer que MySQL realice el cálculo y lo incluya en una columna extra en
la salida:
select titulo, precio,cantidad,precio*cantidad from libros;
Si queremos 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;
Problema 1:Trabajamos con la tabla "libros" de una librería.
Creamos la tabla:
editorial varchar(15), precio decimal(5,2) unsigned, cantidad smallint unsigned, primary key (codigo) );

values('El aleph','Borges','Planeta',15,100);
values('Martin Fierro','Jose Hernandez','Emece',22.20,200);
values('Antologia poetica','Borges','Planeta',40,150);
values('Aprenda PHP','Mario Molina','Emece',18.20,200);
values('Cervantes y el quijote','Borges','Paidos',36.40,100);
values('Manual de PHP', 'J.C. Paez', 'Paidos',30.80,100);
values('Harry Potter y la piedra filosofal','J.K. Rowling','Paidos',45.00,500);
values('Harry Potter y la camara secreta','J.K. Rowling','Paidos',46.00,300);
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;
Problema 2: Una empresa almacena los datos de sus empleados en una tabla "empleados".
2- Cree una tabla llamada "empleados" con la estructura necesaria para almacenar la siguiente información:
- nombre del empleado,

- documento,
- sexo,
- domicilio,
- sueldo básico (hasta 9999.99),
- hijos a cargo,
- clave primaria: documento.

insert into empleados (nombre,documento,sexo,sueldobasico,hijos)

values ('Juan Perez','22333444','m',300,1);
values ('Ana Acosta','21333444','f',400,2);
values ('Alberto Lopez','24333444','m',600,0);
values ('Carlos Sanchez','30333444','m',550,3);
values ('Mariana Torres','23444555','f',600,1);
values ('Marcos Garcia','23664555','m',1500,2);
4- La empresa está pensando en aumentar un 10% el sueldo a los empleados, y quiere saber a cuánto
subiría cada sueldo básico, para ello usamos la siguiente sentencia en la cual incluimos una columna que hará
el cálculo de cada sueldo más el 10%:
select nombre, sueldobasico,sueldobasico+sueldobasico*1/10 from empleados;
5- La empresa paga un salario familiar por hijos a cargo, $200 por cada hijo. Necesitamos el nombre
del empleado, el sueldo básico, la cantidad de hijos a cargo, el total del salario familiar y el suedo final
(incluyendo el salario familiar):
select nombre, sueldobasico,hijos,(200*hijos),sueldobasico+(200*hijos) from empleados;
Otros problemas: Un comercio vende artículos de librería y papelería. Almacena en una tabla los
siguientes datos:
- codigo: int unsigned auto_increment, clave primaria,

- nombre: varchar(30),
- precio: decimal(5,2),
- cantidad: smallint unsigned.
2- Cree la tabla con la estructura necesaria para almacenar los datos descriptos anteriormente.
insert into articulos (nombre,precio,cantidad) values ('lapices coloresx6',1.4,100);


insert into articulos (nombre,precio,cantidad) values ('goma tinta',0.2,150);
insert into articulos (nombre,precio,cantidad) values ('birome',1.2,200);
insert into articulos (nombre,precio,cantidad) values ('escuadra',3.2,200);
insert into articulos (nombre,precio,cantidad) values ('compás plástico',5,200);
insert into articulos (nombre,precio,cantidad) values ('compás metal',8.4,250);
4- El precio representa el costo del artículo al comprarlo. Este comercio vende sus artículos por mayor y
por menor, para la venta minorista incrementa el precio de costo en un 10%, para la venta mayorista lo
incrementa en un 5%. Muestre los precios de cada artículo y calcule en 2 columnas diferentes el precio de
cada uno de ellos al venderse por mayor y por menor:
select nombre,precio,precio+precio*0.1,precio+precio*0.05 from articulos;
5- El gerente de dicho comercio necesita saber cuánto dinero hay invertido en cada artículo, para ello,
necesitamos multiplicar el precio de cada artículo por la cantidad:
select nombre,precio,cantidad,precio*cantidad from articulos;
25 - Funciones para el manejo de cadenas.

RECUERDE que NO debe haber espacios entre un nombre de función y los paréntesis porque MySQL puede
confundir una llamada a una función con una referencia a una tabla o campo que tenga el mismo nombre de
una función.
MySQL tiene algunas funciones para trabajar con cadenas de caracteres. Estas son algunas:
-ord(caracter): Retorna el código ASCII para el caracter enviado como argumento. Ejemplo:
select ord('A');
retorna 65.
-char(x,..): retorna una cadena con los caracteres en código ASCII de los enteros enviados como
argumentos. Ejemplo:
select char(65,66,67);
retorna "ABC".
-concat(cadena1,cadena2,...): devuelve la cadena resultado de concatenar los argumentos. Ejemplo:
select concat('Hola,',' ','como esta?');

retorna "Hola, como esta?".

-concat_ws(separador,cadena1,cadena2,...): "ws" son las iniciales de "with separator". El primer
argumento especifica el separador que utiliza para los demás argumentos; el separador se agrega entre las
cadenas a concatenar. Ejemplo:
select concat_ws('-','Juan','Pedro','Luis');
retorna "Juan-Pedro-Luis".
-find_in_set(cadena,lista de cadenas): devuelve un valor entre de 0 a n (correspondiente a la posición), si

la cadena envidada como primer argumento está presente en la lista de cadenas enviadas como segundo
argumento. La lista de cadenas enviada como segundo argumento es una cadena formada por subcadenas
separadas por comas. Devuelve 0 si no encuentra "cadena" en la "lista de cadenas". Ejemplo:
select find_in_set('hola','como esta,hola,buen dia');

retorna 2, porque la cadena "hola" se encuentra en la lista de cadenas, en la posición 2.
-length(cadena): retorna la longitud de la cadena enviada como argumento. Ejemplo:
select length('Hola');
devuelve 4.
- locate(subcadena,cadena): retorna la posición de la primera ocurrencia de la subcadena en la cadena

enviadas como argumentos. Devuelve "0" si la subcadena no se encuentra en la cadena. Ejemplo:
select locale('o','como le va');

retorna 2.
- position(subcadena in cadena): funciona como "locate()". Devuelve "0" si la subcadena no se encuentra en

la cadena. Ejemplo:
select position('o' in 'como le va');

retorna 2.
- locate(subcadena,cadena,posicioninicial): retorna la posición de la primera ocurrencia de la subcadena

enviada como primer argumentos en la cadena enviada como segundo argumento, empezando en la posición
enviada como tercer argumento. Devuelve "0" si la subcadena no se encuentra en la cadena. Ejemplos:
select locate('ar','Margarita',1);
retorna 1.
select locate('ar','Margarita',3);
retorna 5.
- instr(cadena,subcadena): retorna la posición de la primera ocurrencia de la subcadena enviada como

segundo argumento en la cadena enviada como primer argumento. Ejemplo:

select instr('como le va','om');
devuelve 2.
- lpad(cadena,longitud,cadenarelleno): retorna la cadena enviada como primer argumento, rellenada por la

izquierda con la cadena enviada como tercer argumento hasta que la cadena retornada tenga la longitud
especificada como segundo argumento. Si la cadena es más larga, la corta. Ejemplo:
select lpad('hola',10,'0');
retorna "000000hola".
- rpad(cadena,longitud,cadenarelleno): igual que "lpad" excepto que rellena por la derecha.
- left(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena comenzando desde la

inquierda, primer caracter. Ejemplo:
select left('buenos dias',8);

retorna "buenos d".
- right(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena comenzando desde la

derecha, último caracter. Ejemplo:
select right('buenos dias',8);

retorna "nos dias".
- substring(cadena,posicion,longitud): retorna una subcadena de tantos caracteres de longitud como

especifica en tercer argumento, de la cadena enviada como primer argumento, empezando desde la posición
especificada en el segundo argumento. Ejemplo:
select substring('Buenas tardes',3,5);

retorna "enas".
- substring(cadena from posicion for longitud): variante de "substring(cadena,posicion,longitud)". Ejemplo:
select substring('Buenas tardes' from 3 for 5);
- mid(cadena,posicion,longitud): igual que "substring(cadena,posicion,longitud)". Ejemplo:
select mid('Buenas tardes' from 3 for 5);

retorna "enas".
- substring(cadena,posicion): retorna la subcadena de la cadena enviada como argumento, empezando

desde la posición indicada por el segundo argumento. Ejemplo:
select substring('Margarita',4);
retorna "garita".

-substring(cadena from posicion): variante de "substring(cadena,posicion)". Ejemplo:
select substring('Margarita' from 4);

retorna "garita".
-substring_index(cadena,delimitador,ocurrencia): retorna la subcadena de la cadena enviada como

argumento antes o después de la "ocurrencia" de la cadena enviada como delimitador. Si "ocurrencia" es
positiva, retorna la subcadena anterior al delimitador (comienza desde la izquierda); si "ocurrencia" es
negativa, retorna la subcadena posterior al delimitador (comienza desde la derecha). Ejemplo:
select substring_index( 'margarita','ar',2);

retorna "marg", todo lo anterior a la segunda ocurrencia de "ar".
select substring_index( 'margarita','ar',-2);

retorna "garita", todo lo posterior a la segunda ocurrencia de "ar".
-ltrim(cadena): retorna la cadena con los espacios de la izquierda eliminados. Ejemplo:
select ltrim(' Hola ');

retorna "Hola "
- rtrim(cadena): retorna la cadena con los espacios de la derecha eliminados. Ejemplo:
select rtrim(' Hola ');

retorna " Hola"
-trim([[both|leading|trailing] [subcadena] from] cadena): retorna una cadena igual a la enviada pero
eliminando la subcadena prefijo y/o sufijo. Si no se indica ningún especificador (both, leading o trailing) se
asume "both" (ambos). Si no se especifica prefijos o sufijos elimina los espacios. Ejemplos:
select trim(' Hola ');

retorna 'Hola'.
select trim (leading '0' from '00hola00');

retorna "hola00".
select trim (trailing '0' from '00hola00');

retorna "00hola".
select trim (both '0' from '00hola00');

retorna "hola".
select trim ('0' from '00hola00');

retorna "hola".

select trim (' hola ');
retorna "hola".
-replace(cadena,cadenareemplazo,cadenareemplazar): retorna la cadena con todas las ocurrencias de la

subcadena reemplazo por la subcadena a reemplazar. Ejemplo:
select replace('xxx.mysql.com','x','w');
retorna "www.mysql.com'.
-repeat(cadena,cantidad): devuelve una cadena consistente en la cadena repetida la cantidad de veces

especificada. Si "cantidad" es menor o igual a cero, retorna una cadena vacía. Ejemplo:
select repeat('hola',3);
retorna "holaholahola".
-reverse(cadena): devuelve la cadena invirtiendo el order de los caracteres. Ejemplo:
select reverse('Hola');
retorna "aloH".
-insert(cadena,posicion,longitud,nuevacadena): retorna la cadena con la nueva cadena colocándola en la

posición indicada por "posicion" y elimina la cantidad de caracteres indicados por "longitud". Ejemplo:
select insert('buenas tardes',2,6,'xx');

retorna ""bxxtardes".
-lcase(cadena) y lower(cadena): retornan la cadena con todos los caracteres en minúsculas. Ejemplo:
select lower('HOLA ESTUDIAnte');

retorna "hola estudiante".
select lcase('HOLA ESTUDIAnte');

retorna "hola estudiante".
-ucase(cadena) y upper(cadena): retornan la cadena con todos los caracteres en mayúsculas. Ejemplo:
select upper('HOLA ESTUDIAnte');

retorna "HOLA ESTUDIANTE".
select ucase('HOLA ESTUDIAnte');

retorna "HOLA ESTUDIANTE".
-strcmp(cadena1,cadena2): retorna 0 si las cadenas son iguales, -1 si la primera es menor que la segunda
y 1 si la primera es mayor que la segunda. Ejemplo:

select strcmp('Hola','Chau');
retorna 1.
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 maravillas','L. Carroll','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;

26 - Funciones matemáticas.
Los operadores aritméticos son "+","-","*" y "/". Todas las operaciones matemáticas retornan "null" en caso
de error. Ejemplo:
select 5/0;
MySQL tiene algunas funciones para trabajar con números. Aquí presentamos algunas.
RECUERDE que NO debe haber espacios entre un nombre de función y los paréntesis porque MySQL puede
confundir una llamada a una función con una referencia a una tabla o campo que tenga el mismo nombre de
una función.
-abs(x): retorna el valor absoluto del argumento "x". Ejemplo:
select abs(-20);
retorna 20.
-ceiling(x): redondea hacia arriba el argumento "x". Ejemplo:
select ceiling(12.34),
retorna 13.
-floor(x): redondea hacia abajo el argumento "x". Ejemplo:
select floor(12.34);
retorna 12.
-greatest(x,y,..): retorna el argumento de máximo valor.
-least(x,y,...): con dos o más argumentos, retorna el argumento más pequeño.
-mod(n,m): significa "módulo aritmético"; retorna el resto de "n" dividido en "m". Ejemplos:
select mod(10,3);
retorna 1.
select mod(10,2);
retorna 0.
- %: %: devuelve el resto de una división. Ejemplos:
select 10%3;
retorna 1.

select 10%2;
retorna 0.
-power(x,y): retorna el valor de "x" elevado a la "y" potencia. Ejemplo:
select power(2,3);
retorna 8.
-rand(): retorna un valor de coma flotante aleatorio dentro del rango 0 a 1.0.
-round(x): retorna el argumento "x" redondeado al entero más cercano. Ejemplos:
select round(12.34);
retorna 12.
select round(12.64);
retorna 13.
-srqt(): devuelve la raiz cuadrada del valor enviado como argumento.
-truncate(x,d): retorna el número "x", truncado a "d" decimales. Si "d" es 0, el resultado no tendrá parte
fraccionaria. Ejemplos:
select truncate(123.4567,2);
retorna 123.45;
select truncate (123.4567,0);

retorna 123.
Todas retornan null en caso de error.
Eliminamos la tabla 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) );
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 maravillas','L.
Carroll','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;
27 - Funciones para el uso de fecha y hora.

MySQL tiene algunas funciones para trabajar con fechas y horas. Estas son algunas:
-adddate(fecha, interval expresion): retorna la fecha agregándole el intervalo especificado. Ejemplos:

adddate('2006-10-10',interval 25 day) retorna "2006-11-04". adddate('2006-10-10',interval 5
month) retorna "2007-03-10".
-adddate(fecha, dias): retorna la fecha agregándole a fecha "dias". Ejemplo: adddate('2006-10-10',25),

retorna "2006-11-04".
-addtime(expresion1,expresion2): agrega expresion2 a expresion1 y retorna el resultado.
-current_date: retorna la fecha de hoy con formato "YYYY-MM-DD" o "YYYYMMDD".
-current_time: retorna la hora actual con formato "HH:MM:SS" o "HHMMSS".
-date_add(fecha,interval expresion tipo) y date_sub(fecha,interval expresion tipo): el argumento "fecha"

es un valor "date" o "datetime", "expresion" especifica el valor de intervalo a ser añadido o substraído de la
fecha indicada (puede empezar con "-", para intervalos negativos), "tipo" indica la medida de adición o
substracción. Ejemplo:
date_add('2006-08-10', interval 1 month)

retorna "2006-09-10";
date_add('2006-08-10', interval -1 day)
retorna "2006-09-09";

date_sub('2006-08-10 18:55:44', interval 2 minute)
retorna "2006-08-10 18:53:44";
date_sub('2006-08-10 18:55:44', interval '2:3' minute_second)
retorna "2006-08-10 18:52:41".
Los valores para "tipo" pueden ser: second, minute, hour, day, month, year, minute_second (minutos y
segundos), hour_minute (horas y minutos), day_hour (días y horas), year_month (año y mes), hour_second
(hora, minuto y segundo), day_minute (dias, horas y minutos), day_second(dias a segundos).
-datediff(fecha1,fecha2): retorna la cantidad de días entre fecha1 y fecha2.
-dayname(fecha): retorna el nombre del día de la semana de la fecha.

Ejemplo:
dayname('2006-08-10')
retorna "thursday".
-dayofmonth(fecha): retorna el día del mes para la fecha dada, dentro del rango 1 a 31.
Ejemplo:
dayofmonth('2006-08-10')
retorna 10.
-dayofweek(fecha): retorna el índice del día de semana para la fecha pasada como argumento. Los valores
de los índices son: 1=domingo, 2=lunes,... 7=sábado).
Ejemplo:
dayofweek('2006-08-10')
retorna 5, o sea jueves.
-dayofyear(fecha): retorna el día del año para la fecha dada, dentro del rango 1 a 366.
Ejemplo:
dayofmonth('2006-08-10')
retorna 222.
-extract(tipo from fecha): extrae partes de una fecha.
Ejemplos:
extract(year from '2006-10-10'), retorna "2006".

extract(year_month from '2006-10-10 10:15:25') retorna "200610".
extract(day_minute from '2006-10-10 10:15:25') retorna "101015";
Los valores para tipo pueden ser: second, minute, hour, day, month, year, minute_second, hour_minute,
day_hour, year_month, hour_second (horas, minutos y segundos), day_minute (días, horas y minutos),
day_second (días a segundos).
-hour(hora): retorna la hora para el dato dado, en el rango de 0 a 23.

Ejemplo:
hour('18:25:09')
retorna "18";
-minute(hora): retorna los minutos de la hora dada, en el rango de 0 a 59.
-monthname(fecha): retorna el nombre del mes de la fecha dada.
Ejemplo:
monthname('2006-08-10')
retorna "August".
-month(fecha): retorna el mes de la fecha dada, en el rango de 1 a 12.
-now() y sysdate(): retornan la fecha y hora actuales.
-period_add(p,n): agrega "n" meses al periodo "p", en el formato "YYMM" o "YYYYMM"; retorna un valor en el
formato "YYYYMM". El argumento "p" no es una fecha, sino un año y un mes.
Ejemplo:
period_add('200608',2)
retorna "200610".
-period_diff(p1,p2): retorna el número de meses entre los períodos "p1" y "p2", en el formato "YYMM" o
"YYYYMM". Los argumentos de período no son fechas sino un año y un mes.
Ejemplo:
period_diff('200608','200602')
retorna 6.
-second(hora): retorna los segundos para la hora dada, en el rango de 0 a 59.
-sec_to_time(segundos): retorna el argumento "segundos" convertido a horas, minutos y segundos.

Ejemplo:
sec_to_time(90)
retorna "1:30".
-timediff(hora1,hora2): retorna la cantidad de horas, minutos y segundos entre hora1 y hora2.
-time_to_sec(hora): retorna el argumento "hora" convertido en segundos.
-to_days(fecha): retorna el número de día (el número de día desde el año 0).
-weekday(fecha): retorna el índice del día de la semana para la fecha pasada como argumento. Los índices
son: 0=lunes, 1=martes,... 6=domingo).

Ejemplo:
weekday('2006-08-10')
retorna 3, o sea jueves.
-year(fecha): retorna el año de la fecha dada, en el rango de 1000 a 9999.

Ejemplo:
year('06-08-10')
retorna "2006".
Problema1: 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));

values ('El aleph','22543987','2006-08-15',date_add('2006-08-15', interval 5 day));
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));
Problema 2: Una empresa registra los datos de sus empleados en una tabla llamada "empleados".
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) );
insert into empleados (documento, nombre, sexo, domicilio, fechaIngreso, fechaNacimiento,

sueldoBasico) values ('22333111','Juan Perez','m','Colon 123','1990-02-01','1970-05-
10',550);
sueldoBasico) values ('25444444','Susana Morales','f','Avellaneda 345','1995-04-01','1975-11-
06',650);
sueldoBasico) values ('20111222','Hector Pereyra','m','Caseros 987','1995-04-01','1965-03-
25',510);
sueldoBasico) values ('30000222','Luis Luque','m','Urquiza 456','1980-09-01','1980-03-
29',700);
sueldoBasico) values ('20555444','Maria Laura Torres','f','San Martin 1122','2000-05-
15','1965-12-22',700);
sueldoBasico) values ('30000234','Alberto Soto','m','Peru 232','2003-08-15','1989-10-
10',420);
sueldoBasico) values ('20125478','Ana Gomez','f','Sarmiento 975','2004-06-14','1976-09-
21',350);

sueldoBasico) values ('24154269','Ofelia Garcia','f','Triunvirato 628','2004-09-23','1974-05-
12',390);
sueldoBasico) values ('306154269','Federico Gonzalez','m','Peru 390','1996-08-15','1985-05-
01',580);
4- Es política de la empresa festejar cada fin de mes, los cumpleaños de todos los empleados que
cumplen ese mes. Necesitamos los nombres y fecha de nacimiento de los empleados que cumplen años en el
mes de mayo:
select nombre,fechaNacimiento from empleados where month(fechaNacimiento)=5;
5- También es política de la empresa, aumentar el 1% del sueldo básico a los empleados, cada vez que
cumplen un año más de servicio. Necesitamos los nombres, fecha de ingreso a la empresa y sueldo básico de
todos los empleados que cumplen un año más de servicio en el mes de agosto, y una columna calculando el
incremento del sueldo:
select nombre,fechaIngreso,sueldoBasico, (sueldoBasico+sueldoBasico*0.01) as 'Sueldo

Incrementado' from empleados where month(fechaIngreso)=8;
6- Actualizamos el sueldo aumentando el 1% a los empleados que cumplen un año de servicio en el mes
de agosto:
select nombre,fechaIngreso,sueldoBasico, (sueldoBasico+sueldoBasico*0.01) as 'Sueldo

Incrementado' from empleados where month(fechaIngreso)=8;
7- Verifique si la actualización se realizó:
select nombre, sueldobasico from empleados where month(fechaIngreso)=8;
8- 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 agosto para encargar dichas placas:
select nombre,fechaIngreso, year(current_date)-year(fechaIngreso) as 'Años de servicio' from

empleados where month(fechaIngreso)=8;
En la sentencia anterior, extraemos el año de las fechas actual y de ingreso con la función "year
()" y las restamos, para calcular los años de servicio.

28 - Cláusula order by del select.
Podemos ordenar el resultado de un "select" para que los registros se muestren ordenados por algún
campo, para ello usamos la cláusula "order by".
Por ejemplo, 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. También podemos colocar el
número de orden del campo por el que queremos que se ordene en lugar de su nombre. Por ejemplo, queremos
el resultado del "select" ordenado por "precio":
select codigo,titulo,autor,editorial,precio from libros order by 5;
Por defecto, si no aclaramos en la sentencia, los ordena de manera ascendente (de menor a mayor).
Podemos ordenarlos de mayor a menor, para ello agregamos la palabra clave "desc":
select codigo,titulo,autor,editorial,precio from libros order by editorial desc;
También podemos ordenar por varios campos, por ejemplo, por "titulo" y "editorial":
select codigo,titulo,autor,editorial,precio from libros order by titulo, editorial;
Incluso, podemos ordenar en distintos sentidos, por ejemplo, por "titulo" en sentido ascendente y "editorial"
en sentido descendente:
select codigo,titulo,autor,editorial,precio from libros order by titulo asc, editorial desc;
Debe aclararse al lado de cada campo, pues estas palabras claves afectan al campo inmediatamente
anterior.
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('Matematica 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;
Problema 2: Trabaje con la tabla llamada "medicamentos" que almacena la información de los productos
que vende una farmacia.
create table medicamentos(codigo int unsigned auto_increment, nombre varchar(20), laboratorio

varchar(20), precio decimal(5,2), cantidad int unsigned, primary key(codigo));

insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Paracetamol 500','Bago',1.90,200);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Bayaspirina','Bayer',2.10,150);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal jarabe','Bayer',5.10,250);
5- Ordene los registros por precio, de mayor a menor.
6- Ordene los medicamentos por número del campo "cantidad".
7- Ordene los registros por "laboratorio" (descendente) y cantidad (ascendente).
29 - Operadores Lógicos (and - or - not)

Hasta el momento, hemos aprendido a establer una condición con "where" utilizando operadores
relacionales. Podemos establecer más de una condición con la cláusula "where", para ello aprenderemos los
operadores lógicos.
Son los siguientes:
- and, significa "y",

- or, significa "y/o",
- xor, significa "o",
- not, significa "no", invierte el resultado
- (), paréntesis
Los operadores lógicos se usan para combinar condiciones.
Queremos recuperar todos los registros cuyo autor sea igual a "Borges" y cuyo precio no supere los 20
pesos, para ello necesitamos 2 condiciones:
select * from libros where (autor='Borges') and (precio<=20);
Los registros recuperados en una sentencia que une 2 condiciones con el operador "and", cumplen con las 2
condiciones.
Queremos ver los libros cuyo autor sea "Borges" y/o cuya editorial sea "Planeta":
select * from libros where autor='Borges' or editorial='Planeta';
En la sentencia anterior usamos el operador "or", indicamos que recupere los libros en los cuales el valor del
campo "autor" sea "Borges" y/o el valor del campo "editorial" sea "Planeta", es decir, seleccionará los
registros que cumplan con la primera condición, con la segunda condición o con ambas condiciones.

Los registros recuperados con una sentencia que une 2 condiciones con el operador "or", cumplen 1 de las
condiciones o ambas.
Queremos ver los libros cuyo autor sea "Borges" o cuya editorial sea "Planeta":
select * from libros where (autor='Borges') xor (editorial='Planeta');
En la sentencia anterior usamos el operador "xor", indicamos que recupere los libros en los cuales el valor del
campo "autor" sea "Borges" o el valor del campo "editorial" sea "Planeta", es decir, seleccionará los registros
que cumplan con la primera condición o con la segunda condición pero no los que cumplan con ambas
condiciones. Los registros recuperados con una sentencia que une 2 condiciones con el operador "xor",
cumplen 1 de las condiciones, no ambas.
Queremos recuperar los libros que no cumplan la condición dada, por ejemplo, aquellos cuya editorial NO sea
"Planeta":
select * from libros where not (editorial='Planeta');
El operador "not" invierte el resultado de la condición a la cual antecede.
Los registros recuperados en una sentencia en la cual aparece el operador "not", no cumplen con la condición
a la cual afecta el "NO".
Los paréntesis se usan para encerrar condiciones, para que se evalúen como una sola expresión.
Cuando explicitamos varias condiciones con diferentes operadores lógicos (combinamos "and", "or") permite
establecer el orden de prioridad de la evaluación; además permite diferenciar las expresiones más
claramente.
Por ejemplo, las siguientes expresiones devuelven un resultado diferente:
select * from libros where (autor='Borges') or (editorial='Paidos' and precio<20);

select*from libros where (autor='Borges' or editorial='Paidos') and (precio<20);
Si bien los paréntesis no son obligatorios en todos los casos, se recomienda utilizarlos para evitar
confusiones.
El orden de prioridad de los operadores lógicos es el siguiente: "not" se aplica antes que "and" y "and" antes
que "or", si no se especifica un orden de evaluación mediante el uso de paréntesis.
El orden en el que se evalúan los operadores con igual nivel de precedencia es indefinido, por ello se
recomienda usar los paréntesis.

Eliminamos la tabla, si existe.
editorial varchar(15), precio decimal(5,2), primary key(codigo) );

insert into libros (titulo,autor,editorial,precio) values('Martin Fierro','Jose Hernandez','Emece',22.90);
insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Borges','Paidos',35.40);
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,
tipeamos:
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);
En el primer caso selecciona primero los libros de "Paidos" con precio<20 y también los de "Borges", sin
considerar el precio.
En 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".
Problema 2: Trabaje con la tabla llamada "medicamentos" de una farmacia.

varchar(20), precio decimal(5,2) unsigned, cantidad int unsigned, primary key(codigo) );

insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Paracetamol 500','Bago',1.90,200);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Bayaspirina','Bayer',2.10,150);
insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal jarabe','Bayer',5.10,250);
5- Recupere los códigos y nombres de los medicamentos cuyo laboratorio sea 'Roche' y cuyo precio sea
menor a 5:
select codigo,nombre from medicamentos where laboratorio='Roche' and precio<5;
Quedó seleccionado 1 registro, es el único que cumple con ambas condiciones.
6- Recupere los medicamentos cuyo laboratorio sea 'Roche' o cuyo precio sea menor a 5:
select * from medicamentos where laboratorio='Roche' or precio<5;

Note que la salida es diferente, hemos cambiado el operador de la sentencia anterior. Ahora se
recuperaron todos los registros cuyo laboratorio es igual a 'Roche' y todos los registros cuyo
precio es menor a 5. Aquellos registros que no cumplieron con la condición 1 (no son de "Roche") ni
con la condicion2 (no cuestan menos de 5) no aparecen.
7- Muestre todos los registros que no sean de "Bayer" usando el operador "not".
8- Muestre todos los medicamentos cuyo laboratorio NO sea "Bayer" y cuya cantidad sea=100:
select * from medicamentos where not laboratorio='Bayer' and cantidad=100;
9- Muestre todos los medicamentos cuyo laboratorio sea "Bayer" y cuya cantidad NO sea=100:
select * from medicamentos where laboratorio='Bayer' and not cantidad=100;
Analice estas 2 últimas sentencias. El operador "not" afecta a la condición a la cual antecede, no
a las siguientes. Los resultados de estas 2 sentencias son diferentes.
10- Elimine todos los registros cuyo laboratorio sea igual a "Bayer" y su precio sea mayor a 10:
delete from medicamentos where laboratorio='Bayer' and precio>10;
Sólo 1 registro debe ser eliminado, el que cumple con ambas condiciones.
11- Cambie la cantidad por 200, a todos los medicamentos de "Roche" cuyo precio sea mayor a 5:
update medicamentos set cantidad=200 where laboratorio='Roche' and precio>5;
Un solo registro fue actualizado porque sólo uno cumplió con las condiciones especificadas.
12- Borre los medicamentos cuyo laboratorio sea "Bayer" o cuyo precio sea menor a 3. Antes veamos
cuáles cumplen con la condición, los registros 5 y 6 son de "Bayer, cumplen con la primera condición, los
registros 4 y 5 cumplen con la segunda condición, es decir, se borrarán 3 registros:
el 4 porque cumple con la segunda condición, el 5 porque cumple con ambas y el 6 porque cumple con la
primera. Tipeamos:
delete from medicamentos where laboratorio='Bayer' or precio<3;
30 - Otros operadores relacionales (between - in)

Hemos visto los operadores relacionales:
= (igual), <> (distinto), > (mayor), < (menor), >= (mayor o igual), <= (menor o igual), is null/is not null (si un
valor es NULL o no).
Existen otros que simplifican algunas consultas:
Para recuperar de nuestra tabla "libros" los registros que tienen precio mayor o igual a 20 y menor o igual a
40, usamos 2 condiciones unidas por el operador lógico "and":
select * from libros where precio>=20 and precio<=40;
Podemos usar "between":
select * from libros where precio between 20 and 40;
"between" significa "entre". Averiguamos si el valor de un campo dado (precio) está entre los valores mínimo
y máximo especificados (20 y 40 respectivamente).
Si agregamos el operador "not" antes de "between" el resultado se invierte.
Para recuperar los libros cuyo autor sea 'Paenza' o 'Borges' usamos 2 condiciones:
select * from libros where autor='Borges' or autor='Paenza';
Podemos usar "in":
select * from libros where autor in('Borges','Paenza');
Con "in" averiguamos si el valor de un campo dado (autor) está incluido en la lista de valores especificada (en
este caso, 2 cadenas).
Para recuperar los libros cuyo autor no sea 'Paenza' ni 'Borges' usamos:
select * from libros where autor<>'Borges' and autor<>'Paenza';
También podemos usar "in" :
select * from libros where autor not in ('Borges','Paenza');
Con "in" averiguamos si el valor del campo está incluido en la lista, con "not" antecediendo la condición,
invertimos el resultado.

editorial varchar(15), precio decimal(5,2) unsigned, primary key(codigo) );

insert into libros (titulo,autor,editorial,precio) values('Cervantes y el quijote','Borges','Paidos',35.40);
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');

varchar(20), precio decimal(5,2) unsigned, cantidad int unsigned, primary key(codigo) );

insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100);

insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Paracetamol 500','Bago',1.90,200);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Bayaspirina','Bayer',2.10,150);
insert into medicamentos (nombre,laboratorio,precio,cantidad) values('Amoxidal jarabe','Bayer',5.10,250);
5- Recupere los nombres y precios de los medicamentos cuyo precio esté entre 5 y 15:
select nombre,precio from medicamentos where precio between 5 and 15;
6- Seleccione los registros cuyo laboratorio sea "Bayer" o "Bago":
select * from medicamentos where laboratorio in ('Bayer','Bago');
7- Elimine los registros cuya cantidad esté entre 100 y 200:
delete from medicamentos where cantidad between 100 and 200;
31 - Búsqueda de patrones (like y not like)

Hemos realizado consultas utilizando operadores relacionales para comparar cadenas. Por ejemplo,
sabemos recuperar los libros cuyo autor sea igual a la cadena "Borges":
select * from libros where autor='Borges';
Los operadores relacionales nos permiten comparar valores numéricos y cadenas de caracteres. Pero al
realizar la comparación de cadenas, busca coincidencias de cadenas completas.
Imaginemos que tenemos registrados estos 2 libros:
El Aleph de Borges;
Antologia poetica de J.L. Borges;
Si queremos recuperar todos los libros cuyo autor sea "Borges", y especificamos la siguiente condición:
sólo aparecerá el primer registro, ya que la cadena "Borges" no es igual a la cadena "J.L. Borges".
Esto sucede porque el operador "=" (igual), también el operador "<>" (distinto) comparan cadenas de
caracteres completas. Para comparar porciones de cadenas utilizamos los operadores "like" y "not like".

Entonces, podemos comparar trozos de cadenas de caracteres para realizar consultas. Para recuperar
todos los registros cuyo autor contenga la cadena "Borges" debemos tipear:
select * from libros where autor like "%Borges%";
El símbolo "%" (porcentaje) reemplaza cualquier cantidad de caracteres (incluyendo ningún caracter). Es un
caracter comodín. "like" y "not like" son operadores de comparación que señalan igualdad o diferencia.
Para seleccionar todos los libros que comiencen con "A":
select * from libros where titulo like 'A%';
Note que el símbolo "%" ya no está al comienzo, con esto indicamos que el título debe tener como primera
letra la "A" y luego, cualquier cantidad de caracteres.
Para seleccionar todos los libros que no comiencen con "A":
select * from libros where titulo not like 'A%';
Así como "%" reemplaza cualquier cantidad de caracteres, el guión bajo "_" reemplaza un caracter, es el otro
caracter comodín. Por ejemplo, queremos ver los libros de "Lewis Carroll" pero no recordamos si se escribe
"Carroll" o "Carrolt", entonces tipeamos esta condición:
select * from libros where autor like "%Carrol_";
Si necesitamos buscar un patrón en el que aparezcan los caracteres comodines, por ejemplo, queremos ver
todos los registros que comiencen con un guión bajo, si utilizamos '_%', mostrará todos los registros porque
lo interpreta como "patrón que comienza con un caracter cualquiera y sigue con cualquier cantidad de
caracteres".
Debemos utilizar "\_%", esto se interpreta como 'patrón que comienza con guión bajo y continúa con
cualquier cantidad de caracteres".
Es decir, si queremos incluir en una búsqueda de patrones los caracteres comodines, debemos anteponer
al caracter comodín, la barra invertida "\", así lo tomará como caracter de búsqueda literal y no como
comodín para la búsqueda. Para buscar el caracter literal "%" se debe colocar "\%".
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":
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 tipeamos:
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%';
create table medicamentos(codigo int unsigned auto_increment, nombre varchar(20) not null,
laboratorio varchar(20), precio decimal(6,2) unsigned, cantidad int unsigned, primary key(codigo));
insert into medicamentos (nombre, laboratorio,precio) values('Sertal gotas','Roche',5.2);

insert into medicamentos (nombre, laboratorio,precio) values('Buscapina','Roche',4.10);
insert into medicamentos (nombre, laboratorio,precio) values('Amoxidal 500','Bayer',15.60);
insert into medicamentos (nombre, laboratorio,precio) values('Paracetamol 500','Bago',1.90);
insert into medicamentos (nombre, laboratorio,precio) values('Bayaspirina','Bayer',2.10);
insert into medicamentos (nombre, laboratorio,precio) values('Amoxidal jarabe','Bayer',5.10);
insert into medicamentos (nombre, laboratorio,precio) values('Sertal compuesto','Bayer',5.10);
insert into medicamentos (nombre, laboratorio,precio) values('Paracetamol 1000','Bago',2.90);
insert into medicamentos (nombre, laboratorio,precio) values('Amoxinil','Roche',17.80);
5- Recupere los medicamentos cuyo nombre comiencen con "Amox":
select codigo,nombre,laboratorio,precio from medicamentos where nombre like 'Amox%';
Quedaron 3 registros seleccionados.
6- Recupere los medicamentos "Paracetamol" cuyo precio sea menor a 2:
select codigo,nombre,laboratorio,precio from medicamentos where nombre like 'Paracetamol%' and

precio<2;
7- Busque todos los medicamentos cuyo precio tenga .10 centavos:
select codigo,nombre,laboratorio,precio from medicamentos where precio like '%.1%';
8- Muestre todos los medicamentos que no contengan la cadena "compuesto":
select codigo,nombre,laboratorio,precio from medicamentos where nombre not like'%compuesto%';

9- Elimine todos los registros cuyo laboratorio contenga la letra "y":
delete from medicamentos where laboratorio like '%y%';
10- Cambie el precio por 5, al "Paracetamol" cuyo precio es mayor a 2:
update medicamentos set precio=5 where nombre like 'Paracetamol%' and precio>2;
32 - Búsqueda de patrones (regexp)

Los operadores "regexp" y "not regexp" busca patrones de modo similar a "like" y "not like".
Para buscar libros que contengan la cadena "Ma" usamos:
select titulo from libros where titulo regexp 'Ma';
Para buscar los autores que tienen al menos una "h" o una "k" o una "w" tipeamos:
select autor from libros where autor regexp '[hkw]';
Para buscar los autores que no tienen ni "h" o una "k" o una "w" tipeamos:
select autor from libros where autor not regexp '[hkw]';
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" tipeamos:
select titulo from libros where titulo regexp '^A';
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';
El punto (.) identifica cualquier caracter.

Manual de MySQL

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de MySQL

Cargado por

Copyright:

Formatos disponibles

CARRERA: Técnico en OFIMÁTICA

Diseña y gestiona bases de datos ofimáticas

Submódulo 1 - Diseña bases de datos ofimáticas

Submódulo 2 - Gestiona información mediante el uso de sistemas manejadores

Manual Básico de MySQL - Ejercicios Guiados Parte I -1-

MySQL es un interpretador de SQL, es un servidor de base de datos.

create database administracion;

Pero Linux interpretará como un error la segunda.

Se recomienda usar siempre minúsculas.

“Diseña y gestiona bases de datos ofimáticas” -8-

Manual Básico de MySQL - Ejercicios Guiados Parte I -9-

Nos mostrará los nombres de las bases de datos.

3 - Creación de una tabla y mostrar sus campos

Una base de datos almacena sus datos en tablas.

Cada registro contiene un dato por cada columna de la tabla.

Las tablas forman parte de una base de datos.

“Diseña y gestiona bases de datos ofimáticas” - 10 -

Para ver las tablas existentes en una base de datos tipeamos:

Creamos una tabla llamada "usuarios", tipeamos:

create table usuarios (

Ahora aparece "usuarios" entre otras que ya pueden estar creadas.

Manual Básico de MySQL - Ejercicios Guiados Parte I - 11 -

Field Type Null

Para eliminar una tabla usamos "drop table". Tipeamos:

drop table usuarios;

drop table usuarios;

Para evitar este mensaje podemos tipear:

drop table if exists usuarios;

En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.

drop table if exists usuarios;

create table usuarios (

“Diseña y gestiona bases de datos ofimáticas” - 12 -

A) Queremos almacenar los datos de nuestros amigos.

1- Elimine la tabla "agenda" si existe:

drop table if exists agenda;

create table agenda(

3- Intente crearla nuevamente. Aparece mensaje de error.

4- Visualice las tablas existentes (show tables).

5- Visualice la estructura de la tabla "agenda" (describe agenda).

6- Elimine la tabla, si existe (drop table, if exists).

7- Intente eliminar la tabla sin la cláusula if exists (drop table agenda).

Problema 3: Queremos almacenar información referente a nuestros libros.

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

2- Cree una tabla llamada "libros".

Debe definirse con los siguientes campos:

3- Intente crearla nuevamente. Aparece mensaje de error.

Manual Básico de MySQL - Ejercicios Guiados Parte I - 13 -

5- Visualice la estructura de la tabla "libros".

6- Elimine la tabla, si existe.

7- Intente eliminar la tabla

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

Recordemos como crear la tabla "usuarios":

create table usuarios (

Ahora vamos a agregar un registro a la tabla:

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

La tabla usuarios ahora la podemos graficar de la siguiente forma:

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

select nombre,clave from usuarios;

“Diseña y gestiona bases de datos ofimáticas” - 14 -

drop table if exists usuarios;

create table usuarios (

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

Para ver los registros ejecutamos el comando select:

select nombre,clave from usuarios;