Sunteți pe pagina 1din 248

Leccin

Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
1
Usando la sentencia
SELECT
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Objetivos
Ejecutar las sentencias bsicas utilizando el comando
SELECT de SQL.
Podr realizar operaciones aritmticas.
Manejo bsico de las cadenas de texto.
2
L - L -
Escribiendo Sentencias SQL
SQL no es case-sensitive.
SQL se puede escribir un una o mas lneas.
Las palabras reservadas no se pueden abreviar.
Las clusulas se escriben en lneas separadas.
Comentar para mejorar la comprensin.
Toda palabra reservada se debe escribir en mayscula
para mejorar su compresin.
Toda sentencia debe terminar con el smbolo de (;) punto
y coma.
3
L - L -
Convenciones
4
Smbolo Significado
[ ] Opcional.
| Un elemento de la lista.
[, ...] Se repite.
{ } Lista de elementos.
L - L -
SELECT [ DISTINCT ] * | expresion [ AS alias ] [, ...]
FROM from_item [, ...];
Sintaxis Bsica
5
SELECT identifica las columnas que sern mostradas.
FROM identifica la tabla donde provienen las columnas.
L - L -
department_name_id | department_name | manager_id | location_id
--------------------+----------------------+------------+-------------
10 | Administration | 200 | 1700
20 | Marketing | 201 | 1800
30 | Purchasing | 114 | 1700
40 | Human Resources | 203 | 2400
50 | Shipping | 121 | 1500
60 | IT | 103 | 1400
70 | Public Relations | 204 | 2700
80 | Sales | 145 | 2500
90 | Executive | 100 | 1700
100 | Finance | 108 | 1700
! ! !
(27 rows)
SELECT *
FROM departments;
Seleccionando todo
6
L - L -
department_id | location_id
---------------+-------------
10 | 1700
20 | 1800
30 | 1700
40 | 2400
50 | 1500
60 | 1400
70 | 2700
80 | 2500
90 | 1700
100 | 1700
! ! !
(17 rows)
SELECT department_id, location_id
FROM departments;
Seleccionando columnas
7
L - L -
Operadores aritmticos
8
Operador Descripcin Precedencia
+ Adicin 2
- Sustraccin 2
* Multiplicacin 1
/ Divisin 1
L - L -
1
2
last_name | salary
-------------+--------
Russell | 14000
! ! !
(107 rows)
SELECT last_name, salary
FROM employees;
last_name | ?column?
-------------+----------
Russell | 14100
! ! !
(107 rows)
SELECT last_name, salary + 100
FROM employees;
Usando los operadores aritmticos
9
L - L -
1
2
last_name | ?column?
-------------+----------
Russell | 140100
! ! !
(107 rows)
SELECT last_name, 10 * salary + 100
FROM employees;
last_name | ?column?
-------------+----------
Russell | 141000
! ! !
(107 rows)
SELECT last_name, 10 * (salary + 100)
FROM employees;
Precedencia en los operadores
10
L - L -
SELECT last_name, job_id, salary, commission_pct
FROM employees;
last_name | job_id | salary | commission_pct
-------------+------------+--------+----------------
Taylor | SA_REP | 8600 | 0.20
Livingston | SA_REP | 8400 | 0.20
Johnson | SA_REP | 6200 | 0.10
Kochhar | AD_VP | 17000 |
De Haan | AD_VP | 17000 |
Hunold | IT_PROG | 9000 |
! ! !
(107 rows)
Definiendo el valor NULL
11
NULL es un valor inaplicable, no disponible, no asignado
o desconocido.
NULL no es un cero o un espacio en blanco.
L - L -
last_name | salary | ?column?
-------------+--------------------
Taylor | 8600 | 86000.20
Livingston | 8400 | 84000.20
Johnson | 6200 | 62000.10
Kochhar | 17000 |
De Haan | 17000 |
Hunold | 9000 |
! ! !
(107 rows)
SELECT last_name, salary, 10 * salary + commission_pct
FROM employees;
Cualquier operacin aritmtica que contenga valores
nulos devolvern como resultado un valor nulo.
Valores NULL en operaciones
12
L - L -
Definiendo un alias a las columnas
13
Renombra el encabezado de una columna.
Es muy til cuando se realizan clculos.
El nuevo nombre se coloca despus de la columna, no
es opcional colocar la palabra reservada AS entre la
columna y el alias.
Los nombres que contienen espacios, caracteres
especiales o case-sensitive se colocan entre comillas
dobles.
L - L -
name | salary | New Salary
-------------+--------+------------
Russell | 14000 | 140000
Partners | 13500 | 135000
Errazuriz | 12000 | 120000
Cambrault | 11000 | 110000
Zlotkey | 10500 | 105000
Tucker | 10000 | 100000
Bernstein | 9500 | 95000
Hall | 9000 | 90000
Olsen | 8000 | 80000
Cambrault | 7500 | 75000
! ! !
(107 rows)
SELECT last_name AS name, salary, 10 * salary AS "New Salary"
FROM employees;
Usando el alias
14
L - L -
SELECT last_name || first_name AS "Employees"
FROM employees;
Employees
------------------
RussellJohn
PartnersKaren
ErrazurizAlberto
CambraultGerald
! ! !
(107 rows)
Concatenar columnas
15
Permite unir varias cadena de texto o columnas.
Es representada por dos barras verticales ( | | ).
La unin de varias cadenas de texto o columnas genera
una nueva columna.
L - L -
Caracteres literales
El literal es un carcter, numero o fecha que estn
incluidas dentro de la sentencia SELECT.
La fecha y el carcter literal son valores que se encierran
en comillas simples (' ').
Por ejemplo:
'U'
'King'
'2007-12-01'
16
L - L -
Employee Details
---------------------------
Russell is a SA_MAN
Partners is a SA_MAN
Errazuriz is a SA_MAN
Cambrault is a SA_MAN
Zlotkey is a SA_MAN
Tucker is a SA_REP
Bernstein is a SA_REP
Hall is a SA_REP
Olsen is a SA_REP
Cambrault is a SA_REP
Tuvault is a SA_REP
! ! !
(107 rows)
SELECT last_name || ' is a ' || job_id AS "Employee Details"
FROM employees;
Usando los caracteres literales
17
L - L -
SELECT last_name
|| E', it\'s assigned Manager ID: '
|| job_id AS "Employee Details
FROM employees;
Employee Details
-------------------------------------------------
Russell, it's assigned Manager ID: SA_MAN
Partners, it's assigned Manager ID: SA_MAN
Errazuriz, it's assigned Manager ID: SA_MAN
Cambrault, it's assigned Manager ID: SA_MAN
Zlotkey, it's assigned Manager ID: SA_MAN
Tucker, it's assigned Manager ID: SA_REP
! ! !
(107 rows)
Incluir caracteres especiales
18
Utilizar cualquier delimitador.
Incrementa la legibilidad y su uso.
L - L -
1
2
department_id
---------------
80
80
! ! !
(107 rows)
SELECT department_id
FROM employees;
department_id
---------------
10
20
! ! !
(9 rows)
SELECT DISTINCT department_id
FROM employees;
Evitando registros duplicados
19
L - L -
En esta leccin, usted debi entender como:
Resumen
20
Usar la sentencia SELECT de SQL para:
Retornar todos los registros de una tabla.
Retornar columnas especificas de una tabla.
Definir un alias en las columnas.
Realizar operaciones aritmticas.
Manipular cadenas de texto y los literales.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
2
Restringiendo y Ordenando
los Datos retornados por el
comando SELECT
L - L -
Objetivos
Limitar el numero de registros que son retornados por la
consulta.
Ordenar los registros por columnas.
Al completar esta leccin usted podr entender los
siguientes puntos:
L - L -
Sintaxis Bsica
Limita el numero de registros mediante el uso de la
clusula WHERE.
Usted agrega las condiciones necesarias para limitar o
filtrar los registros que sern retornados por la consulta.
SELECT [ DISTINCT ] * | expresion [ AS alias ] [, ...]
FROM from_item [, ...]
WHERE conditions;
L - L -
Usando la Clusula WHERE
SELECT employee_id, last_name, job_id, department_id
FROM employees
WHERE department_id = 90;
employee_id | last_name | job_id | department_id
-------------+-----------+---------+---------------
101 | Kochhar | AD_VP | 90
102 | De Haan | AD_VP | 90
100 | King | AD_PRES | 90
(3 rows)
L - L -
Texto y Fechas
Todos los valores de tipo texto y fecha deben ser
encerrados dentro de comillas simples.
El texto es de tipo case-sensitive, y la fecha es sensible
al formato.
El formado de entrada por defecto es YYYY-MM-DD.
SELECT employee_id, last_name, job_id, department_id
FROM employees
WHERE last_name = 'Whalen';
L - L -
Condiciones de Comparacin
Operador Significado
=
Igual
>
Mayor que
<
Menor que
>=
Mayor e igual que
<=
Menor e igual que
BETWEEN
Rango, valor mayor e igual entre menor e igual.
IN
Coincidencia con una lista de valores
LIKE
Comparacin de texto case-sensitive
ILIKE
Comparacin de texto
IS NULL
Comparacin de un valor tipo NULL
L - L -
Usando la Condicin de Comparacin
SELECT last_name, salary
FROM employees
WHERE salary <= 3000;
last_name | salary
-------------+--------
Baida | 2900
Tobias | 2800
Himuro | 2600
Colmenares | 2500
Mikkilineni | 2700
Landry | 2400
Markle | 2200
Atkinson | 2800
Marlow | 2500
(26 rows)
L - L -
Usando la Condicin BETWEEN
SELECT last_name, salary
FROM employees
WHERE salary BETWEEN 2500 AND 3500;
last_name | salary
-------------+--------
Khoo | 3100
Baida | 2900
Tobias | 2800
Himuro | 2600
Colmenares | 2500
Nayer | 3200
Mikkilineni | 2700
Bissot | 3300
Atkinson | 2800
Marlow | 2500
(33 rows)
L - L -
Usando la Condicin IN
SELECT last_name, salary, manager_id
FROM employees
WHERE manager_id IN (100, 101, 201);
last_name | salary | manager_id
-----------+--------+------------
Russell | 14000 | 100
Partners | 13500 | 100
Errazuriz | 12000 | 100
Cambrault | 11000 | 100
Zlotkey | 10500 | 100
Kochhar | 17000 | 100
De Haan | 17000 | 100
Greenberg | 12000 | 101
Raphaely | 11000 | 100
Weiss | 8000 | 100
(20 rows)
L - L -
Patrones de Bsqueda
Operador Significado
%
Cualquier coincidencia en adelante
_
Una sola coincidencia de carcter
L - L -
Usando la Condicin LIKE
SELECT first_name
FROM employees
WHERE first_name LIKE 'S%';
first_name
------------
Sarath
Sundar
Sundita
Shelli
Sigal
Shanta
Steven
Stephen
Sarah
Samuel
(13 rows)
L - L -
Usando la Condicin LIKE
SELECT first_name
FROM employees
WHERE first_name LIKE '_o%';
first_name
-------------
John
Louise
Jonathon
John
Jose Manuel
Mozhe
John
Joshua
Donald
Douglas
(10 rows)
L - L -
Usando la Condicin ILIKE
SELECT first_name
FROM employees
WHERE first_name LIKE 'susan';
first_name
------------
(0 rows)
SELECT first_name
FROM employees
WHERE first_name ILIKE 'susan';
first_name
------------
Susan
(1 row)
L - L -
Usando la Condicin IS NULL
SELECT first_name, manager_id
FROM employees
WHERE manager_id IS NULL;
first_name | manager_id
------------+------------
Steven |
(1 row)
L - L -
Condiciones Lgicas
Operador Significado
AND
Retorna TRUE si ambas condiciones se
cumplen.
OR
Retorno TRUE so si una de las
condiciones se cumplen.
NOT
Retorna TRUE si ambas condiciones
no se cumplen.
L - L -
Usando el Operador AND
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE salary >= 10000
AND job_id LIKE '%MAN%';
employee_id | last_name | job_id | salary
-------------+-----------+--------+--------
145 | Russell | SA_MAN | 14000
146 | Partners | SA_MAN | 13500
147 | Errazuriz | SA_MAN | 12000
148 | Cambrault | SA_MAN | 11000
149 | Zlotkey | SA_MAN | 10500
114 | Raphaely | PU_MAN | 11000
201 | Hartstein | MK_MAN | 13000
(7 rows)
L - L -
Usando el Operador OR
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE salary >= 10000
OR job_id LIKE '%MAN%';
employee_id | last_name | job_id | salary
-------------+-----------+---------+--------
145 | Russell | SA_MAN | 14000
146 | Partners | SA_MAN | 13500
147 | Errazuriz | SA_MAN | 12000
148 | Cambrault | SA_MAN | 11000
149 | Zlotkey | SA_MAN | 10500
150 | Tucker | SA_REP | 10000
156 | King | SA_REP | 10000
162 | Vishney | SA_REP | 10500
168 | Ozer | SA_REP | 11500
169 | Bloom | SA_REP | 10000
(24 rows)
L - L -
Usando el Operador NOT
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE job_id NOT IN ('IT_PROG', 'ST_CLERK', 'SA_REP');
employee_id | last_name | job_id | salary
-------------+------------+------------+--------
145 | Russell | SA_MAN | 14000
146 | Partners | SA_MAN | 13500
147 | Errazuriz | SA_MAN | 12000
148 | Cambrault | SA_MAN | 11000
149 | Zlotkey | SA_MAN | 10500
101 | Kochhar | AD_VP | 17000
102 | De Haan | AD_VP | 17000
108 | Greenberg | FI_MGR | 12000
109 | Faviet | FI_ACCOUNT | 9000
110 | Chen | FI_ACCOUNT | 8200
(52 rows)
L - L -
Reglas de Precedencia
Orden Significado
1
Operaciones Aritmticas
2
Concatenacin
3
Comparacin
4
IS [NOT] NULL, LIKE, NOT [IN]
5
[NOT] BETWEEN
6
No es igual
7
Operador lgico NOT
8
Operador lgico AND
9
Operador lgico OR
L - L -
Reglas de Precedencia
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE job_id = 'SA_REP'
OR job_id = 'AD_PRES'
AND salary > 15000;
employee_id | last_name | job_id | salary
-------------+------------+---------+--------
179 | Johnson | SA_REP | 6200
100 | King | AD_PRES | 24000
167 | Banda | SA_REP | 6200
168 | Ozer | SA_REP | 11500
169 | Bloom | SA_REP | 10000
170 | Fox | SA_REP | 9600
171 | Smith | SA_REP | 7400
172 | Bates | SA_REP | 7300
(31 rows)
L - L -
Reglas de Precedencia
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE (job_id = 'SA_REP'
OR job_id = 'AD_PRES')
AND salary > 15000;
employee_id | last_name | job_id | salary
-------------+-----------+---------+--------
100 | King | AD_PRES | 24000
(1 row)
L - L -
Usando la Clusula ORDER BY
Ordena los registros que son recibidos mediante la
clusula ORDER BY:
ASC: Ordena de forma Acendente (Por defecto)
DESC: Ordena de forma Decendente
La clusula ORDER BY se agrega al final de la sentencia
SELECT.
L - L -
Ordenando de Forma Ascendente
SELECT first_name, job_id, department_id, hire_date
FROM employees
ORDER BY hire_date;
first_name | job_id | department_id | hire_date
-------------+------------+---------------+------------
Steven | AD_PRES | 90 | 1987-06-17
Jennifer | AD_ASST | 10 | 1987-09-17
Neena | AD_VP | 90 | 1989-09-21
Alexander | IT_PROG | 60 | 1990-01-03
Bruce | IT_PROG | 60 | 1991-05-21
Lex | AD_VP | 90 | 1993-01-13
Susan | HR_REP | 40 | 1994-06-07
Hermann | PR_REP | 70 | 1994-06-07
Shelley | AC_MGR | 110 | 1994-06-07
William | AC_ACCOUNT | 110 | 1994-06-07
(107 row)
L - L -
Ordenando de Forma Descendente
SELECT first_name, job_id, department_id, hire_date
FROM employees
ORDER BY hire_date DESC;
first_name | job_id | department_id | hire_date
-------------+------------+---------------+------------
Sundita | SA_REP | 80 | 2000-04-21
Amit | SA_REP | 80 | 2000-04-21
Sundar | SA_REP | 80 | 2000-03-24
Steven | ST_CLERK | 50 | 2000-03-08
David | SA_REP | 80 | 2000-02-23
Hazel | ST_CLERK | 50 | 2000-02-06
Girard | SH_CLERK | 50 | 2000-02-03
Eleni | SA_MAN | 80 | 2000-01-29
Mattea | SA_REP | 80 | 2000-01-24
Douglas | SH_CLERK | 50 | 2000-01-13
Charles | SA_REP | 80 | 2000-01-04
(107 row)
L - L -
Ordenando por Alias
SELECT first_name, department_id, salary * 12 AS annsal
FROM employees
ORDER BY annsal;
first_name | department_id | annsal
-------------+---------------+--------
TJ | 50 | 25200
Hazel | 50 | 26400
Steven | 50 | 26400
James | 50 | 28800
Ki | 50 | 28800
Peter | 50 | 30000
Karen | 30 | 30000
Randall | 50 | 30000
James | 50 | 30000
Martha | 50 | 30000
Joshua | 50 | 30000
(107 row)
L - L -
Ordenando por Varias Columnas
SELECT first_name, department_id, salary * 12 AS annsal
FROM employees
ORDER BY first_name, annsal;
first_name | department_id | annsal
-------------+---------------+--------
Adam | 50 | 98400
Alana | 50 | 37200
Alberto | 80 | 144000
Alexander | 30 | 37200
Alexander | 60 | 108000
Alexis | 50 | 49200
Allan | 80 | 108000
Alyssa | 80 | 105600
Amit | 80 | 74400
Anthony | 50 | 36000
Britney | 50 | 46800
(107 row)
L - L -
Resumen
En esta leccin, usted debi entender como:
Usar la clusula WHERE de SQL.
Comparar un valor a una columna.
Comparar un rango de valores a un columna.
Comprar Texto y Fecha a una columna.
Buscar coincidencia de caracteres en una columna.
Ordenar de forma Ascendente y Descendente el
resultado.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
3
Usando funciones simples
para manipular la salida de
los registros
L - L -
Objetivos
Describir diversos tipos de funciones que se encuentran
disponibles en SQL.
Usar funciones que manipulen caracteres, nmeros y
fechas dentro de la sentencia SELECT.
Usar la funcin para realizar cambios en los tipos de
datos.
Al completar esta leccin usted podr entender los
siguientes puntos:
L - L -
Funciones SQL
Funciones
Argumento 1
Entrada Salida
Resultado Argumento 1
Argumento 1
Procesa
L - L -
Dos Tipos de Funciones en SQL
Funciones
Por
Registro
Por
Mltiples Registros
L - L -
Funciones Por Registro
Manipula el datos de cada elemento
Acepta uno o varios argumentos y retorna un solo valor
Retorna un valor por cada registro
Puede modificar el tipo de dato
Puede aceptar como argumento columnas, variables,
constantes o expresiones
function(arg1, arg2, ...)
L - L -
Funciones de Caracteres
Funciones
de
Caracteres
Manipulacin
Por Case
Manipulacin
Por Caracteres
L - L -
Manipulacin del Case
Funcin Retorna Resultado
lower('TOM') text tom
upper('tom') text TOM
initcap('hi THOMAS') text Hi Thomas
Funciones que modifican la Mayscula o Minscula de
un texto:
L - L -
Usando la Manipulacin del Case
SELECT employee_id, last_name, department_id
FROM employees
WHERE last_name = 'higgins';
employee_id | last_name | department_id
-------------+-----------+---------------
(0 rows)
SELECT employee_id, last_name, department_id
FROM employees
WHERE LOWER(last_name) = 'higgins';
employee_id | last_name | department_id
-------------+-----------+---------------
205 | Higgins | 110
(1 row)
L - L -
Manipulacin de Caracteres
Funcin Retorna Resultado
substring('Thomas' from 1 for 3) text Tho
substr('Thomas', 3) text omas
length('jose') int 4
strpos('high', 'ig') int 2
repeat('Pg', 4) text PgPgPgPg
rpad('hi', 5, 'xy') text Hixyx
replace( 'abcdefabcdef', 'cd', 'XX') text abXXefabXXef
trim(both 'x' from 'xTomxx') text Tom
md5('abc') text 900150983cd24
Funciones bsicas para la manipulacin de texto:
L - L -
Usando la Manipulacin de Caracteres
SELECT employee_id, LENGTH(last_name),
SUBSTRING(job_id from 4 for 6)
FROM employees
WHERE SUBSTR(job_id, 4) = 'REP';
employee_id | length | substring
-------------+--------+-----------
150 | 6 | REP
151 | 9 | REP
152 | 4 | REP
153 | 5 | REP
154 | 9 | REP
155 | 7 | REP
156 | 4 | REP
157 | 5 | REP
158 | 6 | REP
159 | 5 | REP
(33 rows)
L - L -
Funciones Numricas
Funcin Retorna Resultado
round(42.4382, 2) int 42.44
trunc(42.4382, 2) int 42.43
mod(9,4) int 1
round: Redondea un numero decimal.
trunc: Trunca la cantidad de decimales a mostrar.
mod: Retorna el resto de una divisin.
L - L -
Usando las Funcin ROUND
SELECT ROUND(45.923, 2), ROUND(45.923, 0), ROUND(45.923, -1)
round | round | round
-------+-------+-------
45.92 | 46 | 50
(1 row)
L - L -
Usando las Funcin TRUNC
SELECT TRUNC(45.923, 2), TRUNC(45.923, 0), TRUNC(45.923, -1);
trunc | trunc | trunc
-------+-------+-------
45.92 | 45 | 40
(1 row)
L - L -
Usando las Funcin MOD
SELECT last_name, salary, MOD(salary, 5000)
FROM employees
WHERE job_id = 'SA_REP';
last_name | salary | mod
------------+--------+------
Tucker | 10000 | 0
Bernstein | 9500 | 4500
Hall | 9000 | 4000
Olsen | 8000 | 3000
Cambrault | 7500 | 2500
Tuvault | 7000 | 2000
King | 10000 | 0
Sully | 9500 | 4500
McEwen | 9000 | 4000
Smith | 8000 | 3000
Doran | 7500 | 2500
(30 rows)
L - L -
Trabajando con Fechas
PostgreSQL guarda internamente las fechas bajo el
siguiente formato: Siglo, Ao, Mes, Da, Horas, Minutos y
Segundos.
Las fechas por defecto se muestran con el formato
YYYY-MM-DD, Ejemplo: 2007-12-01.
SELECT last_name, hire_date
FROM employees
WHERE hire_date < '1988-01-01';
last_name | hire_date
-----------+------------
Whalen | 1987-09-17
King | 1987-06-17
(2 rows)
L - L -
Funciones de Fechas y Horas
Funcin Resultado
current_date 2007-09-25
current_time 12:29:59.062-04
current_timestamp 2007-09-25 12:30:34.218-04
Funciones que retornan la Fecha y Hora del sistema:
L - L -
Operaciones Aritmticas con Fechas
Sumar o restar una cantidad de das a una fecha.
Extraer la cantidad de das que han transcurrido entre
dos fechas.
Funcin Resultado
date '2001-09-28' + integer '7' 2001-10-05
date '2001-09-28' - integer '7' 2001-09-21
date '2001-10-01' - date '2001-09-28' 3
L - L -
Operaciones Aritmticas con Horas
Sumar o restar una cantidad de tiempo a una hora.
Extraer la cantidad de tiempo que a transcurrido entre
dos periodos de tiempo.
Multiplicar una hora por una cantidad de decimales.
Funcin Resultado
time '01:00' + interval '3 hours' 04:00:00
time '01:00' + interval '3 minute' 01:03:00
time '01:00' + interval '3 seconds' 01:00:03
time '04:00' - interval '3 hours' 01:00:00
time '04:15' - time '04:00'; 00:15:00
interval '1 hour' * double precision '3.5' 03:30:00
L - L -
Conversiones
Implcitas: Es el tipo de conversin realizada de forma
automtica por el manejador de base de datos, y no es
visible para el usuario.
Explicitas: Cuando la conversin requiere de la
intervencin del usuario.
NOTA: Existen tipos de datos que no se les pueden realizar
una conversin debido a su naturaleza.
L - L -
Conversin Implcita
SELECT text 'Origin' AS "label", point '(0,0)' AS "value";
label | value
--------+-------
Origin | (0,0)
(1 row)
SELECT '24', integer '24' AS "age";
?column? | age
----------+-----
24 | 24
(1 row)
L - L -
Usando la funcin CAST
SELECT CAST('24' AS INTEGER), CAST('2001-09-10' AS DATE);
int4 | date
------+------------
24 | 2001-09-10
(1 row)
SELECT CAST('12.5' AS DECIMAL) - 2;
?column?
----------
10.5
(1 row)
L - L -
Conversin Explicita
Caracteres Nmeros Fecha
TO_NUMBER
TO_CHAR
TO_DATE
TO_CHAR
L - L -
Usando la Funcin TO_CHAR con Nmeros
TO_CHAR(int, 'text')
Elemento Descripcin
9 Valor que representa un dgito.
0 Se muestra el numero 0 en ausencia de un valor.
. Imprime decimales a partir del punto.
, Imprime la coma en determinada posicin.
La conversin mediante la funcin to_char permite definir
patrones para mostrar el dato bajo el formato deseado.
L - L -
Usando la Funcin TO_CHAR con Nmeros
Funcin Resultado
to_char(485, '999') 485
to_char(485, '99') ##
to_char(-485, '999') -485
to_char(485, '9 9 9') 4 8 5
to_char(1485, '9,999') 1,485
to_char(148.5, '999.999') 148.500
to_char(485, '"Good number:"999') Good number: 485
to_char(.1, '0.9'); 0.1
to_char(1485, '9999.99') 1485.00
L - L -
Usando la Funcin TO_CHAR con Fechas
SELECT last_name, TO_CHAR(salary, '$99,999.00') AS "Salary"
FROM employees;
last_name | Salary
-------------+-------------
Russell | $ 14,000.00
Partners | $ 13,500.00
Errazuriz | $ 12,000.00
Cambrault | $ 11,000.00
Zlotkey | $ 10,500.00
Tucker | $ 10,000.00
Bernstein | $ 9,500.00
Hall | $ 9,000.00
Olsen | $ 8,000.00
Cambrault | $ 7,500.00
Tuvault | $ 7,000.00
King | $ 10,000.00
(107 rows)
L - L -
Usando la Funcin TO_CHAR con Fechas
TO_CHAR(date, 'text')
Elemento Descripcin
YYYY Ao de cuatro dgitos.
YY Ao de dos dgitos.
MONTH Nombre del mes en mayscula.
MM Numero del mes (01-12).
DAY Nombre del da en mayscula.
DY Nombre abreviado del da en 3 letras.
DD Numero del da (01-31).
La conversin mediante la funcin to_char permite definir
patrones para mostrar el dato bajo el formato deseado.
L - L -
Usando la Funcin TO_CHAR con Fechas
SELECT last_name,
TO_CHAR(hire_date, 'YYYY, MONTH') AS "Hire Date"
FROM employees;
last_name | Hire Date
-------------+-----------------
Russell | 1996, OCTOBER
Partners | 1997, JANUARY
Errazuriz | 1997, MARCH
Cambrault | 1999, OCTOBER
Zlotkey | 2000, JANUARY
Tucker | 1997, JANUARY
Bernstein | 1997, MARCH
Hall | 1997, AUGUST
Olsen | 1998, MARCH
Cambrault | 1998, DECEMBER
Tuvault | 1999, NOVEMBER
(107 rows)
L - L -
Patrones para modificar el formato
Utilizar el modificador TM (Translation Mode) para imprimir
los nombres de los das y meses segn la configuracin del
Sistema Operativo, se puede utilizar en cualquier patrn.
to_char
-------------------
Lunes, Enero-2010
(1 row)
SELECT to_char(current_timestamp, 'TMDay, TMMonth-yyyy');
L - L -
Usando las funciones TO_NUMBER y TO_DATE
Convierte una cadena de caracteres a un formato
numrico usando la funcin TO_NUMBER:
Convierte una cadena de caracteres a una fecha con
formato usando la funcin TO_DATE:
TO_NUMBER(text[, 'text'])
TO_DATE(text[, 'text'])
L - L -
Paso 1= Resultado 1
Funciones Jerrquicas
Dentro de un registro pueden haber distintas funciones
en muchos niveles.
Las funciones jerrquicas son evaluadas de adentro
hacia a fuera.
F3( F2( F1( col1, col2 ), arg2 ), arg3 )
Paso 2= Resultado 2
Paso 3= Resultado 3
L - L -
Funciones Jerrquicas
SELECT last_name,
UPPER(SUBSTR(last_name, 1, 8) || '_US')
FROM employees
WHERE department_id = 60;
last_name | upper
-----------+-------------
Hunold | HUNOLD_US
Ernst | ERNST_US
Austin | AUSTIN_US
Pataballa | PATABALL_US
Lorentz | LORENTZ_US
(5 rows)
L - L -
Expresiones Condicionales
COALESCE
CASE
Las siguientes funciones trabajan con cualquier tipo de
dato y permite el uso del valor NULL:
L - L -
Funcin COALESCE
Convierte NULL a un valor en especifico.
El valor devuelto debe ser del mismo tipo al que se
encuentra definido en la columna.
Soporta los tipos de datos numricos, caracteres y
fechas.
COALESCE(value, [, ...]);
L - L -
Funcin COALESCE
SELECT last_name,
COALESCE(manager_id, commission_pct, -1) AS comm
FROM employees
ORDER BY commission_pct;
last_name | comm
-------------+------
Marvins | 147
Johnson | 149
Baer | 101
Higgins | 101
Gietz | 205
King | -1
Jones | 123
Kochhar | 100
De Haan | 100
Hunold | 102
(107 rows)
L - L -
Funcin COALESCE
value1: Retorna este valor si no es NULL.
value2: Retorna este valor si no es NULL y si el primer
valor (value1) es NULL.
value3: Retorna este valor si todas las anteriores son
NULL.
COALESCE(value1, value2, value3, ... valueN);
L - L -
Funcin COALESCE
SELECT last_name,
COALESCE(commission_pct, 0) AS comm
FROM employees
ORDER BY commission_pct;
last_name | comm
-------------+------
Marvins | 0.10
Johnson | 0.10
Kumar | 0.10
Lee | 0.10
King | 0.35
McEwen | 0.35
Russell | 0.40
Gee | 0
Philtanker | 0
Ladwig | 0
(107 rows)
L - L -
Funcin CASE
Facilita el uso de la condicin IF-THEN-ELSE mediante
la sintaxis de SQL.
CASE WHEN condition THEN result
[WHEN ...]
[ELSE result]
END;
L - L -
Funcin CASE
SELECT last_name, job_id, salary,
CASE job_id WHEN 'SA_MAN' THEN 1.10 * salary
WHEN 'SA_REP' THEN 1.15 * salary
ELSE salary
END AS "New Salary"
FROM employees;
last_name | job_id | salary | New Salary
-------------+------------+--------+------------
Russell | SA_MAN | 14000 | 15400.00
Partners | SA_MAN | 13500 | 14850.00
Errazuriz | SA_MAN | 12000 | 13200.00
Cambrault | SA_MAN | 11000 | 12100.00
Zlotkey | SA_MAN | 10500 | 11550.00
Tucker | SA_REP | 10000 | 11500.00
Bernstein | SA_REP | 9500 | 10925.00
Hall | SA_REP | 9000 | 10350.00
(107 rows)
L - L -
Resumen
En esta leccin, usted debi entender como:
Usar las funciones bsicas de SQL.
Manipular las cadenas de caracteres.
Modificar decimales.
Manipular fechas.
Realizar conversiones entre los principales Tipos de
Datos.
Expresiones de Condicin.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
4
Usando funciones para
manipular grupos de datos
L - L -
Objetivos
Identificar las funciones disponibles.
Describir como usar una funcin de grupo.
Agrupar datos mediante la clusula GROUP BY.
Incluir o excluir datos agrupados mediante el uso de la
clusula HAVING.
Al completar esta leccin usted podr entender los
siguientes puntos:
L - L -
?Como trabajan las funciones de grupo?
department_id | salary
---------------+--------
80 | 14000
80 | 13500
80 | 12000
80 | 11000
80 | 10500
80 | 10000
80 | 9500
80 | 9000
80 | 8000
80 | 7500
80 | 7000
80 | 10000
80 | 9500
80 | 9000
80 | 8000
80 | 7500
80 | 7000
80 | 10500
(107 rows)
max
-------
24000
(1 row)
Las funciones de grupo opera sobre un conjunto de
registros y se retorna un solo resultado por grupo.
Salario mas alto de
la tabla employees.
L - L -
Funciones de grupo
Funciones bsicas que realizan operaciones a un
grupo de registros en especifico:
AVG
COUNT
MAX
MIN
SUM
L - L -
Sintaxis Bsica
SELECT [ column ], group_function(column) [, ...]
FROM from_item
[WHERE condition]
[GROUP BY column]
[ORDER BY column];
L - L -
Usando las funciones AVG, MAX, MIN y SUM
SELECT AVG(salary), MAX(salary), MIN(salary), SUM(salary)
FROM employees
WHERE department_id = 80;
avg | max | min | sum
-----------------------+-------+------+--------
8955.8823529411764706 | 14000 | 6100 | 304500
(1 row)
L - L -
Usando las funciones MAX y MIN
SELECT MAX(hire_date), MIN(hire_date)
FROM employees
WHERE department_id = 80;
max | min
------------+------------
2000-04-21 | 1996-01-30
(1 row)
Puede utilizar las funciones MAX y MIN para los tipos de
datos numricos, caracteres y fechas.
L - L -
Usando la funciones COUNT
SELECT COUNT(*)
FROM employees;
count
-------
107
La funcin COUNT(*) retorna la cantidad total de registros que
se encuentran en una tabla.
1
SELECT COUNT(commission_pct)
FROM employees;
count
-------
35
La funcin COUNT(expr) retorna la cantidad total de registros
NO NULL que se encuentran en una tabla.
2
L - L -
Usando la palabra DISTINCT
Usando la palabra DISTINCT se eliminan todos los
valores duplicados.
Puede emplear la palabra DISTINCT dentro de cualquier
funcin.
Retorna todo los elementos que NO son del tipo NULL.
L - L -
Usando la palabra DISTINCT
SELECT COUNT(DISTINCT department_id)
FROM employees;
count
-------
11
(1 row)
La siguiente consulta cuenta cuantos departamentos
se encuentran asignados en la tabla employees.
L - L -
Funciones de grupo y valores NULL
SELECT AVG(commission_pct)
FROM employees;
avg
------------------------
0.22285714285714285714
Las funciones de grupo ignoran los valores NULL.
1
SELECT AVG(COALESCE(commission_pct, 0))
FROM employees;
avg
------------------------
0.07289719626168224299
La funcin COALESCE obliga a las funciones de grupo que
incluya los valores de tipo NULL.
2
L - L -
Creando grupo de datos
department_id | salary
---------------+--------
10 | 4400
20 | 13000
20 | 6000
30 | 3100
30 | 11000
30 | 2500
30 | 2900
40 | 6500
50 | 2500
50 | 8000
50 | 8200
60 | 6000
60 | 9000
70 | 10000
80 | 9500
80 | 9000
80 | 8000
90 | 24000
90 | 17000
90 | 17000
100 | 6900
100 | 9000
100 | 12000
110 | 8300
110 | 12000
(107 rows)
department_id | avg
---------------+------------------------
10 | 4400.0000000000000000
20 | 9500.0000000000000000
30 | 4150.0000000000000000
40 | 6500.0000000000000000
50 | 3475.5555555555555556
60 | 5760.0000000000000000
70 | 10000.0000000000000000
80 | 8955.8823529411764706
90 | 19333.333333333333
100 | 8600.0000000000000000
110 | 10150.0000000000000000
| 7000.0000000000000000
(12 rows)
Promedio del salario por cada
departamento y por cada empleado del
mismo departamento
L - L -
Sintaxis Bsica
SELECT [ column ], group_function(column) [, ...]
FROM from_item
[WHERE condition]
[GROUP BY column]
[ORDER BY column];
Permite dividir los registros de una tabla en pequeos
grupos usando la clusula GROUP BY.
No puedes utilizar Alias dentro de la clusula GROUP BY.
Solo puedes incluir el nombre de la columna dentro de la
clusula GROUP BY.
Si no usas funciones de grupo no podrs apreciar
resultados individuales.
L - L -
Usando la clusula GROUP BY
SELECT department_id, AVG(salary)
FROM employees
GROUP BY department_id
ORDER BY department_id;
department_id | avg
---------------+------------------------
10 | 4400.0000000000000000
20 | 9500.0000000000000000
30 | 4150.0000000000000000
40 | 6500.0000000000000000
50 | 3475.5555555555555556
60 | 5760.0000000000000000
(12 rows)
Todas las columnas dentro de la sentencia SELECT no
deben estar en la funcin de grupo si no en la
clausrala GROUP BY.
L - L -
Usando la clusula GROUP BY
SELECT AVG(salary)
FROM employees
GROUP BY department_id;
avg
------------------------
7000.0000000000000000
10150.0000000000000000
8600.0000000000000000
19333.333333333333
8955.8823529411764706
10000.0000000000000000
5760.0000000000000000
3475.5555555555555556
6500.0000000000000000
4150.0000000000000000
(12 rows)
Las columnas dentro la clusula GROUP BY no tienen
que estar dentro de la sentencia SELECT .
L - L -
Agrupando por mas de una columna
department_id | job_id | salary
---------------+------------+--------
10 | AD_ASST | 4400
30 | PU_CLERK | 3100
30 | PU_CLERK | 2800
30 | PU_CLERK | 2500
30 | PU_CLERK | 2600
30 | PU_CLERK | 2900
50 | SH_CLERK | 3800
50 | SH_CLERK | 3000
50 | SH_CLERK | 3400
50 | SH_CLERK | 4100
50 | SH_CLERK | 4200
50 | SH_CLERK | 2800
50 | SH_CLERK | 2500
60 | IT_PROG | 9000
60 | IT_PROG | 4200
60 | IT_PROG | 4800
60 | IT_PROG | 4800
60 | IT_PROG | 6000
100 | FI_ACCOUNT | 7700
100 | FI_ACCOUNT | 6900
100 | FI_ACCOUNT | 9000
100 | FI_ACCOUNT | 8200
100 | FI_ACCOUNT | 7800
100 | FI_MGR | 12000
(107 rows)
department_id | job_id | sum
---------------+------------+--------
10 | AD_ASST | 4400
20 | MK_MAN | 13000
20 | MK_REP | 6000
30 | PU_CLERK | 13900
30 | PU_MAN | 11000
40 | HR_REP | 6500
50 | SH_CLERK | 64300
50 | ST_CLERK | 55700
50 | ST_MAN | 36400
60 | IT_PROG | 28800
70 | PR_REP | 10000
80 | SA_MAN | 61000
(20 rows)
Promedio del salario por cada
departamento y por cada empleado
del mismo cargo y departamento
L - L -
Usando la clusula GROUP BY con mltiples
columnas
SELECT department_id, job_id, SUM(salary)
FROM employees
GROUP BY department_id, job_id
ORDER BY department_id;
department_id | job_id | sum
---------------+------------+--------
10 | AD_ASST | 4400
20 | MK_MAN | 13000
20 | MK_REP | 6000
30 | PU_CLERK | 13900
30 | PU_MAN | 11000
40 | HR_REP | 6500
50 | SH_CLERK | 64300
50 | ST_CLERK | 55700
50 | ST_MAN | 36400
60 | IT_PROG | 28800
70 | PR_REP | 10000
80 | SA_MAN | 61000
(20 rows)
L - L -
Consultas mal escritas usando las
funciones de grupo
SELECT department_id, SUM(salary)
FROM employees;
ERROR: column "employees.department_id" must appear in the GROUP
BY clause or be used in an aggregate function
Toda columna o expresin que no se encuentra dentro
de una funcin de grupo, debe estar dentro de la
clusula GROUP BY.
L - L -
Consultas mal escritas usando las
funciones de grupo
SELECT department_id, job_id, AVG(salary)
FROM employees
WHERE AVG(salary) > 1000
GROUP BY department_id, job_id
ORDER BY department_id;
ERROR: aggregates not allowed in WHERE clause
No se puede usar condiciones en la clusula WHERE para
restringir grupos.
Use la clusula HAVING para restringir los grupos.
No use las funciones de grupo dentro de la clusula
WHERE.
L - L -
Restringiendo el resultado de los grupo con
la clusula HAVING
SELECT [ column ], group_function(column) [, ...]
FROM from_item
[WHERE condition]
[GROUP BY column]
[HAVING condition [, ...]]
[ORDER BY column];
Filtra por registros agrupados.
Muestra la coincidencia definida en la clusula HAVING.
L - L -
Usando la clusula HAVING
SELECT department_id, MAX(salary)
FROM employees
GROUP BY department_id
HAVING MAX(salary) > 10000;
department_id | max
---------------+-------
110 | 12000
100 | 12000
90 | 24000
80 | 14000
30 | 11000
20 | 13000
(6 rows)
L - L -
Usando la clusula HAVING
SELECT job_id, SUM(salary) AS "PAYROLL"
FROM employees
WHERE job_id NOT LIKE '%REP%'
GROUP BY job_id
HAVING SUM(salary) > 13000
ORDER BY SUM(salary);
job_id | PAYROLL
------------+---------
PU_CLERK | 13900
AD_PRES | 24000
IT_PROG | 28800
AD_VP | 34000
ST_MAN | 36400
FI_ACCOUNT | 39600
ST_CLERK | 55700
SA_MAN | 61000
SH_CLERK | 64300
(9 rows)
L - L -
Funciones jerrquicas de grupo
SELECT MAX(AVG(salary))
FROM employees
GROUP BY department_id;
ERROR: aggregate function calls may not be nested
No se puede usar las funciones de grupo en modo
jerrquico.
L - L -
Resumen
En esta leccin, usted debi entender como:
Usar las funciones bsicas de grupo en SQL.
SUM
COUNT
MAX
MIN
AVG
Escribir consultas usando la clusula GROUP BY.
Escribir consultas usando la clusula HAVING.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
5
Recibiendo datos desde
mltiples tablas
L - L5 - L -
Objetivos
Escribir sentencias SELECT para poder combinar
diversas tablas que se encuentran relacionadas.
Al completar esta leccin usted podr entender los
siguientes puntos:
2
L - L5 - L -
Obteniendo datos de mltiples tablas
employee_id | last_name | department_id
-------------+-----------+---------------
145 | Russell | 80
146 | Partners | 80
147 | Errazuriz | 80
148 | Cambrault | 80
149 | Zlotkey | 80
150 | Tucker | 80
151 | Bernstein | 80
152 | Hall | 80
153 | Olsen | 80
154 | Cambrault | 80
EMPLOYEES
department_id | department_name | location_id
---------------+----------------------+-------------
10 | Administration | 1700
20 | Marketing | 1800
30 | Purchasing | 1700
40 | Human Resources | 2400
50 | Shipping | 1500
60 | IT | 1400
70 | Public Relations | 2700
80 | Sales | 2500
90 | Executive | 1700
100 | Finance | 1700
110 | Accounting | 1700
120 | Treasury | 1700
130 | Corporate Tax | 1700
DEPARTMENTS
employee_id | department_id | department_name
-------------+---------------+-----------------
202 | 20 | Marketing
119 | 30 | Purchasing
187 | 50 | Shipping
107 | 60 | IT
155 | 80 | Sales
102 | 90 | Executive
101 | 90 | Executive
113 | 100 | Finance
206 | 110 | Accounting
(32 rows)
3
L - L5 - L -
Tipos de JOIN
[ INNER ] JOIN
LEFT [ OUTER ] JOIN
RIGHT [ OUTER ] JOIN
FULL [ OUTER ] JOIN
CROSS JOIN
NATURAL JOIN
4
L - L5 - L -
Sintaxis bsica
SELECT table_1.expression, table_2.expresion [, ...]
FROM table_1
[NATURAL JOIN table_2] |
[JOIN table_2 USING(expression)] |
[JOIN table_2 ON table_2.expression = table_1.expression] |
[LEFT | RIGHT | FULL OUTER JOIN table_2
ON table_2.expression = table_1.expression] |
[CROSS JOIN table_2];
5
L - L5 - L -
Usando la Clusula NATURAL JOIN
La clusula NATURAL JOIN une dos tablas mediante
todas las columnas que tengan el mismo nombre.
Selecciona los registros que provienen de las dos tablas
siempre y cuando los valores de las columnas que tienen
el mismo nombre coincidan.
Si el tipo de dato es diferente en las columnas que tienen
el mismo nombre, se produce un error.
6
L - L5 - L -
Usando la clusula NATURAL JOIN
SELECT employee_id, department_id, department_name
FROM employees
NATURAL JOIN departments;
employee_id | department_id | department_name
-------------+---------------+-----------------
202 | 20 | Marketing
119 | 30 | Purchasing
118 | 30 | Purchasing
117 | 30 | Purchasing
116 | 30 | Purchasing
115 | 30 | Purchasing
187 | 50 | Shipping
186 | 50 | Shipping
185 | 50 | Shipping
184 | 50 | Shipping
! ! !
(32 rows)
7
L - L5 - L -
Uniendo tablas usando la clusula USING
En caso de existir varias columnas con el mismo nombre
y su tipo de dato no coincide, se utiliza la clusula JOIN
acompaada de la clusula USING para especificar
cuales de las columnas sern utilizadas para unir las dos
tablas.
Utilizar la clusula USING solamente cuando existe mas
de una columna que coincide.
No puede usar nombres de tablas o alias para hacer
referencia a una columna que tenga nombres en comn.
8
L - L5 - L -
Uniendo columnas con el mismo nombre
employee_id | last_name | department_id
-------------+-----------+---------------
145 | Russell | 80
146 | Partners | 80
147 | Errazuriz | 80
148 | Cambrault | 80
149 | Zlotkey | 80
150 | Tucker | 80
151 | Bernstein | 80
152 | Hall | 80
153 | Olsen | 80
154 | Cambrault | 80
EMPLOYEES
department_id | department_name | location_id
---------------+----------------------+-------------
10 | Administration | 1700
20 | Marketing | 1800
30 | Purchasing | 1700
40 | Human Resources | 2400
50 | Shipping | 1500
60 | IT | 1400
70 | Public Relations | 2700
80 | Sales | 2500
90 | Executive | 1700
100 | Finance | 1700
DEPARTMENTS
Clave Fornea Clave Primaria
=
9
L - L5 - L -
Uniendo columnas con el mismo nombre
SELECT employee_id, department_id, department_name
FROM employees
JOIN departments USING(department_id);
employee_id | department_id | department_name
-------------+---------------+------------------
200 | 10 | Administration
202 | 20 | Marketing
201 | 20 | Marketing
119 | 30 | Purchasing
118 | 30 | Purchasing
117 | 30 | Purchasing
116 | 30 | Purchasing
115 | 30 | Purchasing
114 | 30 | Purchasing
203 | 40 | Human Resources
! ! !
(106 rows)
10
L - L5 - L -
Columnas Ambiguas
Usar los alias en las tablas para identificar correctamente
las columnas entre las tablas.
Usar los alias en las tablas mejora el rendimiento.
Usar los alias en las columnas que son del mismo
nombre y estn en distintas tablas.
Usar los alias simplifican las consultas.
11
L - L5 - L -
Usando el alias en las tablas
SELECT e.employee_id, e.last_name,
e.department_id, d.department_id,
d.location_id
FROM employees e
JOIN departments d USING(department_id);
employee_id | last_name | department_id | department_id | location_id
-------------+-------------+---------------+---------------+-------------
200 | Whalen | 10 | 10 | 1700
202 | Fay | 20 | 20 | 1800
201 | Hartstein | 20 | 20 | 1800
119 | Colmenares | 30 | 30 | 1700
118 | Himuro | 30 | 30 | 1700
117 | Tobias | 30 | 30 | 1700
116 | Baida | 30 | 30 | 1700
115 | Khoo | 30 | 30 | 1700
114 | Raphaely | 30 | 30 | 1700
203 | Mavris | 40 | 40 | 2400
! ! !
(106 rows)
12
L - L5 - L -
Creando JOIN con la clusula ON
Se utiliza la clusula ON para especificar la unin de las
columnas con distinto nombre o condiciones arbitrarias.
Las condiciones en la clusula ON se encuentran
separadas de otras condiciones de bsqueda.
La clusula ON permite un cdigo mas fcil de entender.
13
L - L5 - L -
Usando la clusula ON
SELECT e.employee_id, e.last_name,
d.location_id, department_id
FROM employees e
JOIN departments d ON(d.department_id = e.department_id);
employee_id | last_name | location_id | department_id
-------------+-------------+-------------+---------------
200 | Whalen | 1700 | 10
202 | Fay | 1800 | 20
201 | Hartstein | 1800 | 20
119 | Colmenares | 1700 | 30
118 | Himuro | 1700 | 30
117 | Tobias | 1700 | 30
116 | Baida | 1700 | 30
115 | Khoo | 1700 | 30
203 | Mavris | 2400 | 40
! ! !
(106 rows)
14
L - L5 - L -
Uso libre del JOIN con la clusula ON
employee_id | last_name | manager_id
-------------+-------------+------------
100 | King |
121 | Fripp | 100
120 | Weiss | 100
108 | Greenberg | 101
103 | Hunold | 102
106 | Pataballa | 103
104 | Ernst | 103
113 | Popp | 108
117 | Tobias | 114
116 | Baida | 114
126 | Mikkilineni | 120
129 | Bissot | 121
130 | Atkinson | 121
(107 rows)
employee_id | last_name
-------------+-----------
100 | King
101 | Kochhar
102 | De Haan
114 | Raphaely
120 | Weiss
121 | Fripp
122 | Kaufling
123 | Vollman
124 | Mourgos
145 | Russell
146 | Partners
147 | Errazuriz
148 | Cambrault
(15 rows)
EMPLOYEES (Trabajadores) EMPLOYEES (Jefes)
Clave Fornea Clave Primaria
=
15
L - L5 - L -
Uso libre del JOIN con la clusula ON
SELECT e.last_name AS "Trabajador",
m.last_name AS "Jefe
FROM employees e
JOIN employees m ON (e.manager_id = m.employee_id);
Trabajador | Jefe
-------------+-----------
Russell | King
Partners | King
Errazuriz | King
Cambrault | King
Zlotkey | King
Tucker | Russell
Bernstein | Russell
Hall | Russell
Olsen | Russell
! ! !
(106 rows)
16
L - L5 - L -
Condiciones adicionales en la clusula JOIN
SELECT e.last_name AS "Trabajador",
m.last_name AS "Jefe
FROM employees e
JOIN employees m ON ( e.manager_id = m.employee_id
AND e.manager_id = 100);
Trabajador | Jefe
------------+------
Russell | King
Partners | King
Errazuriz | King
Cambrault | King
Zlotkey | King
Kochhar | King
De Haan | King
Raphaely | King
Weiss | King
Fripp | King
Kaufling | King
Vollman | King
Mourgos | King
! ! !
(14 rows)
17
L - L5 - L -
Usando varias clusulas JOIN juntas
SELECT employee_id, city, department_name
FROM employees e
JOIN departments d ON d.department_id = e .department_id
JOIN locations l ON d.location_id = l.location_id;
employee_id | city | department_name
-------------+---------------------+------------------
200 | Seattle | Administration
202 | Toronto | Marketing
201 | Toronto | Marketing
119 | Seattle | Purchasing
118 | Seattle | Purchasing
117 | Seattle | Purchasing
116 | Seattle | Purchasing
115 | Seattle | Purchasing
114 | Seattle | Purchasing
203 | London | Human Resources
199 | South San Francisco | Shipping
198 | South San Francisco | Shipping
197 | South San Francisco | Shipping
196 | South San Francisco | Shipping
! ! !
(106 rows)
18
L - L5 - L -
Combinaciones de desigualdad
department_name | department_id
----------------------+---------------
Administration | 10
Marketing | 20
Purchasing | 30
Human Resources | 40
Shipping | 50
IT | 60
Public Relations | 70
Sales | 80
Executive | 90
Finance | 100
Accounting | 110
Contracting | 190
! ! !
(27 rows)
department_id | last_name
---------------+-------------
| Grant
110 | Gietz
110 | Higgins
100 | Urman
100 | Faviet
100 | Chen
100 | Sciarra
100 | Popp
100 | Greenberg
90 | King
90 | De Haan
90 | Kochhar
80 | Russell
80 | McEwen
80 | Smith
80 | Doran
! ! !
(107 rows)
El departamento 190 no se encuentra
asignado a ningn empleado
DEPARTMENTS EMPLOYEES
19
L - L5 - L -
Combinaciones INNER Versus OUTER
Las combinaciones entre tablas usando las clusulas
NATURAL JOIN, USING y ON retorna un resultado de
tipo INNER JOIN, donde siempre existe una relacin de
valores.
Para retornar aquellos registros que no coinciden
mediante una relacin entre tablas, se utiliza la clusula
OUTER JOIN, donde podemos especificar de cual lado
falta una coincidencia.
LEFT OUTER JOIN
RIGHT OUTER JOIN
FULL OUTER JOIN
La clave fornea se encuentren con el valor NULL.
20
L - L5 - L -
Usando la clusula LEFT,OUTER JOIN
SELECT e.last_name, e.department_id, d.department_name
FROM employees e
LEFT OUTER JOIN departments d
ON e.department_id = d.department_id
ORDER BY d.department_id DESC;
last_name | department_id | department_name
-------------+---------------+------------------
Grant | |
Gietz | 110 | Accounting
Higgins | 110 | Accounting
Urman | 100 | Finance
Faviet | 100 | Finance
Chen | 100 | Finance
Sciarra | 100 | Finance
Popp | 100 | Finance
Greenberg | 100 | Finance
King | 90 | Executive
De Haan | 90 | Executive
Kochhar | 90 | Executive
Russell | 80 | Sales
McEwen | 80 | Sales
! ! !
(107 rows)
21
L - L5 - L -
Usando la clusula RIGHT OUTER JOIN
SELECT e.last_name, e.department_id, d.department_name
FROM employees e
RIGHT OUTER JOIN departments d
ON e.department_id = d.department_id
ORDER BY d.department_id DESC;
last_name | department_id | department_name
-------------+---------------+----------------------
| | Payroll
| | Recruiting
| | Retail Sales
| | Government Sales
| | IT Helpdesk
| | NOC
| | IT Support
| | Operations
! ! !
| | Shareholder Services
| | Control And Credit
| | Corporate Tax
| | Treasury
Higgins | 110 | Accounting
Gietz | 110 | Accounting
(122 rows)
22
L - L5 - L -
Usando la clusula FULL OUTER JOIN
SELECT e.last_name, e.department_id, d.department_name
FROM employees e
FULL OUTER JOIN departments d
ON e.department_id = d.department_id
ORDER BY d.department_id DESC;
last_name | department_id | department_name
-------------+---------------+----------------------
Grant | |
| | Payroll
| | Recruiting
| | Retail Sales
| | Government Sales
| | IT Helpdesk
| | NOC
| | IT Support
! ! !
| | Shareholder Services
| | Control And Credit
| | Corporate Tax
| | Treasury
Higgins | 110 | Accounting
Gietz | 110 | Accounting
(123 rows)
23
L - L5 - L -
Producto Cartesiano
El producto cartesiano se forma cuando:
Se omite una condicin en el JOIN.
La condicin del JOIN es invalida.
Todos los registros de la primera tabla se relacionan
con todos los registros de la segunda tabla.
Se utiliza la clusula CROSS JOIN.
Para evitar un producto cartesiano, siempre debe incluir
una condicin valida dentro del JOIN.
24
L - L5 - L -
Generando el producto cartesiano
department_name | department_id
----------------------+---------------
Administration | 10
Marketing | 20
Purchasing | 30
Human Resources | 40
Shipping | 50
IT | 60
Public Relations | 70
Sales | 80
! ! !
(27 rows)
department_id | last_name
---------------+-------------
| Grant
110 | Gietz
110 | Higgins
100 | Urman
100 | Faviet
100 | Chen
100 | Sciarra
100 | Popp
! ! !
(107 rows)
DEPARTMENTS EMPLOYEES
Producto cartesiano:
27 x 107 = 2889 registros
employee_id | department_id | department_name
-------------+---------------+----------------------
145 | 10 | Administration
145 | 20 | Marketing
145 | 30 | Purchasing
145 | 40 | Human Resources
145 | 50 | Shipping
145 | 60 | IT
145 | 70 | Public Relations
! ! !
(2889 rows)
25
L - L5 - L -
Usando la clusula CROSS JOIN
SELECT e.employee_id, d.department_id, d.department_name
FROM employees e
CROSS JOIN departments d;
employee_id | department_id | department_name
-------------+---------------+----------------------
145 | 10 | Administration
145 | 20 | Marketing
145 | 30 | Purchasing
145 | 40 | Human Resources
145 | 50 | Shipping
145 | 60 | IT
145 | 70 | Public Relations
145 | 80 | Sales
145 | 90 | Executive
145 | 100 | Finance
! ! !
(106 rows)
26
L - L5 - L -
Resumen
[ INNER ] JOIN
LEFT [ OUTER ] JOIN
RIGHT [ OUTER ] JOIN
FULL [ OUTER ] JOIN
CROSS JOIN
NATURAL JOIN
En esta leccin, usted debi entender como usar la
clusula JOIN para mostrar los datos que provienen de
distintas tablas usando:
27
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
6
Subconsultas
L - L6 - L -
Objetivos
Definir que son Subconsultas.
Describir los diferentes tipos de problemas que se
pueden presentar para resolverlos con subconsultas.
Listar los tipos de subconsultas.
Escribir subconsultas.
Al completar esta leccin usted podr entender los
siguientes puntos:
2
L - L6 - L -
Cuando usar Subconsultas?
3
Consulta Principal
Subconsulta
Quien tiene el salario mas alto que Abels?
Que empleado tiene el salario mas alto
que Abels?
Cual es el salario de Abels?
L - L6 - L -
Que es una Subconulta?
4
Es una consulta que utiliza nicamente la sentencia
SELECT la cual se encuentra embebida dentro de la
consulta principal.
Consulta Principal
Subconsulta
Para extraer un grupo de datos en especficos, los
cuales dependen de una consulta principal.
Se puede utilizar en cualquier parte de una consulta.
L - L6 - L -
Sintaxis Bsica
Primero se ejecuta la Subconsulta y luego la consulta
principal.
La Subconsulta arroja un resultado, el cual ser utilizado
para la consulta principal.
5
SELECT column
FROM from_item
WHERE condition (SELECT column
FROM from_item
WHERE condition);
last_name
-----------
Russell
Partners
Errazuriz
Ozer
Kochhar
De Haan
Greenberg
Hartstein
Higgins
King
(10 rows)
L - L6 - L -
Usando la Subconsulta
6
SELECT last_name
FROM employees
WHERE salary > (SELECT salary
FROM employees
WHERE last_name ILIKE 'Abel');
salary
--------
11000
(1 row)
L - L6 - L -
Consideraciones para usar Subconsultas
Encerrar la Subconsulta dentro de los parntesis.
Escriba la Subconsulta del lado derecho de la condicin.
No usar la clusula ORDER BY dentro de la
Subconsulta, esta no ser necesario y compromete el
rendimiento de la misma.
Utilice los operadores adecuados para las Subconsultas
que arrojan uno o mltiples registro.
7
L - L6 - L -
Tipos de Subconsultas
Por un solo registro:
Por mltiples registros:
8
Consulta Principal
Subconsulta
Retorna
ST_CLERK
Consulta Principal
Subconsulta
Retorna ST_CLERK
SA_MAN
L - L6 - L -
Por un solo registro
Retorna un solo valor.
Se utilizan los siguientes operadores de comparacin:
9
Operador Significado
= Igual
> Mayor que
<
Menor que
>= Mayor e igual que
<= Menor e igual que
<> Diferente
L - L6 - L -
Cmo retornar un solo valor?
10
SELECT last_name, job_id, salary
FROM employees
WHERE job_id = (SELECT job_id
FROM employees
WHERE employee_id = 141)
AND salary > (SELECT salary
FROM employees
WHERE employee_id = 143);
job_id
----------
ST_CLERK
(1 row)
salary
--------
2600
(1 row)
last_name | job_id | salary
-------------+----------+--------
Nayer | ST_CLERK | 3200
Mikkilineni | ST_CLERK | 2700
Bissot | ST_CLERK | 3300
Atkinson | ST_CLERK | 2800
Mallin | ST_CLERK | 3300
Rogers | ST_CLERK | 2900
! ! !
(11 rows)
L - L6 - L -
Usando las funciones de grupo
11
last_name | job_id | salary
-----------+----------+--------
Olson | ST_CLERK | 2100
(1 row)
SELECT last_name, job_id, salary
FROM employees
WHERE salary = (SELECT MIN(salary)
FROM employees);
min
------
2100
(1 row)
L - L6 - L -
Usando la clusula HAVING
12
department_id | min
---------------+-------
| 7000
30 | 2500
110 | 8300
60 | 4200
90 | 17000
10 | 4400
40 | 6500
70 | 10000
! ! !
(11 rows)
SELECT department_id, MIN(salary)
FROM employees
GROUP BY department_id
HAVING MIN(salary) > (SELECT MIN(salary)
FROM employees
WHERE department_id = 50);
min
------
2100
(1 row)
L - L6 - L -
Errores que se cometen, ejemplo #1
13
SELECT employee_id, last_name
FROM employees
WHERE salary = (SELECT MIN(salary)
FROM employees
GROUP BY department_id);
min
-------
7000
2500
8300
4200
17000
4400
6500
10000
! ! !
(12 rows)
ERROR: more than one row returned by a
subquery used as an expression
L - L6 - L -
Errores que se cometen, ejemplo #2
14
SELECT last_name, job_id
FROM employees
WHERE job_id = (SELECT job_id
FROM employees
WHERE last_name = 'Haas');
last_name | job_id
-----------+--------
(0 rows)
job_id
--------
(0 rows)
L - L6 - L -
Mltiples registros
Se retorna mas de un registro.
Se utilizan operadores de comparacin para mltiples
registros.
Se puede utilizar el operador NOT en cualquiera de los
siguientes operadores de comparacin.
15
Operador Significado
IN Compara si uno o mas de los elementos
retornados por la subconsulta coinciden con
los de la lista de la consulta principal.
ANY Compara el valor de la consulta por
cualquiera de los valores que son retornados
por la subconsulta.
ALL Compara el valor de la consulta con todos los
valores que retorna la subconsulta.
L - L6 - L -
Usando el operador ANY
16
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE salary < ANY (SELECT salary
FROM employees
WHERE job_id = 'IT_PROG')
AND job_id <> 'IT_PROG';
salary
--------
9000
6000
4800
4800
4200
(5 rows)
employee_id | last_name | job_id | salary
-------------+-------------+------------+--------
153 | Olsen | SA_REP | 8000
154 | Cambrault | SA_REP | 7500
155 | Tuvault | SA_REP | 7000
159 | Smith | SA_REP | 8000
160 | Doran | SA_REP | 7500
161 | Sewall | SA_REP | 7000
164 | Marvins | SA_REP | 7200
165 | Lee | SA_REP | 6800
166 | Ande | SA_REP | 6400
! ! !
(76 rows)
L - L6 - L -
Usando el operador ALL
17
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE salary < ALL (SELECT salary
FROM employees
WHERE job_id = 'IT_PROG')
AND job_id <> 'IT_PROG';
salary
--------
9000
6000
4800
4800
4200
(5 rows)
employee_id | last_name | job_id | salary
-------------+-------------+----------+--------
115 | Khoo | PU_CLERK | 3100
116 | Baida | PU_CLERK | 2900
117 | Tobias | PU_CLERK | 2800
118 | Himuro | PU_CLERK | 2600
119 | Colmenares | PU_CLERK | 2500
125 | Nayer | ST_CLERK | 3200
126 | Mikkilineni | ST_CLERK | 2700
127 | Landry | ST_CLERK | 2400
128 | Markle | ST_CLERK | 2200
! ! !
(44 rows)
L - L6 - L -
Valores NULL en las Subconsultas
18
SELECT emp.last_name
FROM employees emp
WHERE emp.employee_id NOT IN(SELECT mgr.manager_id
FROM employees mgr);
last_name
-----------
(0 rows)
manager_id
------------
100
100
100
100
100
145
145
145
145
! ! !
(1 row)
L - L6 - L -
Resumen
Identificar cuando se necesita resolver un determinado
problema utilizando la Subconsulta.
Escribir Subconsultas dentro de una consulta base
cuando se desconocen ciertos valores.
19
En esta leccin, usted debi entender como:
Seccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
7
Usando los operadores
de conjunto
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Objetivos
Describir cuales son los diversos tipos de operadores de
conjunto.
Como usar los operadores de conjunto en mltiples
consultas.
Controlar el orden de como son retornados los registros
2
L - L -
Consideraciones de los operadores
La lgica de estos tipos de operadores nace de la teora
de conjuntos.
Permite unir dos o mas consultas en una sola.
Cada consulta debe retornar la misma cantidad de
columnas y del mismo tipo de dato.
No importa si el nombre de las columna son diferentes,
siempre se muestran los nombres de la primera
consulta..
No importa la cantidad de registros retornados.
Puede utilizar la clusula ORDER BY o LIMIT, al final de
la ultima consulta, esto afecta a todo el resultado.
3
L - L -
Cuando se usan los operadores?
Reportes donde se requiere complementar los datos
mediante totales, estos pueden estar divididos por
grupos.
Construir un reporte que consolide un solo resultado
desde diversas fuentes.
4
L - L -
Tipos de operadores de conjuntos
5
A B A B A B B A
UNION UNION ALL INTERSECT EXCEPT
Une distintas
consultas, no
muestra los
registros
duplicados.
Une distintas
consultas, si
muestra los
registros
duplicados.
Une distintas
consultas, retorna
nicamente los
registros que son
duplicados.
Une distintas
consultas, y solo
muestra los
registros de A y
no los de B.
L - L -
employee_id | job_id
-------------+------------
100 | AD_PRES
101 | AC_ACCOUNT
101 | AC_MGR
101 | AD_VP
102 | AD_VP
! ! !
(105 rows)
SELECT employee_id, job_id
FROM employees
UNION
SELECT employee_id, job_id
FROM job_history;
Lista los cdigos de cada empleado, con su cargo
actual y su historio.
Usando el operador UNION
6
L - L -
employee_id | job_id | department_id
-------------+------------+---------------
! ! !
200 | AC_ACCOUNT | 90
200 | AD_ASST | 10
200 | AD_ASST | 90
201 | MK_REP | 20
! ! !
(117 rows)
SELECT employee_id, job_id, department_id
FROM employees
UNION ALL
SELECT employee_id, job_id, department_id
FROM job_history
ORDER BY employee_id;
Lista los cdigos de cada empleado, con su cargo
actual y su historio, sin importar que se repitan.
Usando el operador UNION ALL
7
L - L -
employee_id | job_id
-------------+---------
176 | SA_REP
200 | AD_ASST
(2 rows)
SELECT employee_id, job_id
FROM employees
INTERSECT
SELECT employee_id, job_id
FROM job_history
Lista los cdigos de cada empleado, con su cargo
actual y su historio, siempre y cuando se repitan.
Usando el operador INTERSECT
8
L - L -
employee_id | job_id
-------------+------------
! ! !
199 | SH_CLERK
201 | MK_MAN
202 | MK_REP
203 | HR_REP
! ! !
(105 rows)
SELECT employee_id, job_id
FROM employees
EXCEPT
SELECT employee_id, job_id
FROM job_history;
Lista los cdigos de cada empleado, con su cargo
actual y su historio, siempre y cuando no existan en la
segunda consulta.
Usando el operador EXCEPT
9
L - L -
Manejo de columnas no existentes
10
Puede remplazar el nombre de una columna por un valor
por defecto.
Los valores sern colocados en la consulta que no tiene
la columna a mostrar.
Estos valores deben ser del tipo de dato a la columna
que hacemos referencia, como por ejemplo:
- Utilizamos null como un valor genrico, el valor 0 u
otro tipo de literales.
L - L -
department_id | hire_date | ?column?
---------------+------------+----------
10 | 1987-09-17 |
10 | | 1700
20 | 1996-02-17 |
20 | 1997-08-17 |
20 | | 1800
30 | 1994-12-07 |
! ! !
(100 rows)
SELECT department_id, hire_date, null
FROM employees
UNION
SELECT department_id, null, location_id
FROM departments
LIMIT 100;
Utilizando el valor null
11
L - L -
employee_id | job_id | salary
-------------+------------+--------
100 | AD_PRES | 24000
101 | AC_ACCOUNT | 0
101 | AC_MGR | 0
101 | AD_VP | 17000
102 | AD_VP | 17000
102 | IT_PROG | 0
103 | IT_PROG | 9000
! ! !
(130 rows)
SELECT employee_id, job_id, salary
FROM employees
UNION
SELECT employee_id, job_id, 0
FROM job_history;
Utilizando valores por defecto
12
L - L -
En esta leccin, usted debi entender como:
Resumen
13
Usar el operador UNION para retornar diferentes
registros.
Usar el operador UNION ALL para retornar todos los
registros incluyendo los duplicados.
Usar el operador INTERSECT para retornar todos los
registros comunes.
Usar el operador EXCEPT para retornar todos los
registros que son diferentes en la primera consulta, y
estos no se encuentran en la segunda consulta.
Ordenar los registros con la clusula ORDER BY o definir
un mximo con la clusula LIMIT.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
8
Manipulando Datos
y Transacciones
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Objetivos
Describir cada uno de los lenguajes de manipulacin de
datos (DML, Data Manipulation Lenguage).
Introducir nuevos registros dentro de una tabla.
Actualizar registros dentro de una tabla.
Eliminar registros dentro de una tabla.
Control de transacciones.
2
L - L -
Lenguaje de Manipulacin de Datos
Las sentencias DML son ejecutadas cuando:
Introducir nuevos registros dentro de una tabla.
Actualizar registros dentro de una tabla.
Eliminar registros dentro de una tabla.
El control de transacciones consiste en una coleccin de
sentencias DML que permiten manejar el flujo de los
datos cuando son manipulados.
3
L - L -
Agregando un nuevo registro
department_id | department_name | manager_id | location_id
---------------+----------------------+------------+-------------
10 | Administration | 200 | 1700
20 | Marketing | 201 | 1800
30 | Purchasing | 114 | 1700
40 | Human Resources | 203 | 2400
50 | Shipping | 121 | 1500
60 | IT | 103 | 1400
80 | Sales | 145 | 2500
90 | Executive | 100 | 1700
100 | Finance | 108 | 1700
! ! !
(27 rows)
DEPARTMENTS
department_id | department_name | manager_id | location_id
---------------+----------------------+------------+-------------
10 | Administration | 200 | 1700
20 | Marketing | 201 | 1800
30 | Purchasing | 114 | 1700
40 | Human Resources | 203 | 2400
50 | Shipping | 121 | 1500
60 | IT | 103 | 1400
70 | Public Relations | 204 | 2700
80 | Sales | 145 | 2500
90 | Executive | 100 | 1700
100 | Finance | 108 | 1700
! ! !
(27 rows)
DEPARTMENTS
70 | Public Relations | 204 | 2700
Nuevo Registro
4
L - L -
INSERT INTO table [ ( column [, ...] ) ]
VALUES ( expression [, ...]);
Usando la sentencia INSERT
Agrega un nuevo registro dentro de una tabla utilizando
la sentencia INSERT.
Con esta sentencia, solo podr insertar un registro a la
vez.
5
L - L -
Consideraciones al insertar
Insertar nuevos registros que contengan datos por cada
columna.
La lista de valores debe estar ordenada por el orden de
las columnas de la tabla.
Es opcional listar las columnas en la sentencia INSERT.
Encerrar dentro de comillas simples los caracteres y las
fechas.
En caso de que se omite un valor o se agrega la palabra
null, se agregara por defecto un valor que se encuentra
especificado en la tabla.
6
L - L -
INSERT INTO departments (department_id, department_name,
manager_id, location_id)
VALUES (70, 'Public Relations', 100, 1700);
INSERT 0 1
Insertando un nuevo registro
7
No se puede definir un Alias a las tablas.
Puede deshacer los cambios de esta sentencia mediante
el uso de transacciones.
L - L -

