Mysql

3 - Creacin 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 interseccin de una
columna con una fila, contiene un dato especfico, 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
informacin que almacenar.
Cada campo (columna) tambin debe definir el tipo de dato que almacenar.
nombre
clave
MarioPerez
Marito
MariaGarcia
Mary
DiegoRodriguez
z8080
Grficamente 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.
Nosotros trabajaremos con la base de datos llamada "administracion", que ya hemos
creado en el servidor mysqlya.com.ar.
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 mysqlya.com.ar
Al crear una tabla debemos resolver qu campos (columnas) tendr y que tipo de datos
almacenarn 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 accin 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;
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 aceptacin de valores nulos etc, que veremos ms
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.
4 - Carga de registros a una tabla y su

recuperacin (insert into - select)
Problema: 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:

select nombre,clave from usuarios;
(Aclaracin: Generalmente borraremos la tabla y luego la crearemos por si otro usuario

del sitio mysqlya.com.ar a modificado la tabla, para comprobar que no es necesario
siempre hacer drop y create puede borrar esas dos instrucciones y luego ejecutar
sucesivamente varios insert y ver como se van agregando los registros a la tabla. Tener
en cuenta que cuando hacemos drop se borra la tabla por completo, su estructura y los
registros cargados hasta el momento)

nombre varchar(30),
clave varchar(10)
);
insert into usuarios(nombre,clave) values ('MarioPerez','Marito');
insert into usuarios(nombre,clave) values ('MariaGarcia','Mary');

