Modelado SQL introducción lenguaje bases datos

Técnicas de Modelamiento
Técnicas de Modelamiento
Introducción al SQL
Introducción al SQL

Prof. César Luza Montero
Facultad de Ingeniería de Sistemas e Informática
Universidad Nacional Mayor de San Marcos
Copyright © 2008, Cesar Luza, Lima-Perú

¿Lenguaje de programación?

Programa
Lenguaje

Compilador
Instrucción

Fuente Interpretador

Ejecutable Aplicación
Interactivo

Exploración

Segmento de Programa SQL
CREATE TABLE TIPO_USUARIO
(
idTipoUsuario int Identity(1,1),
descTipoUsuario varchar(20) NOT NULL,
CONSTRAINT PK_TIPO_USUARIO PRIMARY KEY(idTipoUsuario)
)

CREATE TABLE USUARIO
(
idUsuario char(8)NOT NULL,
idTipoUsuario int NOT NULL,
apelUsuario varchar(35)NOT NULL,
nomUsuario varchar(35) NOT NULL,
direccion varchar(50)NULL,
habilitado bit NOT NULL,
fechaExpCarnet smalldatetime NOT NULL,
fechaVencCarnet smalldatetime NOT NULL,
CONSTRAINT PK_USUARIO_idUsuario PRIMARY KEY(idUsuario),
CONSTRAINT FK_USUARIO_idTipoUsuario FOREIGN KEY (idTipoUsuario)
REFERENCES TIPO_USUARIO(idTipoUsuario)
)

Desafío cognitivo

Contenido

El SQL

Definición Comandos Consultas Ejemplos

Mapa de contenidos

Definición de SQL
SQL = Structured Query Language
Es el lenguaje más usado para bases de
datos relacionales
Lenguaje declarativo de alto nivel
Desarrollado por IBM (1974-1977)
Se convirtió en un standard definido por :
– ANSI (American National Standards Institute) e
– ISO (International Standards Organization)

http://bochica.udea.edu.co/~jfduitam/DB-Course/SQL_archivos/frame.htm

Definición de SQL
SQL esta compuesto por lenguajes para :
– Definición de Datos
• DDL (Data Definition Language)
– Para definir estructuras de datos.
– Manipulación
• DML (Data Manipulation Language)
– Para manipular datos
– Control
• DCL (Data Control Language)
– Para recuperación, control de concurrencias,
seguridad y protección

Lenguaje de Definición de datos DDL

Nivel lógico
Nivel Externo Nivel Físico
Global
Definición
de CREATE TABLE CREATE VIEW CREATE INDEX
esquema
Evolución ALTER TABLE
DROP VIEW DROP INDEX
de DROP TABLE
esquema

Los comandos DDL permiten controlar el esquema, es
decir permiten construir, cambiar y remover definiciones
de tablas.

Lenguaje de Manipulación de datos DML

Actualizaciones
Altas INSERT INTO ,,,
Bajas DELETE FROM …
Cambios
UPDATE ..

Consultas SELECT

Lenguaje de Control de datos

Recuperación y Control COMMIT
de concurrencias
ROLLBACK ..
GRANT
Seguridad y Protección
REVOKE

Comandos DDL
CREATE TABLE:
– Nos permite crear una tabla de datos vacía.
CREATE VIEW:
– Permite crear una vista para un usuario
CREATE INDEX:
– Crea un índice que nos puede auxiliar para
las consultas.

Comandos DDL
Create
CREATE TABLE [nombre_basedatos].nombre_tabla
(column datatype [, ...]
[[CONSTRAINT npk] PRIMARY KEY (column [,...]),]
[[CONSTRAINT nuk] UNIQUE (column [,...]),]
[[CONSTRAINT nck] CHECK (condition) ]
[[CONSTRAINT nfk] FOREIGN KEY (column [,...]),]
REFERENCES [schema.]table (column [,...]) ]
);

Comandos DDL
Create
– Los tipo de datos de las columnas sirven para
que decirle al DBMS que valor es permitido
almacenar en cada atributo.
– Una selección de tipos incluye:
• INTEGER
• REAL
• DECIMAL : Including DECIMAL(5) and DECIMAL(4,2)
• VARCHAR
• CHAR
• DATE

Comandos DDL
Create
– Ejemplos

CREATE TABLE Departamento
(
Dep_Codigo SMALLINT NOT NULL,
Dep_Nombre VARCHAR (30),
Dep_Localizacion VARCHAR (10),
Dep_Telefono NUMERIC (10),
constraint dep_pk PRIMARY KEY (Dep_Codigo),
constraint dep_nom UNIQUE (Dep_Nombre),
constraint dep_loc CHECK
(Dep_Localizacion in (‘Lima’, ‘Trujillo’, ‘Ica’))
);

Comandos DDL
Create
– Ejemplos