Mtodo implcito: Omite el nombre de la columna en la


lista.
INSERT INTO departments (department_id, department_name)
VALUES (70, 'Public Relations');
INSERT 0 1
INSERT INTO departments
VALUES (70, 'Public Relations', NULL, NULL);
INSERT 0 1

Mtodo explcito: Se indica la palabra NULL en la lista de


valores.
Insertando un registro con valores NULL
8
L - L -
INSERT INTO employees (employee_id, first_name, last_name,
email, phone_number, hire_date,
job_id, salary, commission_pct,
manager_id, department_id)
VALUES (113, 'Louis', 'Popp', 'LPOPP',
'515.123.4567', current_date,
'AC_ACCOUNT', 6900, NULL, 205, 100);
INSERT 0 1
La funcin current_date obtiene la fecha del sistema.
Insertando valores especiales
9
L - L -
INSERT INTO employees
VALUES (113,
'Louis',
'Popp',
'LPOPP',
'515.123.4567',
TO_DATE('FEB 3, 1999', 'MON, MM YYYY'),
'AC_ACCOUNT',
6900,
NULL,
205,
100);
INSERT 0 1
Agregando un nuevo empleado.
Insertando valores en especficos
10
L - L -
INSERT INTO sales_reps (id, name, salary, commission_pct)
SELECT employee_id, last_name, salary, commission_pct
FROM employees
WHERE job_id LIKE '%REP%';
INSERT 0 4
Copiando registros desde otra tabla
Escribir la sentencia INSERT con una subconsulta.
No requiere el uso de la clusula VALUES.
Debe coincidir el nmero de columnas de la tabla que se
encuentra definida en la sentencia INSERT con las que
retorna la subconsulta.
11
L - L -
Entendiendo la salida
INSERT INTO departments
VALUES (70, 'Public Relations', NULL, NULL);
INSERT 0 1
Al ejecutar sentencias DML se retorna informacin
sobre los registros.
oid: Es el Object ID (oid) que hace referencia al objeto
que es afectado, por defecto es 0 y solo se aplica en el
sentencia INSERT.
count: Hace referencia a la cantidad de registros que
son afectados dependiendo de la sentencia utilizada.
INSERT oid count
12
L - L -
Modificando valores
employee_id | last_name | hire_date | job_id | salary | department_id
-------------+-------------+------------+------------+--------+---------------
145 | Russell | 1996-10-01 | SA_MAN | 14000 | 80
146 | Partners | 1997-01-05 | SA_MAN | 13500 | 80
! ! !
103 | Hunold | 1990-01-03 | IT_PROG | 9000 | 60
104 | Ernst | 1991-05-21 | IT_PROG | 6000 | 60
105 | Austin | 1997-06-25 | IT_PROG | 4800 | 60
106 | Pataballa | 1998-02-05 | IT_PROG | 4800 | 60
107 | Lorentz | 1999-02-07 | IT_PROG | 4200 | 60
! ! !
(107 rows)
employee_id | last_name | hire_date | job_id | salary | department_id
-------------+-------------+------------+------------+--------+---------------
145 | Russell | 1996-10-01 | SA_MAN | 14000 | 80
146 | Partners | 1997-01-05 | SA_MAN | 13500 | 80
! ! !
103 | Hunold | 1990-01-03 | IT_PROG | 9000 | 30
104 | Ernst | 1991-05-21 | IT_PROG | 6000 | 30
105 | Austin | 1997-06-25 | IT_PROG | 4800 | 30
106 | Pataballa | 1998-02-05 | IT_PROG | 4800 | 30
107 | Lorentz | 1999-02-07 | IT_PROG | 4200 | 30
! ! !
(107 rows)
13
EMPLOYEES
Se actualizaron los siguientes registros:
L - L -
UPDATE table
SET column = expression [,...]
[WHERE condition];
Usando la sentencia UPDATE
14
Modifica un registro existente utilizando la sentencia
UPDATE.
Puede modificar mas de un registro al mismo tiempo.
Puede especificar cuales son las columnas que sern
modificadas.
Puede deshacer los cambios de esta sentencia mediante
el uso de transacciones. No se puede definir un Alias a
las tablas.
L - L -
UPDATE employees
SET department_id = 70
WHERE employee_id = 113;
UPDATE 1