insert into usuarios(nombre,clave) values ('DiegoRodriguez','z8080');
5 - Tpos de datos bsicos 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 bsicos:
- 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 mximo 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'
ajustndose a la longitud de 10 caracteres.
- integer: se usa para guardar valores numricos enteros, de -2000000000 a 2000000000
aprox. Definimos campos de este tipo cuando queremos representar, por ejemplo,
cantidades.
- float: se usa para almacenar valores numricos 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 nmeros
enteros, el tipo "float" sera una mala eleccin; si vamos a guardar precios, el tipo
"float" es correcto, no as "integer" que no tiene decimales.
drop table if exists libros;
create table libros (

codigo integer,
titulo varchar (20),
autor varchar (30),

precio float
);
insert into libros(codigo,titulo,autor,precio) values (1,'MySQL a

fondo','Rodriguez Pablo',70.52);
insert into libros(codigo,titulo,autor,precio) values (2,'PHP 5','Rios Juan',20);
insert into libros(codigo,titulo,autor,precio) values (3,'JSP 1.1','Rosales
Ana',27.75);
select * from libros;
6 - Recuperacin de algunos campos

(select)
Hemos aprendido cmo 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 separndolos por
comas:
select titulo,autor,editorial from libros;
En la sentencia anterior la consulta mostrar slo los campos "titulo", "autor" y

"editorial". En la siguiente sentencia, veremos los campos correspondientes al ttulo 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;
create table libros(

titulo varchar(20),
autor varchar(30),
editorial varchar(15),
precio float,
cantidad integer
);
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);
select titulo,autor,editorial from libros;
select titulo,precio from libros;
select editorial,cantidad from libros;
7 - Recuperacin de registros
especficos (select - where)
Hemos aprendido cmo 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 clusula, "where" que es opcional, con ella podemos especificar condiciones
para la consulta "select". Es decir, podemos recuperar algunos registros, slo los que
cumplan con ciertas condiciones indicadas con la clusula "where". Por ejemplo,
queremos ver el usuario cuyo nombre es "MarioPerez", para ello utilizamos "where" y
luego de ella, la condicin:
select nombre, clave from usuarios where nombre='MarioPerez';
Para las condiciones se utilizan operadores relacionales (tema que trataremos ms

adelante en detalle). El signo igual(=) es un operador relacional. Para la siguiente
seleccin de registros especificamos una condicin que solicita los usuarios cuya clave
es igual a 'bocajunior':
select nombre, clave from usuarios where clave='bocajunior';
Si ningn registro cumple la condicin establecida con el "where", no aparecer ningn

registro.

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

insert into usuarios (nombre, clave) values ('MarioPerez','Marito');
insert into usuarios (nombre, clave) values ('Marcelo','bocajunior');
insert into usuarios (nombre, clave) values ('Gustavo','bocajunior');
select nombre, clave from usuarios;
select nombre, clave from usuarios where nombre='Leonardo';
select nombre, clave from usuarios where clave='bocajunior';
select nombre, clave from usuarios where clave='river';
8 - Operadores Relacionales = <> < <=

> >=
Problema:
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 numricos (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 numricos (en este caso de tipo float) no se utilizan
comillas.

titulo varchar(20),
autor varchar(30),
precio float
);
insert into libros (titulo,autor,editorial,precio) values ('El

aleph','Borges','Planeta',12.50);
insert into libros (titulo,autor,editorial,precio) values ('Martin Fierro','Jose
Hernandez','Emece',16.00);
insert into libros (titulo,autor,editorial,precio) values ('Aprenda PHP','Mario
Molina','Emece',35.40);
('Cervantes','Borges','Paidos',50.90);
select titulo, autor,editorial,precio from libros;
select titulo, autor,editorial,precio from libros where autor<>'Borges';
select titulo, autor,editorial,precio from libros where precio>20;
select titulo,autor,editorial,precio from libros where precio<=30;
9 - Borrado de registros de una tabla (delete)

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

insert into usuarios (nombre, clave) values ('Marcelo','River');
insert into usuarios (nombre, clave) values ('Gustavo','River');
delete from usuarios where nombre='Leonardo';
delete from usuarios where clave='River';
delete from usuarios;
10 - Modificacin de registros de una

tabla (update)
Problema:
Trabajamos con la tabla "usuarios" que guarda el nombre de usuario y su clave.
Eliminamos la tabla, si existe:
drop table if exists
usuarios;
Creamos la tabla:
nombre varchar(30),
clave varchar(10)
);
Ingresamos algunos registros:

insert
insert
insert
insert
into
into
into
into
usuarios
usuarios
usuarios
usuarios
(nombre,
(nombre,
(nombre,
(nombre,
clave)
clave)
clave)
clave)
values
values
values
values
('Leonardo','payaso');
('MarioPerez','Marito');
('Marcelo','River');
('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 actualizacin:

Cambiamos el valor correspondiente a la clave de nuestro usuario llamado 'MarioPerez',

por 'Boca':
update usuarios set clave='Boca'
where nombre='MarioPerez';
Verificamos el cambio:
Cambiamos el valor correspondiente al nombre de usuario 'Gustavo' por

'GustavoGarcia':
update usuarios set nombre='GustavoGarcia'
where nombre='Gustavo';
Podemos actualizar varios campos en una sola instruccin:

update usuarios set nombre='MarceloDuarte', clave='Marce'
where nombre='Marcelo';

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

update usuarios set clave='RealMadrid';
update usuarios set nombre='GustavoGarcia'

where nombre='Gustavo';
update usuarios set nombre='MarceloDuarte', clave='Marce'

where nombre='Marcelo';
11 - Clave primaria.
Problema:
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)
);
Vemos la estructura de la tabla:
describe usuarios;
Note que en la columna "KEY" del campo "nombre" aparece "PRI", esto significa que
ese campo es clave primaria.
insert
insert
insert
insert
into
into
into
into
usuarios
usuarios
usuarios
usuarios
(nombre,
(nombre,
(nombre,
(nombre,
clave)
clave)
clave)
clave)
values
values
values
values
('Leonardo','payaso');
('MarioPerez','Marito');
('Marcelo','River');
('Gustavo','River');
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; vemoslo en un
ejemplo, ingresemos un registro con un nombre de usuario repetido:
insert into usuarios (nombre, clave)
values ('Gustavo','Boca');

nombre varchar(20),
clave varchar(10),
primary key (nombre)
);
describe usuarios;

insert into usuarios (nombre, clave) values ('Gustavo','Boca');
12 - Campo entero con autoincremento.
Problema:
Trabajamos con la tabla "libros" de una librera.
Creamos la tabla estableciendo como clave primaria y "auto_increment" el campo

"codigo":
codigo integer auto_increment,
titulo varchar(20),
autor varchar(30),
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 automticamente. 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 cdigo, comenz la secuencia en 1.
Ingresamos ms registros:
values('Martin Fierro','Jose Hernandez','Emece');
values('Aprenda PHP','Mario Molina','Emece');
values('Cervantes y el quijote','Borges','Paidos');
values('Matematica estas ahi', 'Paenza', 'Paidos');
Seleccionamos todos los registros:

select codigo,titulo,autor,editorial from libros;
Vemos que el cdigo, dato que no ingresamos, se carg automticamente 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 insercin 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:
values(2,'Martin Fierro','Jose Hernandez','Planeta');
Si ingresamos un valor que no sigue la secuencia, el dato es vlido, lo toma, por

ejemplo:
values(15,'Harry Potter y la piedra filosofal','J.K.
Rowling','Emece');
El siguiente registro insertado tomar el valor ms alto para seguir la secuencia (en este
caso 16):
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):
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 slo valores
positivos), lo ingresa:
values(-5,'Alicia a traves del espejo','Lewis Carroll','Planeta');