CREATE TABLE empleado
(
Emp_Codigo smallint not null,
Emp_Nombre varchar(30),
Emp_Cargo varchar(11),
Emp_Fecha_Alta datetime,
Emp_Salario numeric (10),
Emp_Cod_Dep smallint,
constraint emp_pk PRIMARY KEY (Emp_Codigo),
constraint emp_fk FOREIGN KEY (Emp_Cod_Dep) references
Departamento (Dep_Codigo) on delete cascade,
constraint emp_ck CHECK (Emp_salario > 0)
);

Comandos DDL
CREATE table conductor
(
nombre varchar(30) PRIMARY KEY,
fechaNac date NOT NULL
);
CREATE TABLE carro
(
nroPlaca varchar(8) PRIMARY KEY,
marca varchar(20),
color varchar(30),
precio decimal(8,2),
propietario varchar(30) references conductor ( nombre )
);

Comandos DDL
CREATE table conductor
(
nombre varchar(30) ,
fechaNac date NOT NULL,
PRIMARY KEY (NOMBRE)
);
CREATE TABLE carro
(
nroPlaca varchar(8),
marca varchar(20),
color varchar(30),
precio decimal(8,2),
propietario varchar(30)
PRIMARY KEY (nroPlaca),
FOREINGN KEY (propietario) references conductor ( nombre )
);

Comandos DDL
ALTER TABLE:
– Permite modificar la estructura de la tabla:
• agregar o borrar columnas
• cambiar la definición de columnas
• agregar o borrar constraints
DROP TABLE:
– Permite borrar una tabla.
DROP INDEX:
– Borra el índice indicado.

Comandos DDL
ALTER TABLE table
ADD column datatype [DEFAULT expr]
[, column datatype]...;

ALTER TABLE table
MODIFY (column datatype [DEFAULT expr]
[, column datatype]...);

ALTER TABLE table
DROP COLUMN column;