Modificando uno o varios registros mediante una condicin


establecida en la clusula WHERE.
UPDATE employees
SET department_id = 110;
UPDATE 107

Todos los registros son modificados en una tabla si se


omite el uso de la clusula WHERE.
Modificando un registro
15
L - L -
UPDATE employees
SET job_id = (SELECT job_id
FROM employees
WHERE employee_id = 205),
salary = (SELECT salary
FROM employees
WHERE employee_id = 205)
WHERE employee_id = 114;
UPDATE 1
Modificando los datos del job_id y el salary del
empleado cuyo cdigo es 114, obteniendo los datos a
modificar del empleado cuyo cdigo es 205.
Modificando con subconsultas
16
L - L -
UPDATE copy_employees
SET job_id = (SELECT job_id
FROM employees
WHERE employee_id = 205),
salary = (SELECT salary
FROM employees
WHERE employee_id = 205)
WHERE employee_id = 114;
UPDATE 1
Use una subconsultas para determinar una serie de
valores que permitan modificar el registro dentro de
una tabla mediante la la sentencia UPDATE.
Modificando con subconsultas
17
L - L -
Eliminando un registro
18
department_id | department_name | manager_id | location_id
---------------+----------------------+------------+-------------
10 | Administration | 200 | 1700
20 | Marketing | 201 | 1800
30 | Purchasing | 114 | 1700
40 | Human Resources | 203 | 2400
50 | Shipping | 121 | 1500
60 | IT | 103 | 1400
70 | Public Relations | 204 | 2700
80 | Sales | 145 | 2500
90 | Executive | 100 | 1700
100 | Finance | 108 | 1700
! ! !
(107 rows)
department_id | department_name | manager_id | location_id
---------------+----------------------+------------+-------------
10 | Administration | 200 | 1700
20 | Marketing | 201 | 1800
30 | Purchasing | 114 | 1700
40 | Human Resources | 203 | 2400
50 | Shipping | 121 | 1500
60 | IT | 103 | 1400
70 | Public Relations | 204 | 2700
80 | Sales | 145 | 2500
90 | Executive | 100 | 1700
110 | Accounting | 205 | 1700
! ! !
(106 rows)
EMPLOYEES
Se elimino un registro de la tabla:
L - L -
DELETE FROM table
WHERE condition;
Usando la sentencia DELETE
19
Eliminar un registro existente utilizando la sentencia
DELETE.
Puede eliminar mas de un registro al mismo tiempo.
No se puede definir un Alias a las tablas.
Puede deshacer los cambios de esta sentencia mediante
el uso de transacciones.
L - L -
DELETE FROM departments
WHERE department_name = 'Finance';
DELETE 1