titulo varchar(20),
autor varchar(30),
);
describe libros;

values('El aleph','Borges','Planeta');
select * from libros libros;

values('Martin Fierro','Jose Hernandez','Emece');
select codigo,titulo,autor,editorial from libros;

values(6,'Martin Fierro','Jose Hernandez','Paidos');

values(2,'Martin Fierro','Jose Hernandez','Planeta');
values(15,'Harry Potter y la piedra filosofal','J.K. Rowling','Emece');

values('Harry Potter y la camara secreta','J.K. Rowling','Emece');

values(0,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta');

values(-5,'Alicia a traves del espejo','Lewis Carroll','Planeta');
13 - Comando truncate table.

Problema:
Creamos la tabla:
titulo varchar(20),
autor varchar(30),
);

values('Martin Fierro','Jose Hernandez','Planeta');

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:
values('Antologa poetica', 'Borges', 'Emece');
Veamos el resultado:
Para el campo "codigo" se guard el valor 6 porque el valor ms 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 cdigo:

Vemos que la secuencia de "codigo" empez en 1 nuevamente.

Ejecutamos entonces:

titulo varchar(20),
autor varchar(30),

);

values('Martin Fierro','Jose Hernandez','Planeta');
values('El aleph', 'Borges', 'Emece');
delete from libros;

truncate table libros;

14 - Valores null.
Problema:
Creamos la tabla estableciendo con la siguiente estructura:

titulo varchar(20) not null,
autor varchar(30),
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 dems 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 situacin:
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":
values ('Harry Potter y la piedra filosofal', 'J.K.
Rowling',null,30.00);
Ingresemos otros valores que nos servirn luego para verificar que los valores "null" son
diferentes de 0 y de cadenas vacas.
values ('Matematica estas ahi','Paenza','Paidos',0);
values ('Martin Fierro','Jose Hernandez','',22.50);
Explicamos que "null" no es lo mismo que una cadena vaca 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:

where precio=0;
Verifiquemos que las siguientes sentencias no retornan el mismo resultado:

select
where
select
where
* from libros
editorial is null;
*from libros
editorial='';
Con la primera sentencia recuperamos los libros cuya editorial es "null"; con la segunda,
los libros cuya editorial guarda una cadena vaca.

autor varchar(30),
precio float,
primary key(codigo)
);

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

values ('Matematica estas ahi','Paenza','Paidos',0);
values ('Martin Fierro','Jose Hernandez','',22.50);

values ('Harry Potter y la piedra filosofal', 'J.K. Rowling',null,30.00);

where precio is null;

where precio=0;
where editorial is null;
select *from libros
where editorial='';
15 - Valores numricos sin signo

(unsigned)
Problema:
Trabaje con la tabla "libros" de una librera.
Elimine la tabla, si existe:
Cree la tabla con la siguiente estructura:

codigo integer unsigned auto_increment,
autor varchar(30),
precio float unsigned,
cantidad integer unsigned,
);
Al definir los campos especificamos si un campo numrico es "unsigned".