ALTER TABLE table
ADD [CONSTRAINT nfk] FOREIGN KEY (column [,...]),]
REFERENCES table((column [,...]);

ALTER TABLE table
DROP CONSTRAINT constraint [CASCADE];

Comandos DDL
DROP TABLE tablename [CASCADE];
Ejemplo:
– DROP TABLE empleados;

La principal dificultad con el drop de una tabla es la
integridad referencial.

Comandos DML
INSERT:
– Agrega una nueva fila en la tabla.
DELETE:
– Borra filas existentes de una tabla
UPDATE:
– Modifica filas existentes en una tabla.
SELECT:
– Permite realizar consultas de una o más
tablas

DML Insert
INSERT INTO table [(column [, column...])]
VALUES (value [, value...]);
– Esta sintaxis agrega una sola fila por vez.
Ejemplos:
– INSERT INTO departamento (dep_codigo, dep_nombre)
VALUES (50, ‘CONTABILIDAD');
– INSERT INTO departamentos VALUES (50,
‘CONTABILIDAD‘, ’Lima’,’4610035’ );

DML Insert
También pueden insertarse un conjunto de
filas en un comando

INSERT INTO gerentes (gcod, gnombre, gsalario)
SELECT ecod, enombre, esalario
FROM empleados
WHERE cargo = ‘GERENTE';

DML Update
Modifica filas existentes en una tabla
UPDATE table
SET column = value [, column = value, ...]
[WHERE condition];
Ejemplos
UPDATE empleados
SET dcod = 20
WHERE ecod = 7782;

DML Delete
Borra filas existentes en una tabla
DELETE [FROM] table
[WHERE condition];

Ejemplos
DELETE FROM departamentos
WHERE ddescr = ‘FINANZAS';

DML Select
El proceso más importante que podemos llevar a
cabo en una base de datos es la consulta de los
datos.
De nada serviría una base de datos si no
podemos consultarla.
Es además la operación que efectuaremos con
mayor frecuencia.
La sentencia SELECT nos permite consultar los
datos almacenados en una tabla de la base de
datos.

DML Select
El formato de la sentencia select es:

SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>|<nombre_vista>
[{,<nombre_tabla>|<nombre_vista>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
[HAVING <condicion>[{ AND|OR <condicion>}]]
[ORDER BY <nombre_campo>|<indice_campo> [ASC |
DESC] [{,<nombre_campo>|<indice_campo> [ASC | DESC
]}]]

DML Select
Palabra clave que indica que la sentencia de SQL que queremos ejecutar es de
SELECT selección
Indica que queremos seleccionar todos los valores. .Es el valor por defecto y no
ALL suele especificarse casi nunca

DISTINCT Indica que queremos seleccionar sólo los valores distintos

Indica la tabla (o tablas) desde la que queremos recuperar los datos. En el caso
de que exista más de una tabla se denomina a la consulta "consulta combinada"
FROM o "join". En las consultas combinadas es necesario aplicar una condición de
combinación a través de una cláusula WHERE
Especifica una condición que debe cumplirse para que los datos sean devueltos
WHERE por la consulta. Admite los operadores lógicos AND y OR.
Especifica la agrupación que se da a los datos. Se usa siempre en
GROUP BY
combinación con funciones agregadas
Especifica una condición que debe cumplirse para que los datos sean devueltos
por la consulta. Su funcionamiento es similar al de WHERE pero aplicado al
HAVING conjunto de resultados devueltos por la consulta. Debe aplicarse siempre junto a
GROUP BY y la condición debe estar referida a los campos contenidos en ella
Presenta el resultado ordenado por las columnas indicadas. El orden puede
ORDER BY expresarse con ASC (orden ascendente) y DESC (orden descendente). El valor
predeterminado es ASC.

DML Select
Base Datos de ejemplo
– A fin de entender mejor el uso de las consultas con SQL
usaremos una simple base de datos de ejemplo
– La base de datos esta formada por dos tablas: CARRO
y CONDUCTOR
– Cada carro tiene un solo propietario Conductor
– Un conductor puede ser propietario de varios carros

CONDUCTO CARRO
R

DML Select
PK
CONDUCTOR
Nombre FechaNacimiento
Jim Smith 11 Jan 1980
Bob Smith 23 Mar 1981
Bob Jones 3 Dec 1986

PK FK
CARR
O
NROPLACA MARCA COLOR PRECIO PROPIETARI
O
F611 AAA FORD ROJO 12000 Jim Smith
J111 BBB SKODA AZUL 11000 Jim Smith
A155 BDE MERCEDES AZUL 22000 Bob Smith
K555 GHT FIAT VERDE 6000 Bob Jones
SC04 BFE SMART AZUL 13000

DML Select simple
SELECT column FROM tablename
SELECT column1,column2,column3 FROM tablename
SELECT * from tablename

SELECT * from CARRO;
NROPLACA MARCA COLOR PRECIO PROPIETARIO

DML Select simple
SELECT nroplaca from CARRO; SELECT color, propietario from CARRO;
NROPLAC COLO PROPIETARIO
A R
F611 AAA ROJO Jim Smith
J111 BBB AZUL Jim Smith
A155 BDE AZUL Bob Smith
K555 GHT VERDE Bob Jones
SC04 BFE AZUL

Los espacios y saltos de líneas no importan.
Una buena practica es poner ”;” al final de la consulta.
Las mayúsculas o minúsculas (excepto entre comillas simples) es los
mismo.
Las sentencias siguientes son validas:
SELECT NROPLACA FROM CARRO;
SElecT nroplaca
From Carro

DML Select clausula where
Usted puede tener condiciones (reglas) en su consulta
Esas condiciones son comprobadas para cada fila que su
consulta produce
Si la condición es verdadera, la columna es mostrada
Si la condición es falsa, la columna no es mostrada
La condición empieza con WHERE

SELECT columnas
FROM tabla
WHERE condición

DML Select con condición Simple
Una condición simple puede ser mostrar los carros de color ROJO
La condición será color = 'ROJO'

SELECT * from CARRO where color = ‘ROJO’;

NROPLAC MARCA COLOR PRECIO PROPIETARIO
A

SELECT nroplaca FROM SELECT nroplaca from CARRO
CARRO; WHERE color = 'ROJO‘;
NROPLACA
F611 AAA NROPLACA
J111 BBB F611 AAA
A155 BDE
K555 GHT CASE SENSITIVE.
SC04 BFE ‘ROJO’ no es lo mismo que ‘Rojo’ o
‘rojo’

DML Select Comparaciones
Las comparaciones validas incluyen: =,!
=,<>,<,<=,>,>=
– Color = ‘ROJO’ El color debe ser rojo
– Color != ‘ROJO’ El color no es rojo
– Color <> ‘ROJO’ Igual que !=
– Precio > 10000 Mayor que 10000
– Precio >= 10000 Mayor o igual a 10000
– Precio < 10000 Menor que 10000
– Precio <=10000 Menor o igual a 10000
Números – Usted puede decir ‘10000’ o 10000.
Los Strings siempre tienen comillas

DML Select Comparando Fechas
Las comparaciones de fechas pueden ser delicadas
Usted puede usar todos lo comparadores para las fechas

SELECT nombre, fechanacimiento from SELECT nombre, fechanacimiento from
CONDUCTOR CONDUCTOR
NOMBR FECHANACIMIENTO
where fechanacimiento = ‘3 Dec 1986’
E
NOMBR FECHANACIMIENT
Jim Smith 11 Jan 1980 E O
Bob 23 Mar 1981 Bob 3 Dec 1986
Smith Jones
Bob 3 Dec 1986
Jones
FECHA1>FECHA2 indica que FECHA1 es en el futuro después de FECHA2.

SELECT nombre,fechanacimiento NOMBRE FECHANACIMIENTO
from CONDUCTOR
WHERE FECHANACIMIENTO >= ‘1
Jan 1981’ Bob Jones 3 Dec 1986

DML Select Clausula BETWEEN
Cuando trata con fechas, algunas veces se desea comprobar
si el valor de un campo cae entre dos fechas
La manera mas fácil de hacerlo es con BETWEEN
Por ejemplo, Encontrar todos los conductores que nacieron
entre 1995 y 1999
SELECT nombre,fechanacimiento from CONDUCTOR
WHERE FECHANACIMIENTO between ‘1 Jan 1985’
and ’31 Dec 1999’
Between trabaja para otras cosas también, no solo fechas…
SELECT nroplaca from CARRO
where precio between 5000 and 10000;

DML Select Clausula NULL
NULL indica que algo no tiene valor
No es un valor, y usted no puede usar operadores de comparación
normales
Por ejemplo, buscar los carros sin propietarios
Malo: SELECT nroplaca from carro where propietario = NULL
Malo: SELECT nroplaca from carro where propietario = ‘NULL’
Hay dos operadores especiales: IS NULL y IS NOT NULL

SELECT nroplaca from carro SELECT nroplaca from carro
WHERE propietario is null WHERE propietario is not null

NROPLAC NROPLACA
A F611 AAA
SC04 BFE J111 BBB
A155 BDE
K555 GHT
SC04 BFE

DML Select Clausula LIKE
Algunas veces se desea tener una condición que involucra un string
parcial o substrings en comodines
LIKE permite esto, y se introduce en reemplazo de ‘=‘
Si el string contiene ‘%’ o ‘_’, LIKE los usa para soportar comodines.
– % - Matches 0 o mas caracteres en el string
– _ - Matches exactamente 1 carácter en el string

Nombre LIKE ‘Jim Smith’ e.g. Jim Smith
Nombre LIKE ‘_im Smith’ e.g. Tim Smith
Nombre LIKE ‘___ Smith’ e.g. Bob Smith
Nombre LIKE ‘% Smith’ e.g. Frank Smith
Nombre LIKE ‘% S%’ e.g. Brian Smart
Nombre LIKE ‘Bob %’ e.g. Bob Martin
Nombre LIKE ‘%’ i.e. match cualquiera
LIKE es mas costoso que =
Si usted no esta usando wildcards, siempre use = mas que LIKE.

DML Select Operadores Lógicos
Combinar condiciones en una simple clausula WHERE puede
ser de utilidad
AND y OR nos permiten hacer esto
NOT también nos permite modificar el comportamiento de las
condiciones
Cuando esas combinaciones se juntan, pueden ocurrir
problemas en el orden
Esto se resuelve usando paréntesis

DML Select Operador AND
AND combina condiciones donde todas deben ser verdaderas
para filtrar
Revisemos la tabla CARRO:







DML Select Operador AND

SELECT nroplaca from carro SELECT nroplaca from carro
where color = ‘AZUL’ WHERE nroplaca LIKE ‘%5’

NROPLACA NROPLACA
J111 BBB A155 BDE
A155 BDE K555 GHT
SC04 BFE

SELECT nroplaca from carro
WHERE color = ‘AZUL’ and nroplaca LIKE ‘%5%’;
NROPLACA
A155 BDE

DML Select Múltiples AND
Usted puede tener muchas condiciones como LIKE y AND
juntas
Por ejemplo:

SELECT nroplaca
FROM carro
WHERE color = ‘AZUL’
AND nroplaca like ‘%5%’
AND propietario like ‘Bob %’
;

DML Select Operador OR
OR es semejante a ‘uno u otro’. Basta que una de las
condiciones sea verdadera entonces el filtro es verdadero.
Por ejemplo: Buscar los carros de color rojo o azul

SELECT nroplaca,color from CARRO
WHERE color = ‘ROJO’ OR color = ‘AZUL’

NROPLAC COLOR
A
F611 AAA ROJO
J111 BBB AZUL
A155 BDE AZUL
SC04 BFE AZUL

DML Select Operador NOT
NOT invierte la condición establecida
Por ejemplo: WHERE color = ‘ROJO’
Puede invertirse como:
– WHERE color != ‘ROJO’
– WHERE NOT color = ‘ROJO’

NOT no es realmente util en este ejemplo, pero es apropiado
en muchos conjuntos de condiciones complejas.

DML Select Precedencia
La precedencia es el orden en la cual las
condiciones son evaluadas y combinadas juntas
Esto no es el orden en que ellos son escritos
El orden de las condiciones combinadas juntas es:
primero el AND, luego el OR y finalmente el NOT.
Considere: Buscar el carro que tiene 5 en el
nroplaca y es azul o rojo

SELECT nroplaca,color from carro
WHERE color = ‘ROJO’ -- Line 1
OR color = ‘AZUL’ -- Line 2
AND nroplaca LIKE ‘%5%’ -- Line 3

DML Select Paréntesis
Rescribirlo como:
WHERE (color = ‘ROJO’
OR color = ‘AZUL’ )
AND nroplaca LIKE ‘%5%’

Podría ser aclarado como:
WHERE ( color = ‘ROJO’ OR color = ‘AZUL’ )
AND nroplaca LIKE ‘%5%’

DML Select clausula DISTINCT

Encontrar todos los colores usados en los carros

SELECT color from carro; SELECT DISTINCT color from
carro;
COLOR
ROJO
COLOR
AZUL
ROJO
AZUL
AZUL
VERDE
VERDE
AZUL

DML Select clausula ORDER BY
Podria ser ASC: Ordena DESC: Ordena en
simpatico mostrar alfabeticamente o forma descendente
los resultados en numericamente: alfabetico or numerico
forma ordenada ORDER BY … ASC ORDER BY … DESC
es por defecto. debe ser
SELECT marca seleccionado.
from carro; SELECT marca from
carro
SELECT marca from
ORDER BY marca; carro ORDER BY
MARCA MARCA MARCA
marca DESC;
FORD FORD SMART
SKODA FIAT SKODA
MERCEDES MERCEDES MERCEDES
FIAT SKODA FIAT
SMART SMART FORD

DML Select Multi Column Sort
ORDER BY puede tomar multiples columnas

SELECT marca,color FROM carro
ORDER BY color,marca;

MARCA COLOR
SKODA AZUL
SMART AZUL
MERCEDES AZUL
FORD ROJO
FIAT VERDE

DML Select clausula IN
Cuando usted tiene una lista de OR, todos sobre el mismo
atributo, entonces, IN podria ser una manera simple de
declararlos:

Mas que:
SELECT nroplaca, marca FROM carro
WHERE marca = ‘SKODA’ or marca = ‘SMART’

Se tiene:
SELECT nroplaca, marca FROM carro
WHERE marca in (‘SKODA’,’SMART’);

DML Select Funciones de
agregación
Las funciones de agregacióon le permite escribir
consultas para producir estadisticas sobre los datos
en la base de datos
Esas funciones son algunas veces llamadas SET
functions.

Estas incluyen:
– AVG (calcula el promedio)
– SUM
– MAX
– MIN
– COUNT

DML Select Función AVERAGE
SELECT precio FROM carro;
PRECIO
12000
11000
22000
6000
13000

SELECT avg(precio) FROM carro;

AVG(PRECIO)
12800

DML Select Función SUM
Suma todos los valores de la columna

SELECT sum(precio) FROM carro;

SUM(PRECIO)

64000

DML Select Función MAX
Cual es el maximo valor en la columna

SELECT max(precio) FROM carro;

MIN(PRECIO)
22000

DML Select Función MIN
Cual es el minimo valor en la columna

SELECT min(precio) FROM carro;

MIN(PRECIO)
22000

DML Select Función COUNT
Cuantas filas componen una columna
SELECT count(precio) FROM carro;

COUNT(PRECIO)
5

Count(*) es simlar, pero tambiencuenta cuando los precios
son nulos
SELECT count(*) FROM carro;

DML Select Función COUNT
DISTINCT
Algunas veces se desea contar no el numero de filas de una
columna, sino cuantos valores diferentes podrian encontrase
en una columna
Hay una variante especial de count para hacer esto:

SELECT count(color) from carro; COUNT(PRECIO)
5
SELECT count(DISTINCT color) from carro;

COUNT(PRECIO)

3

DML Select clausula GROUP BY
Hasta el momento las funciones de agregación solo han sido
mostradas en consultas con solo la simple agregación sobre
la linea select
Usted puede combinar funciones y no-funciones sonre la
linea select
Para hacer esto necesita GROUP BY.

Pregunta: Cual es el carro mas caro por cada color
Intuitivamente lo siguiente parece correcto , pero no ejecutara
SELECT color,max(precio)
FROM carro;

DML Select clausula GROUP BY
SELECT color,precio
COLOR PRECIO
FROM carro;
ROJO 12000
AZUL 11000
AZUL 22000
VERDE 6000
AZUL 13000
SELECT color,max(precio)
FROM carro
COLOR PRECIO
GROUP BY color;
ROJO 12000
AZUL 22000
VERDE 6000

DML Select clausula HAVING
HAVING permite condiciones para cada grupo de un GROUP
BY.

Considere el problema “Quien tiene mas de 1 carro”.

Podriamos decir algo parecido:
SELECT propietario from carro where count(propietario) > 1

Las funciones de agregación no son permitidas en WHERE.
Ellos son permitidas en HAVING.

DML Select clausula HAVING
SELECT propietario,count(nroplaca)
FROM carro
GROUP BY propietario
HAVING count(nroplaca) > 1
OR
SELECT propietario
FROM carro
GROUP BY propietario
HAVING count(nroplaca) > 1

count(*) Trabaja bien solo en este caso.

DML Select múltiples tablas
Consultar mas de una tabla de la base de datos es
generalmente necesario
La forma básica es solo listar todas las tablas necesarias
Usted debe decirle al DBMS como las tablas podrían ser
unidas (joins)
En este apartado se tratan estos temas

DML Select Consultas
individuales
SELECT * from conductor;
NOMBRE FECHANACIMIENTO

SELECT * from carro
F611 AAA FORD RED 12000 Jim Smith
J111 BBB SKODA BLUE 11000 Jim Smith
A155 BDE MERCEDES BLUE 22000 Bob Smith
K555 GHT FIAT GREEN 6000 Bob Jones
SC04 BFE SMART BLUE 13000

DML Select Consultas juntas sin
restricción
SELECT * FROM carro, conductor
NROPLACA MARCA COLO PRECI PROPIETARI NOMBRE FECHNACIMIENTO
R O O
F611 AAA FORD RED 12000 Jim Smith Jim Smith 11 Jan 1980
J111 BBB SKODA BLUE 11000 Jim Smith Jim Smith 11 Jan 1980
A155 BDE MERCEDE BLUE 22000 Bob Smith Jim Smith 11 Jan 1980
S
K555 GHT FIAT GREE 6000 Bob Jones Jim Smith 11 Jan 1980
N
SC04 BFE SMART BLUE 13000 Jim Smith 11 Jan 1980
F611 AAA FORD RED 12000 Jim Smith Bob Smith 23 Mar 1981
J111 BBB SKODA BLUE 11000 Jim Smith Bob Smith 23 Mar 1981
A155 BDE MERCEDE BLUE 22000 Bob Smith Bob Smith 23 Mar 1981
S
K555 GHT FIAT GREE 6000 Bob Jones Bob Smith 23 Mar 1981
N
SC04 BFE SMART BLUE 13000 Bob Smith 23 Mar 1981
F611 AAA FORD RED 12000 Jim Smith Bob Jones 3 Dec 1986
J111 BBB SKODA BLUE 11000 Jim Smith Bob Jones 3 Dec 1986
A155 BDE MERCEDE BLUE 22000 Bob Smith Bob Jones 3 Dec 1986
S

DML Select Enlace por foreign key
NROPLAC MARCA COLO PRECI PROPIETARI NOMBRE FECHANACIMIENT
A R O O O
A155 BDE MERCEDES BLUE 22000 Bob Smith Jim Smith 11 Jan 1980
K555 GHT FIAT GREE 6000 Bob Jones Jim Smith 11 Jan 1980
N
SC04 BFE SMART BLUE 13000 Jim Smith 11 Jan 1980
F611 AAA FORD RED 12000 Jim Smith Bob Smith 23 Mar 1981
J111 BBB SKODA BLUE 11000 Jim Smith Bob Smith 23 Mar 1981
A155 BDE MERCEDES BLUE 22000 Bob Smith Bob Smith 23 Mar 1981
K555 GHT FIAT GREE 6000 Bob Jones Bob Smith 23 Mar 1981
N
SC04 BFE SMART BLUE 13000 Bob Smith 23 Mar 1981
F611 AAA FORD RED 12000 Jim Smith Bob Jones 3 Dec 1986
J111 BBB SKODA BLUE 11000 Jim Smith Bob Jones 3 Dec 1986
A155 BDE MERCEDES BLUE 22000 Bob Smith Bob Jones 3 Dec 1986
K555 GHT FIAT GREE 6000 Bob Jones Bob Jones 3 Dec 1986
N
SC04 BFE SMART BLUE 13000 Bob Jones 3 Dec 1986

DML Select JOIN Tradicional
SELECT *
FROM carro, conductor
WHERE propietario = nombre;

NROPLACA MARCA COLOR PRECI PROPIETARI NOMBRE FECHANACIMIENT
O O O
K555 GHT FIAT GREEN 6000 Bob Jones Bob Jones 3 Dec 1986

DML Select JOIN Moderno
SELECT *
FROM carro JOIN conductor ON ( propietario = nombre )
;
NROPLAC MARCA COLOR PRECIO PROPIETARI NOMBR FECHANACIMIENT
A O E O
A155 BDE MERCEDE BLUE 22000 Bob Smith Bob Smith 23 Mar 1981
S
K555 GHT FIAT GREEN 6000 Bob Jones Bob 3 Dec 1986
Jones

DML Select OUTER JOIN
Considere la ultima fila del join sin restricción
NROPLAC MARCA COLO PRECIO PROPIETARIO NOMBRE FECHANACIMIENT
A R O
SC04 BFE SMART BLUE 13000 Bob Jones 3 Dec 1986

Este es un carro sin propietario.
Algunas veces deseamos ver las filas que fallan a la condición join por
el valor NULL
Para ver los NULL en el joins usaremos OUTER JOIN.
El JOIN discutido hasta este punto es conocido como INNER JOIN.
Realmente outer join significa que deseamos forzar que todas las filas
de una de las tablas aparezca en el resultado.
Hay algunas variantes del OUTER JOIN, dependiendo de cuales filas
desea usted no perder.

Considere:
Select *
FROM carro JOIN conductor on (propietario = nombre)

To the RIGHT of the JOIN

To the LEFT of the JOIN
Si usted desea todas las filas de CARRO siempre en la respuesta,
necesita un LEFT OUTER JOIN
Si usted necesita todas las filas de CONDUCTOR siempre en la
respuesta, necesita un RIGHT OUTER JOIN

SELECT *
FROM carro LEFT JOIN conductor ON ( propietario = nombre);

nroplaca marca color precio propietario nombre fecnac






SELECT *
FROM carro RIGHT JOIN conductor ON ( propietario = nombre);

DML Select FULL OUTER JOIN
Con LEFT OUTER join, usted no pierde las filas de la tabla izquierda
Con RIGHT OUTER join, usted no pierde las filas de la tabla derecha.
Si usted desea mostrar todas las filas de ambos lados
– Necesita FULL OUTER join, conocido como FULL JOIN.
Considere una nueva fila; David Davis, para CONDUCTOR. David no
es propietario de ningún carro.

nombre fechanacimiento
David Davis 1 Oct 1975

DML Select Ejemplo: LEFT y
RIGHT
SELECT *
FROM carro LEFT JOIN conductor ON ( propietario = nombre);

SELECT *
FROM carro RIGHT JOIN conductor ON ( propietario = nombre );

DML Select Ejemplo: Full
SELECT *
FROM carro FULL JOIN conductor ON ( propietario = nombre)
;







DML Select Naming
Algunas veces los nombres de las columnas pueden ser ambiguos.
Tome dos tablas, llamados ALPHA y BRAVO. Asumimos que cada
tabla tiene una columna llamada CODIGO.

La consulta: SELECT CODIGO from ALPHA,BRAVO;

Falla, porque CODIGO esta en ambas tablas.
El DBMS no puede trabajar el nombre de columna que se desea.
Se puede decirle al DBMS con exactitud anteponiendo el nombre de
la tabla al nombre de la columna, separados por un punto.

SELECT alpha.codigo from ALPHA, BRAVO;

DML Select Aliases
Si se escribe una consulta grande, puede escribir el mismo
nombre largo de tabla una y otra vez.
Esto puede provocar errores en la digitación
SQL permite renombrar las tabla durante la consulta.
Se escribe el nuevo nombre inmediatamente después del
nombre de la tabla en el FROM, separado por espacio.
Mas que: SELECT carro.propietario FROM carro;
Puede decir: SELECT c.propietario FROM carro c;

Tambien trabaja en JOIN.
SELECT c.nroplaca, c.propietario, d.fechanacimiento
FROM carro c JOIN conductor d on (c.propietario = d.nombre)

DML Select Selfjoin
Un selfjoin, o un equijoin, es donde una misma tabla es usado dos
veces en una línea FROM
Indica la necesidad de usar una sola tabla en dos formas diferentes
simultáneamente
Considere la pregunta “Quienes son propietarios de un carro del
mismo color que del de Bob Smith”?

SELECT color FROM carro Color
WHERE propietario = ‘Bob Smith’; BLUE

SELECT propietario FROM carro
WHERE color = ‘BLUE’
Propietario

AND propietario != ‘Bob Smith’ Jim Smith

AND propietario not null;

DML Select Selfjoin
SELECT other.propietario
FROM carro bobsmith, carro other
WHERE bobsmith.color = other.color -- 1
AND bobsmith.propietario = ‘Bob Smith’ -- 2
AND bobsmith.propietario != other.propietario -- 3
AND other.propietario NOT NULL -- 4
;

VIEWS
Las Vistas (VIEWS) son para una base de datos lo que las
subrutinas son para los lenguajes de programación
Una vista nos permite almacenar una consulta en la base de
datos, así podemos accesarlo después por su nombre.
Tratamos las vista en la misma forma que una tabla norma
cuando escribimos consultas

VIEWS
Escribamos una consulta que nos diga cuantos conductores y
cuantos carros esta el al base de datos
Podríamos escribirlo separadamente

SELECT count(*) from CONDUCTOR;
SELECT count(*) from CARRO;

Sin embargo, son dos consultas y queremos hacerlo en una
sola
Almacenemos las dos consultas en dos diferentes VIEWs

VIEWS
CREATE VIEW count1 (total) AS select count(*) from conductor;
CREATE VIEW count2 (total) AS select count(*) from carro;

Select * from count1; Total
3

Select * from count2;
Total
5
Select count1.total,count2.total
from count1,count2; Total Total
3 5

Borrando una VIEW
Cuando finaliza con una VIEW puede crear su propio borrado,
con el comando DROP VIEW.
Para nuestro ejemplo…

DROP VIEW count1;

DROP VIEW count2;

Subqueries
Un Subquery es una sentencia select dentro de otra
Usado en la cláusula WHERE
Los Subqueries pueden retornar muchas filas.
Los Subqueries pueden retornar solo una columna.
Se utiliza como reemplazo de una Vista o de un selfjoin.
Algunos programadores lo ven como más fácil de entender
que otras
El principal inconveniente es que pueden ser mucho más
lentos que selfjoin o las Vistas

Ejemplo Simple
Quien en la base de datos es mayor que Jim
Smith?

SELECT fecnac FROM conductor WHERE nombre
= ‘Jim Smith’;
fecnac
11 Jan 1980

SELECT nmbre FROM conductor WHERE fecnac >
’11 Jan 1980’; name
Bob Smith
Bob Jones

Ejemplo Simple
Select juntos:

SELECT nombre FROM conductor
WHERE fecnac > (SELECT fecnac
FROM conductor
WHERE nombre = ‘Jim Smith’)
;

Esta consulta solo trabajará si hay solo 1 Jim Smith.

ANY y ALL
Para soportar subqueries que retornan mas de 1 fila se
necesita algun operador adicional… ANY and ALL.
ANY – cambia la regla de que debe ser verdadera para al
menos un de las filas retornadas desde el subquery.
ALL – cambia la regla de que debe ser verdadera para todos
y cada una de las filas retornadas desde el subquery.
Los operadores ANY o ALL va inmediatamente antes de abrir
el paréntesis.

Ejemplo 1
Que carros son del mismo color de los carros
propedad de Jim Smith?
Jim es propietario de 2 carros, uno es Rojo y el
otro Azul. Estamos buscando los carros que sean
Rojo o Azul.

SELECT nroplaca FROM carro
WHERE color = ANY ( SELECT color
FROM carro
WHERE propietario = ‘Jim Smith’
)

Ejemplo 2
Listar los conductores mas jovenes que todas las
personas propietarias de carros azules.
Estamos buscando las edades de los conductores
quienes osn propietarios de carros de color azul, y
listar los conductores que son menores que todas
esas edades.

SELECT nombre,fecnac FROM conductor
WHERE fecnac < ALL (
SELECT fecnac
FROM carro JOIN conductor ON (propietario=nombre)
WHERE color = ‘BLUE’
);

IN and NOT IN
We earlier saw IN working for sets like (‘A’,’B’).
A subquery itself returns its result as a set.
Therefore we can use IN and NOT IN on
subqueries.

Question: Which cars are the same colour as one of
Jim Smith’s cars?

SELECT regno FROM car
WHERE colour IN (SELECT colour FROM car
WHERE owner = ‘Jim Smith’)
;

Example of NOT IN

Question: Which cars DO NOT have the
same colour as one of Jim Smith’s cars?

SELECT regno FROM car
WHERE colour NOT IN (SELECT colour
FROM car
WHERE owner = ‘Jim Smith’)
;

EXISTS
If a question involves discovering uniqueness, then
it can probably be easily solved using the operator
EXISTS or NOT EXISTS.
The EXISTS operator tests the result of running a
subquery, and if any rows are returned it is TRUE,
else it is FALSE.
NOT EXISTS does the opposite of EXISTS.

Note that subqueries can actually refer to tables
defined outside the brackets which define the
subquery. This is exceptionally useful, but can be
slow to execute and confusing to look at.

Question: List the colours which are only used once
in the database.

SELECT colour
FROM car a
WHERE exists (
SELECT colour -- The row does not matter
FROM car b -- unique name from
a
WHERE a.colour = b.colour -- Same colour as a
AND a.regno != b.regno -- Different car from a
);

UNION
Sometimes you might write two or more queries
which produce the same types of answer, and you
want to combine the rows of these answers into a
single result.
UNION does this, and basically allows you to join
different SELECT statement together.
UNION automatically removes duplicate rows.

For the next example, assume a row has been
added to the DRIVER table for David Davis, but that
he owns no cars.
Question: List all drivers in the DRIVER table,
together with how many cars they own.

SELECT name,count(*)
FROM driver JOIN car on (name = owner)

NAME Count(*)
Jim Smith 2
Bob Smith 1
Bob Jones 1

David Davis is missing, as he did not satisfy the JOIN
condition.

Write a query just for David Davis…

SELECT name,0
FROM driver
WHERE name NOT IN (select owner from car)
NAME
David Davis 0

Link the two queries together:
SELECT name,count(*)
FROM driver JOIN car on (name = owner)
UNION
SELECT name,0
NAME Count(*)
FROM driver
Jim Smith 2
WHERE name
Bob Smith 1
NOT IN (select owner
Bob Jones 1
from car)
David Davis 0

View Manipulation
When is a view ‘materialised’ or populated with rows
of data?

When it is defined or
when it is accessed

If it is the former then subsequent inserts, deletes and
updates would not be visible. If the latter then changes
will be seen.

Some systems allow you to chose when views are
materialised, most do not and views are materialised
whenever they are accessed thus all changes can be
seen.

VIEW update, insert and delete
Can we change views?
Yes, provided the
Base Table - A Base Table - B
primary key of all the A# B#
base tables which
make up the view are
present in the view. View Definition
View
A# B#

VIEW cont...
This view cannot be
changed because we
Base Table - A Base Table - B
have no means of A# B#
knowing which row of
B to modify
View Definition
View
A#

SELECT - Order of Evaluation
SELECT [DISTINCT] column_name 5,6 eliminate
unwanted data
FROM label_list 1 Cartesian Product
[WHERE condition ] 2
eliminate unwanted rows
[GROUP BY column_list 3 group rows
[HAVING condition ]] 4 eliminate unwanted
groups
[ORDER BY column_list[DESC]] 7 sort rows

The last four components are optional.

Modelado SQL introducción lenguaje bases datos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (8)

Similar a Modelado SQL introducción lenguaje bases datos

Similar a Modelado SQL introducción lenguaje bases datos (20)

Más de Julio Pari

Más de Julio Pari (20)

Modelado SQL introducción lenguaje bases datos

Notas del editor