Especifique el registro a eliminar mediante un criterio


establecido en la clusula WHERE.
DELETE FROM copy_employees;
DELETE 68;

Eliminar todos los registros de una tabla sin usar la


clusula WHERE.
Eliminando un registro
20
L - L -
DELETE FROM employees
WHERE department_id = (SELECT department_id
FROM departments
WHERE department_name
ILIKE '%Public%');
DELETE 1
Use una subconsulta para determinar una serie de
valores que permitan eliminar registros dentro de una
tabla mediante la sentencia DELETE.
Eliminando con subconsultas
21
L - L -
Sentencia TRUNCATE
22
Elimina todos los registros dentro de una tabla.
Es mas eficiente para las tablas con gran cantidad de
registros que la clusula DELETE.
Solamente puede ser ejecutada por el usuario dueo
(owner) de la tabla.
Puede deshacer los cambios de esta sentencia mediante
el uso de transacciones.
Sintaxis:
Ejemplo:
TRUNCATE [TABLE] name [,...];
TRUNCATE copy_employees;
L - L -
Todo sistema gestor de Bases de Datos maneja los
siguientes conceptos sobre las transacciones:
Transacciones
Son un conjunto de acciones que altera el estado original
de los datos y forman una sola unidad.
Todo lenguaje que manipula los datos (DML) son
administrador por las transacciones.
Las transacciones pueden interrumpir un conjunto de
acciones o hacerlas permanentes.
Mantiene la integridad de los datos cuando alguna
accin falla.
23
L - L -
Los siguientes comandos son utilizados para tener
control de las transacciones:
Comandos utilizados
BEGIN
COMMIT
ROLLBACK
SAVEPOINT
ROLLBACK TO
RELEASE SAVEPOINT
24
L - L -
Usando el comando BEGIN y COMMIT
25
Linea de tiempo
BEGIN;
INSERT INTO...
UPDATE...
UPDATE...
DELETE...
COMMIT;

Se inicia un conjunto de
transacciones mediante el
comando BEGIN;

Luego se pr ocede a
utilizar cualquier comando
de tipo DML (INSERT,
UPDATE y/o DELETE) para
manipular los datos.

Por ultimo, se finaliza las


transacciones haciendo los
cambios permanentes con
el comando COMMIT;.
L - L -
HR=# BEGIN;
BEGIN
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 1700
(1 row)
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 270;
UPDATE 1
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
(1 row)
HR=# COMMIT;
COMMIT
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
(1 row)
HR=#
Ejemplo del comando BEGIN y COMMIT
26
L - L -
Usando el comando ROLLBACK
27
Linea de tiempo
BEGIN;
UPDATE...
UPDATE...
UPDATE...
ROLLBACK;
La ultima actualizacin que se
realizo a generado un error
inesperado o un resultado no
deseado, para deshacer
todos los cambios se utiliza el
comando ROLLBACK.
ERROR...
L - L -
HR=# BEGIN;
BEGIN
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 1700
(1 row)
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 270;
UPDATE 1
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
(1 row)
HR=# ROLLBACK;
ROLLBACK
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 1700
(1 row)
HR=# COMMIT;
Ejemplo del comando ROLLBACK
28
L - L -
Usando el comando SAVEPOINT
29
Linea de tiempo
BEGIN;
UPDATE...
UPDATE...
ROLLBACK TO A;
La ultima actualizacin que se
realizo a generado un error
inesperado o un resultado no
deseado, para deshacer
todos los cambios hasta el
punto de control A se utiliza el
comando ROLLBACK TO.
ERROR...
SAVEPOINT A;
L - L -
HR=# BEGIN;
BEGIN
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 1700
(1 row)
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 270;
UPDATE 1
HR=# SAVEPOINT A;
SAVEPOINT
HR=# SELECT * FROM departments WHERE department_id = 270;
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
(1 row)
HR=# UPDATE departments SET location_id = 1000 WHERE department_id = 270;
UPDATE 1
HR=# ROLLBACK TO A;
ROLLBACK
HR=# COMMIT;
COMMIT
Ejemplo del comando SAVEPOINT
30
SAVEPOINT B;
L - L -
Usando el comando RELEASE SAVEPOINT
31
Linea de tiempo
BEGIN;
UPDATE...
UPDATE...
RELEASE SAVEPOINT B;
Se determino que el
punto de control B ya no
es utilizado, todos los
datos afectados de dicho
punto pasaran a ser del
punto de control A, para
realizar este cambio se
ut i l i z a el c omando
RELEASE SAVEPOINT.
SAVEPOINT A;
UPDATE...
COMMIT;
L - L -
HR=# BEGIN;
BEGIN
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 270;
UPDATE 1
HR=# SAVEPOINT A;
SAVEPOINT
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 260;
UPDATE 1
HR=# SAVEPOINT B;
SAVEPOINT
HR=# UPDATE departments SET location_id = 2500 WHERE department_id = 250;
UPDATE 1
HR=# SELECT * FROM departments WHERE department_id IN (270, 260, 250);
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
260 | Recruiting | | 2500
250 | Retail Sales | | 2500
(3 rows)
HR=# RELEASE SAVEPOINT B;
RELEASE
HR=# ROLLBACK TO A;
ROLLBACK
department_id | department_name | manager_id | location_id
---------------+-----------------+------------+-------------
270 | Payroll | | 2500
260 | Recruiting | | 1700
250 | Retail Sales | | 1700
(3 rows)
HR=# COMMIT;
COMMIT
Ejemplo del comando SAVEPOINT
32
L - L -
En esta leccin, usted debi entender como:
Resumen
33
Utilizar los comandos DML que permiten insertar o
alterar los datos.
Eliminar el contenido de una tabla.
Manejo de las transacciones.
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
9
Tablas
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Objetivos
Conocer la estructura de una tabla.
Listar los diversos tipos de datos.
Entender como funcionan las restricciones de los datos.
Mantener la integridad de los datos con las relaciones
entre tablas.
Mejorar el tiempo de acceso a los datos mediante los
Indices.
2
L - L -
Las Tablas
Es un objeto que contiene datos de forma permanente.
Cada tabla es una entidad que agrupa conceptualmente
una serie de datos en comn y estos se encuentran
segmentados en varias columnas.
Cada tabla tiene reglas que definen una serie de
restricciones para evitar redundancia y mantener la
integridad de los mismos.
Las tablas dependen entre ellas para mantener la
relacin de los datos.
3
L - L -
Los nombres de las tablas y las columnas deben
respetar las siguientes reglas:
Definir nombres
Deben empezar con letras.
Debe tener entre 1 y 63 caracteres.
Solamente se permiten los siguientes caracteres;
0-9, a-z, A-Z, _ y $.
No se permiten nombres duplicados, solo en Case
Sensitive.
Para mantener nombres en Case Sensitive debe
colocarlos entre comillas dobles.
4
L - L -
CREATE TABLE table_name ([
column_name data_type [ DEFAULT expr ], ...
]);
Considere lo siguiente:
Usando la clusula CREATE TABLE
5
Debe tener privilegios para crear tablas.
Espacio en disco.
Nombre de la tabla.
Nombre de las columnas, tipo de dato a utilizar y su
longitud.
L - L -
Tipo de Datos para nmeros
6
Nombre Tamao Rango
smallint 2 bytes -32768 hasta +32767
integer 4 bytes -2147483648 hasta +2147483647
bigint 8 bytes -9223372036854775808 hasta 9223372036854775807
decimal variable No existe limite, definir la expresin exacta.
numeric variable No existe limite, definir la expresin exacta.
real 4 bytes 6 decimales
double precision 8 bytes 15 decimales
serial 4 bytes 1 hasta 2147483647
bigserial 8 bytes 1 hasta 9223372036854775807
L - L -
Tipo de Datos para carcteres
7
Nombre Descripcin Ejemplo Resultado
character(l) Se define la longitud de
caracteres (l), completa con
espacios en blanco.
character(2)
VE
character varing(l) Se define la longitud de
caracteres (l), no completa
con espacios en blanco.
character
varing(10)
Caracas
text De longitud ilimitada. text abcdefghijk
lmnu...
L - L -
Tipo de Datos para fechas
8
Nombre Tamao Descripcin Min. Max.
timestamp 8 bytes Fecha y hora, permite
la zona horaria.
4713 AC 5874987 DC
interval 12 bytes Intervalo de tiempo,
contempla cualquier
unidad.
-178000000 aos 178000000 aos
date 4 bytes Solo fecha. 4713 AC 5874987 DC
time 8-12 bytes Solo hora, permite la
zona horaria.
00:00:00+1359 24:00:00-1359
L - L -
CREATE TABLE films (
code char(5),
title varchar(40),
summary text,
);

Crear una tabla:


HR=# \d films
Table "public.films"
Column | Type | Modifiers
-----------+-----------------------+-----------
code | character(5) |
title | character varying(40) |
summary | text |
HR=#

Visualizar la estructura de la tabla desde psql:


Crear tablas
9
L - L -
Valores por defecto
10
CREATE TABLE products (
pk_product integer NOT NULL,
name text NOT NULL,
summary text,
price numeric NOT NULL,
discounted numeric DEFAULT 0 NOT NULL,
company integer NOT NULL
);
Agregar valores por defecto cuando son omitidos en su
insercin.
L - L -
Consultas de Ejemplo
11
HR=# INSERT INTO products (pk_product, name, price, company)
HR-# VALUES (1, 'DVD', 12, 1);
INSERT 0 1
HR=# SELECT * FROM products;
pk_product | name | summary | price | discounted | company
------------+------+---------+-------+------------+---------
1 | DVD | | 12 | 0 | 1
Insertamos un nuevo registro omitiendo las columnas
summary y discounted, observando el valor 0 por defecto
que es incorporado de forma automtica.
L - L -
Restricciones
12
Define reglas dentro de una tabla o en columnas.
Evita eliminar datos dentro de una tabla que tiene
dependencias.
Se pueden aplicar mientras crea una tabla o despus.
Existen los siguientes tipos de restricciones:
NOT NULL
UNIQUE
PRIMARY KEY
FORAIGN KEY
CHECK
L - L -
Evita que una columna en especifico contenga valores de
tipo NULL, en caso de que esta no contenga la restriccin,
se permite la insercin del valor NULL.
CREATE TABLE films (
code char(5) NOT NULL,
title varchar(40) NOT NULL,
summary text
);
Restriccin NOT NULL
13
L - L -
Restringe un grupo de columnas donde se requieren que
sus valores siempre sean nicos, evitando que existan
valores duplicados en dichas columnas.
CREATE TABLE films (
code char(5) NOT NULL,
title varchar(40) NOT NULL,
summary text,
CONSTRAINT un_film UNIQUE (code, title)
);
Restriccin UNIQUE
14
L - L -
Restriccin PRIMARY KEY
15
Define una o mas columnas como clave primaria de la
tabla, haciendo sta nica y permitir la relacin de un
registro con otra tabla para crear la dependencia.
CREATE TABLE films (
code char(5) NOT NULL,
title varchar(40) NOT NULL,
summary text,
CONSTRAINT pk_film PRIMARY KEY (code)
);
L - L -
Restriccin FORAING KEY
16
Define una o mas columnas como clave primaria de la
tabla, haciendo sta nica y permitir la relacin de un
registro con otra tabla para crear la dependencia.
CREATE TABLE films (
code char(5) NOT NULL,
title varchar(40) NOT NULL,
summary text,
company integer NOT NULL,
CONSTRAINT fk_company FOREIGN KEY (company)
REFERENCES product (pk_product)
);
L - L -
CREATE TABLE products (
pk_product integer,
name text,
price numeric,
discounted numeric,
CONSTRAINT cn_price CHECK (price > 0 AND
price > discounted)
);
Restriccin CHECK
Define una o varias condiciones que debe satisfacer a cada
uno de los registro existentes de forma boleana.
No se permiten consultas.
Solo se utilizan operadores de condicin y de conjunto.
17
L - L -
Cdigo de Ejemplo
18
CREATE TABLE companies (
pk_company integer NOT NULL,
name text NOT NULL,
CONSTRAINT un_company UNIQUE (name),
CONSTRAINT pk_company PRIMARY KEY (pk_company)
);
CREATE TABLE products (
pk_product integer NOT NULL,
fk_company integer NOT NULL,
name text NOT NULL,
summary text,
price numeric NOT NULL,
discounted numeric DEFAULT 0,
CONSTRAINT un_product UNIQUE (name),
CONSTRAINT ck_product CHECK (discounted > 0 AND price > discounted),
CONSTRAINT pk_product PRIMARY KEY (pk_product),
CONSTRAINT fk_company FOREIGN KEY (fk_company)
REFERENCES companies (pk_company)
);
L - L -
Violando una restriccin
19
No existe el la clave primaria:
HR=# INSERT INTO products (pk_product, fk_company, name, price, discounted)
HR-# VALUES (1, 1, 'DVD', 10, 0.5);
ERROR: insert or update on table "products" violates foreign key constraint
"fk_company"
DETAIL: Key (fk_company)=(1) is not present in table "companies".
HR=#
No existe la clave primaria con el valor 1 en la tabla companies.
L - L -
Violando una restriccin
20
No cumple con una restriccin
HR=# INSERT INTO products (pk_product, fk_company, name, price)
HR-# VALUES (1, 1, 'DVD', 10);
ERROR: new row for relation "products" violates check constraint
"ck_product"
HR=#
Los datos a insertar no cumplen con la restriccin ck_product.
L - L -
HR=# \d products
Table "public.products"
Column | Type | Modifiers
------------+---------+-----------
pk_product | integer | not null
fk_company | integer | not null
name | text | not null
summary | text |
price | numeric | not null
discounted | numeric | default 0
Indexes:
"pk_product" PRIMARY KEY, btree (pk_product)
"un_product" UNIQUE, btree (name)
Check constraints:
"ck_product" CHECK (discounted > 0::numeric AND price > discounted)
Foreign-key constraints:
"fk_company" FOREIGN KEY (fk_company) REFERENCES companies(pk_company)
HR=#
Visualizar la estructura de la tabla para identificar la
restriccin:
Violando una restriccin
21
L - L -
Violando una restriccin
22
No puede actualizar o eliminar un registro por que una
de las claves forneas se encuentra relacionada con
otra tabla.
HR=# DELETE FROM companies WHERE pk_company = 1;
ERROR: update or delete on table "companies" violates foreign key
constraint "fk_company" on table "products"
DETAIL: Key (pk_company)=(1) is still referenced from table "products".
HR=#
La clave fornea de valor 1 se encuentra en uso dentro de
la tabla products.
L - L -
Modifica la estructura fsica de una tabla, contemplando:
Sentencia ALTER TABLE
Columnas.
Tipo de dato sobre una columna.
Valores por defecto.
Restricciones.
Relaciones.
Triggers.
Usuario Dueo.
Permisos.
Comentarios.
23
L - L -
HR=# DROP TABLE products;
DROP TABLE
Eliminar una tabla
24
Toda la data es eliminada.
Toda su estructura se elimina.
Todo tipo de restriccin, relacin, indices y triggers son
eliminados.
No se puede hacer rollback una ves que la tabla se haya
eliminado.
L - L -
Para mejorar el rendimiento levemente de las
consultas, debe tener en cuenta el siguiente criterio
para el orden mientras crea las columnas.
Orden de las culumnas
Clave primarias.
Columnas con la restriccin de tipo nico.
Clave forneas.
Columnas obligatorias.
Columnas no obligatorias.
25
L - L -
Estructura fsica de datos que permiten ubicar un
determinado valor solicitado utilizando un metodo de
acceso.
Indices
Son estructuras que no se encuentran alojadas dentro de
una tabla pero dependen de ella.
Incrementa la velocidad de bsqueda.
Se definen por una o varias columnas en especifico
donde son utilizadas para realizar una bsqueda.
El algoritmo definido por defecto es el B-Trees.
Se pueden ordenar los indices de forma ascendente o
descendente y existe un tratamiento especial para los
valores de tipo NULL.
26
L - L -
Desventajas de los Indices
Consumen ms espacio en disco.
El uso consecutivo de sentencias de tipo INSERT,
UPDATE y/o DELETE disminuyen el rendimiento cuando
existen indices, por lo que se requiere reconstruirlos
peridicamente como una actividad de mantenimiento.
Se utiliza el comando: reindexdb
27
L - L -
Debe crean indices obligatoriamente en las siguientes
columnas, las cuales son utilizadas constantemente:
Uso de los Indices
Claves primarias.
Claves forneas.
Columnas que se utilizan con operadores lgicos.
Campos de bsqueda.
28
L - L -
Existen muchos tipos, por defecto se considera que el
algoritmo B-Trees, es suficiente debido a que puede
manejar perfectamente las condiciones de igualdad.
Algoritmo B-Trees
<
<=
=
>=
>
29
L - L -
Adicionalmente el algoritmo se apoya de parmetros en
su creacin, con el fin de ampliar ms su rendimiento.
Parmetros bsicos
ASC: Ordena de forma ascendente (Por defecto).
DESC: Ordena de forma descendente.
NULL FIRST: Especifica que los valores de tipo NULL estarn de primero
con los valores que no son de tipo NULL, este valor es asignado por
defecto cuando se ordena de forma DESC.
NULL LAST: Especifica que los valores de tipo NULL estarn de ultimo
con los valores que no son de tipo NULL, este valor es asignado por
defecto cuando se ordena de forma ASC.
Unique: El sistema arroja un error al verificar si existen valores
duplicados en la tabla cada vez que el indice es creado o actualizado.
30
L - L -
Sintaxis bsica:
Ejemplo
31
CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
( column [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
[, ...] )
CREATE UNIQUE INDEX title_idx ON films (title);
Ejemplos:
CREATE INDEX title_idx_nulls ON films (title NULLS FIRST);
L - L -
En esta leccin, usted debi entender como:
Resumen
Crear, modificar y eliminar tablas.
Visualizar la estructura de la tabla.
Definir restricciones para el contenido de una tabla.
Establecer la relacin entre una o mas tablas.
Incrementar la velocidad de acceso a los registros
mediante los Indices.
32
Leccin
Este material se encuentra basado en el curso de Fundamentos a SQL de ORACLE, el cual es adaptado para
el producto PostgreSQL, todos los ejemplos, cdigos fuentes y la Base de Datos HR es propiedad de ORACLE.
Autor: Nicola Strappazzon C.
e-mail: nicola51980@gmail.com
Blog: http://www.swapbytes.com/
Revisin: 17/11/11
10
Vistas
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Objetivos
Qu es una Vista?
Cul es su funcin?
Donde sern utilizadas?
Cmo recuperar datos?
2
L - L -
Es una estructura lgica que permite visualizar un
grupo de datos que provienen de una o varias tablas u
otras vistas.
Qu es una Vista?
No contiene datos propios, estos provienen de otras
tablas con datos reales.
No permite la insercin, actualizacin y eliminacin de
datos, solo la lectura.
Su utilizacin es como el de una tabla, podemos usar
cualquier sentencia de tipo SELECT sobre ellas.
Prcticamente es una tabla virtual que proviene de la
instruccin SELECT.
El uso de las vistas ofrece una infinidad de usos.
3
L - L -
Podemos utilizar estas estructuras para realizar las
siguientes tareas:
Usos prcticos
Una o varias vistas pueden conformar una serie de
pantallas del sistema de informacin.
Reportes que no requieren un procesamiento complejo.
4
L - L -
Que nos permite hacer?
Restringen la informacin antes de ser mostrada al
usuario final.
Permite hacer consultas simples para aquellas que son
complejas debido a que provienen de mltiples tablas o
vistas gracias a la utilizacin de los JOIN.
Permite unir datos divididos, desmoralizando un grupo
de tablas.
El cambio de la estructura fsica de la base de datos
altera el resultado final de una consulta, esto se puede
evitar con el uso de las vistas, el cual mantiene la misma
estructura para otros sistemas a pesar que la consulta
cambie internamente.
5
L - L -
Filtran el contenido a mostrar como un nivel mas de
seguridad.
Restricciones
Permite oculta columnas y registros que no son
deseados mediante condiciones.
El uso de permisologas de usuario y de grupos permiten
restringir la informacin a visualizar.
6
L - L -
De los puntos mencionados anteriormente, se puede
apreciar lo siguiente:
Ventajas
Siempre se muestran los datos actualizados.
Simplifica el uso de consultas complejas.
Simplifica la representacin de los datos ofreciendo mas
sentido lgico.
Define un nivel mas de seguridad.
Asla las aplicaciones de la Base de Datos.
Permite mayor flexibilidad.
7
L - L -
De los puntos mencionados anteriormente, se puede
apreciar lo siguiente:
Desventajas
No se pueden utilizar las sentencias INSERT, UPDATE y
DELETE sobre la vista para alterar los datos.
No mejora el rendimiento.
8
L - L -
CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ]
AS query
Sintaxis Bsica
9
Smbolo Significado
OR REPLACE
Permite remplazar la vista actual por
una nueva, sin necesidad de eliminar
y volverla a crear.
L - L -
CREATE VIEW comedies AS
SELECT *
FROM films
WHERE kind = 'Comedy';
La siguiente vista permite visualizar todas las pelculas
que pertenecen al genero de comedia.
Crear una Vista
10
L - L -
CREATE OR REPLACE VIEW comedies AS
SELECT code, title
FROM films
WHERE kind = 'Comedy';
Puede remplazar una consulta contenida dentro de una
vista de la siguiente forma:
Modificar una Vista
11
L - L -
SELECT * FROM comedies;
Use la Vista de la misma forma que una tabla para
recupear los datos.
Recuperar los datos
12
L - L -
DROP VIEW comedies;
Utilice el siguiente comando para eliminar una Vista.
Eliminar una Vista
13
L - L -
Al completar esta leccin usted podr entender los
siguientes puntos:
Resumen
14
Conocer el propsito de las Vistas.
Crear, modificar y eliminar Vistas.
Implementar las vistas dentro de una consulta.

S-ar putea să vă placă și