El atributo "unsigned" (sin signo) slo puede agregarse a un campo de tipo numrico
(enteros o comas flotantes) permitiendo para dicho campo slo 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 cdigo 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 jams 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.

codigo integer unsigned auto_increment,
autor varchar(30),
precio float unsigned,
cantidad integer unsigned,

);
describe libros;
17 - Tipos de datos (texto)

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.
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 definicin ocupamos un byte.
drop table if exists visitantes;
create table visitantes(

nombre varchar(30),
edad integer unsigned,
sexo char(1),
domicilio varchar(30),
ciudad varchar(20),
telefono varchar(11),
montocompra float unsigned
);
describe visitantes;
18 - Tipos de datos (numricos)

Problema:
Creamos la tabla con la siguiente estructura:

codigo int unsigned auto_increment,
autor varchar(30),
precio decimal(5,2) unsigned,
cantidad smallint unsigned,
);
Note que definimos el campo "cantidad" de tipo "smallint unsigned", esto es porque los
valores para este campo sern siempre positivos (mayores o iguales a 0), adems 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 ms 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
tenamos antes con el tipo "float".

autor varchar(30),

cantidad smallint unsigned,
);
describe libros;
19 - Tipos de datos (fechas y horas)

Problema:
Una playa de estacionamiento guarda cada da los datos de los vehculos 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 definicin
ocupamos 6 bytes, si lo hubisemos definido como "varchar(6)" ocupara 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 vehculo 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');
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 vehculo 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:

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".
drop table if exists vehiculos;
create table vehiculos(

patente char(6) not null,
tipo char (4),
horallegada time not null,
horasalida time
);
insert into vehiculos (patente,tipo,horallegada) values

('ACD123','auto','8:30');
values('BGF234','moto','8:35');
values('KIU467','auto','9:40');
update vehiculos set horasalida='11:45'

where patente='ACD123';
insert into vehiculos values('LIO987','auto','10',null);
insert into vehiculos values('GTR987','auto','1010',null);
insert into vehiculos values('HTR234','auto','2006-12-15 12:15',null);
insert into vehiculos values('KUY246','auto','12/15',null);
20 - Valores por defecto.

Problema:

autor varchar(30),
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 numricos que no admiten valores nulos.
Ingresamos otro registro con algunos valores explcitos:
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 vaca 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.
autor varchar(30),
cantidad mediumint unsigned not null,
primary key(codigo)
);
insert into libros (titulo,autor,precio)
values('El aleph','Borges',23.6);
63 - Clave fornea.
Problema:
Trabajamos con las tablas "libros" y "editoriales" de una librera.
Eliminamos las tablas, si existen:

drop table libros, editoriales;
Creamos las tablas:

autor varchar(30) not null default 'Desconocido',
codigoeditorial tinyint unsigned not null,
cantidad smallint unsigned default 0,
);
create table editoriales(
codigo tinyint unsigned auto_increment,
nombre varchar(20) not null,
primary key(codigo)
);
En este ejemplo, el campo "codigoeditorial" de "libros" es una clave fornea, se emplea

para enlazar la tabla "libros" con "editoriales".
insert into editoriales values(2,'Emece');
insert into editoriales values(15,'Planeta');
insert into editoriales values(23,'Paidos');
insert into libros values(1,'El aleph','Borges',23,4.55,10);
insert into libros values(2,'Alicia en el pais de las
maravillas','Lewis Carroll'
,2,11.55,2);
insert into libros values(3,'Martin Fierro','Jose
Hernandez',15,7.12,4);
Si modificamos el tipo, longitud o atributos de una clave fornea, sta puede quedar
inhabilitada para hacer los enlaces.
Veamos un ejemplo:
alter table libros
modify codigoeditorial char(1);
Veamos cmo afect el cambio a la tabla "libros":

El libro con cdigo de editorial "23" ("Paidos") ahora tiene "2" ("Emece") en
"codigoeditorial" y el libro con cdigo de editorial "15" ("Planeta") ahora almacena "1"
(valor inexistente en "editoriales").
Si buscamos coincidencia de cdigos en la tabla "editoriales":
select l.titulo,e.nombre
from libros as l
join editoriales as e
on l.codigoeditorial=e.codigo;
El resultado es errneo.
Las claves forneas y las claves primarias deben ser del mismo tipo para poder
enlazarse. Si modificamos una, debemos modificar la otra para que los valores se
correspondan.
Intentemos modificar la clave en "editoriales":
alter table editoriales
modify codigo char(1);
No lo permite porque si la modifica los valores para el campo clave quedan repetidos.
drop table libros, editoriales;

autor varchar(30) not null default 'Desconocido',
codigoeditorial tinyint unsigned not null,
cantidad smallint unsigned default 0,
);
create table editoriales(

codigo tinyint unsigned auto_increment,
nombre varchar(20) not null,
primary key(codigo)
);
insert into editoriales values(2,'Emece');

