Professional Documents
Culture Documents
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.
Para que el servidor nos muestre las bases de datos existentes, se lo solicitamos
enviando la instrucción:
Nos mostrará los nombres de las bases de datos, debe aparecer en este sitio
"administracion".
EJERCICIO RESUELTO:
CLASE # 3 - Creación de una tabla y mostrar sus campos (create table - show
tables - describe - drop table)
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 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
Marit
MarioPerez
o
MariaGarcia Mary
DiegoRodrigue
z8080
z
show tables;
Deben aparecer todas las tablas que han creado los visitantes al sitio local
http://localhost
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.
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;
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:
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:
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.
Si tipeamos nuevamente:
Aparece un mensaje de error, indicando que no existe, ya que intentamos borrar una
tabla inexistente.
EJERCICIO PROPUESTO:
Problema:
A) Queremos almacenar los datos de nuestros amigos.
1- Elimine la tabla "agenda" si existe:
drop table if exists agenda;
Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada
registro tiene un dato por cada columna.
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de
los campos.
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.
nombre clave
MarioPere Marit
z o
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.
El comando "select" recupera los registros de una tabla. Luego del comando select
indicamos los nombres de los campos a rescatar.
EJERCICIO RESUELTO:
Problema: Insertar tres registros en la tabla usuarios y luego mostrar todos los
registros de la tabla.
Creamos la tabla:
create table usuarios (
nombre varchar(30),
clave varchar(10)
);
Insertamos 3 registros:
insert into usuarios(nombre,clave) values ('MarioPerez','Marito');
insert into usuarios(nombre,clave) values ('MariaGarcia','Mary');
insert into usuarios(nombre,clave) values
('DiegoRodriguez','z8080');
Para ver los registros ejecutamos el comando select:
select nombre,clave from usuarios;
2- Cree una tabla llamada "agenda". Debe tener los siguientes campos:
nombre varchar(20),
domicilio varchar(30),
telefono varchar(11)
);
(show tables).
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.
- float: se usa para almacenar valores numéricos decimales. Se utiliza como separador
el punto (.). Definimos campos de este tipo para precios, por ejemplo.
EJERCICIO RESUELTO:
Problema:
Para almacenar información de los libros de una librería necesitamos los siguientes
campos:
Al crear la tabla, entonces, elegimos el tipo de dato más adecuado para cada campo:
describe libros;
Es una forma resumida de indicar que seleccione todos los campos de la tabla.
CODIGO FUENTE:
EJERCICIO PROPUESTO:
Problema:
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.
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:
Problema:
Trabajamos con la tabla "libros" que almacena los datos de los libros de una librería.
describe libros;
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:
EJERCICIO PROPUESTO:
Problema:
2- Cree la tabla:
describe peliculas;
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:
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 'bocajunior':
EJERCICIO RESUELTO:
Problema:
Creamos la tabla:
describe usuarios;
Realizamos una consulta especificando una condición, queremos ver el usuario cuyo
nombre es "Leonardo":
EJERCICIO PROPUESTO:
Problema:
Trabajamos con nuestra tabla "agenda".
1- Eliminamos "agenda", si existe:
drop table if exists agenda;
Otros problemas:
A) Trabaje con la tabla "libros".
1- Elimine la tabla si existe. (drop table- if exists),
Los operadores relacionales vinculan un campo con un valor para que MySQL
compare cada registro (el campo especificado) con el valor dado.
Podemos seleccionar los registros cuyo autor sea diferente de 'Borges', para ello
usamos la condición:
Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los libros
cuyos precios sean mayores a 20 pesos:
EJERCICIO RESUELTO:
Problema:
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(.).
Note que al comparar valores numéricos (en este caso de tipo float) no se utilizan
comillas.
EJERCICIO PROPUESTO:
Problema:
Un comercio que vende artículos de computación registra los datos de
sus artículos
en una tabla con ese nombre.
La ejecución del comando indicado en la línea anterior borra TODOS los registros de
la tabla.
EJERCICIO RESUELTO:
Problema:
Creamos la tabla:
EJERCICIO PROPUESTO:
Problema:
Trabaje con la tabla "agenda" que registra la información referente
a sus amigos.
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":
Si no encuentra registros que cumplan con la condición del "where", ningún registro
es afectado.
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:
Creamos la tabla:
Para actualizar los valores de todas las claves, por 'RealMadrid' tipeamos:
Verificamos el cambio:
EJERCICIO PROPUESTO:
Problema:
Trabaje con la tabla "agenda" que almacena los datos de sus amigos.
2- Cree la tabla:
create table agenda(
apellido varchar(30),
nombre varchar(20),
domicilio varchar(30),
telefono varchar(11)
);
Otros problemas:
A) Trabaje con la tabla "libros" de una librería.
1- Elimine la tabla.
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.
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.
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.
EJERCICIO RESUELTO:
Problema:
Creamos la tabla:
describe usuarios;
Note que en la columna "KEY" del campo "nombre" aparece "PRI", esto significa
que ese campo es clave primaria.
EJERCICIO PROPUESTO:
Problema:
Trabaje con la tabla "libros" de una librería.
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.
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:
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.
Para que este atributo funcione correctamente, el campo debe contener solamente
valores positivos; más adelante trataremos este tema.
EJERCICIO RESUELTO:
Problema:
describe libros;
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.
El siguiente registro insertado tomará el valor más alto para seguir la secuencia (en
este caso 16):
EJERCICIO PROPUESTO:
Problema:
Una farmacia guarda información referente a sus medicamentos en una
tabla
llamada "medicamentos".
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:
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.
Creamos la tabla:
Veamos el resultado:
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".
Veamos qué sucede si ingresamos otro registro sin valor para el código:
Ejecutamos entonces:
EJERCICIO PROPUESTO:
Problema:
Una farmacia guarda información referente a sus medicamentos en una
tabla llamada "medicamentos".
5- Ingrese 2 registros:
insert into medicamentos (nombre, laboratorio,precio,cantidad)
values('Sertal','Roche',5.2,100);
insert into medicamentos (nombre, laboratorio,precio,cantidad)
values('Amoxidal 500','Bayer',15.60,100);
7- Vacíe la tabla:
truncate table medicamentos;
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
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".
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.
Imaginemos que ingresamos los datos de un libro, para el cual aún no hemos definido
el precio:
Note que el valor "null" no es una cadena de caracteres, no se coloca entre comillas.
El campo "titulo", no debería aceptar valores nulos, para establecer este atributo
debemos crear la tabla con la siguiente sentencia:
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):
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:
EJERCICIO RESUELTO:
Problema:
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.
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:
Podemos ingresar valores nulos en los campos que lo permiten, por ejemplo, en
"editorial":
Ingresemos otros valores que nos servirán luego para verificar que los valores "null"
son diferentes de 0 y de cadenas vacías.
Para recuperar los registros que contengan el valor "null" en el campo "precio"
tipeamos:
Con la primera sentencia recuperamos los libros cuya editorial es "null"; con la
segunda, los libros cuya editorial guarda una cadena vacía.
EJERCICIO PROPUESTO:
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
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.
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.
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.
EJERCICIO RESUELTO:
Problema:
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.
Field Type
_________________________________
codigo int(10) unsigned
titulo varchar(20)
autor varchar(30)
editorial varchar(15)
precio float unsigned
Para almacenar el precio de los libros, definimos un campo de tipo "float unsigned"
porque jamás guardaremos un valor negativo.
EJERCICIO PROPUESTO:
Problema:
Trabaje con la tabla que almacena los datos sobre películas.
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.
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.
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.
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.
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.
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.
EJERCICIO RESUELTO:
Problema:
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.
EJERCICIO PROPUESTO:
Problema:
Una concesionaria de autos vende autos usados y almacena los datos
de los autos en
una tabla llamada "autos".
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:
- tinyint(x): define un valor entero pequeño, cuyo rango es de -128 a 127. El tipo sin
signo va de 0 a 255.
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.
float 4
decimal(t,d) t+2 si d>0, t+1 si d=0 y d+2 si t<d
EJERCICIO RESUELTO:
Problema:
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.
EJERCICIO PROPUESTO:
Problema:
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.
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.
Para almacenar valores de tipo fecha se permiten como separadores "/", "-" y ".".
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".
EJERCICIO RESUELTO:
Problema:
Una playa de estacionamiento guarda cada día los datos de los vehículos que ingresan
a la playa en una tabla llamada "vehiculos".
Note que no ingresamos los segundos y colocó por defecto "00" para ellos.
almacena "00:00:15".
EJERCICIO PROPUESTO:
Problema:
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.).
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.
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.
EJERCICIO RESUELTO:
Problema:
EJERCICIO PROPUESTO:
Problema:
Trabaje con la tabla que almacena los datos sobre películas, llamada
"peliculas".
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)
('Harry Potter y la piedra filosofal','Daniel R.');
insert into peliculas (titulo,actor,duracion)
('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.
Hemos visto los valores por defecto de los distintos tipos de datos.
Un valor es inválido por tener un tipo de dato incorrecto para el campo o por estar
fuera de rango.
-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.
- 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".
-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.
EJERCICIO RESUELTO:
Problema:
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.
Si intentamos ingresar "null" para el código, lo pasa por alto y sigue la secuencia.
Otro ejemplo:
Aparece un mensaje de error indicando que el campo "titulo" no acepta valores nulos.
Otro ejemplo:
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)
);