insert into editoriales values(15,'Planeta');
insert into editoriales values(23,'Paidos');
insert into libros values(1,'El aleph','Borges',23,4.55,10);

insert into libros values(2,'Alicia en el pais de las maravillas','Lewis
Carroll',2,11.55,2);
insert into libros values(3,'Martin Fierro','Jose Hernandez',15,7.12,4);
alter table libros

modify codigoeditorial char(1);
select l.titulo,e.nombre
from libros as l
join editoriales as e
on l.codigoeditorial=e.codigo;
alter table editoriales

modify codigo char(1);

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

Mysql

Cargado por

Copyright:

Formatos disponibles

3 - Creacin de una tabla y mostrar sus

campos (create table - show tables describe - drop table)

Grficamente ac tenemos la tabla usuarios, que contiene dos campos llamados:nombre

Creamos una tabla llamada "usuarios", tipeamos:

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

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

4 - Carga de registros a una tabla y su

create table usuarios (

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

Para ver los registros ejecutamos el comando select:

(Aclaracin: Generalmente borraremos la tabla y luego la crearemos por si otro usuario

create table usuarios (

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

insert into usuarios(nombre,clave) values ('MariaGarcia','Mary');

select nombre,clave from usuarios;

5 - Tpos de datos bsicos de un campo

create table libros (

autor varchar (30),

insert into libros(codigo,titulo,autor,precio) values (1,'MySQL a

select * from libros;

6 - Recuperacin de algunos campos

En la sentencia anterior la consulta mostrar slo los campos "titulo", "autor" y

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

drop table if exists libros;

create table libros(

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

select * from libros;

select titulo,autor,editorial from libros;

select titulo,precio from libros;

select editorial,cantidad from libros;

Para las condiciones se utilizan operadores relacionales (tema que trataremos ms

Si ningn registro cumple la condicin establecida con el "where", no aparecer ningn

create table usuarios (

insert into usuarios (nombre, clave) values ('Leonardo','payaso');

select nombre, clave from usuarios;

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

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

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

8 - Operadores Relacionales = <> < <=

La creamos con la siguiente estructura:

Por primera vez definimos un campo de tipo float.

Seleccionamos los registros cuyo autor sea diferente de 'Borges':

Seleccionamos los registros cuyo precio supere los 20 pesos:

Seleccionamos los libros cuyo precio es menor o igual a 30:

select titulo,autor,editorial,precio from libros where precio<=30;

create table libros(

insert into libros (titulo,autor,editorial,precio) values ('El

select titulo, autor,editorial,precio from libros;

select titulo, autor,editorial,precio from libros where autor<>'Borges';

select titulo, autor,editorial,precio from libros where precio>20;

select titulo,autor,editorial,precio from libros where precio<=30;

9 - Borrado de registros de una tabla (delete)

create table usuarios (

insert into usuarios (nombre, clave) values ('Leonardo','payaso');

delete from usuarios where nombre='Leonardo';

select nombre,clave from usuarios;

delete from usuarios where clave='River';

select nombre,clave from usuarios;

delete from usuarios;

select nombre,clave from usuarios;

10 - Modificacin de registros de una

Ingresamos algunos registros:

Visualizamos todos los registros:

Visualizamos todos los registros para verificar la actualizacin: