Structured Query Language

La sigla que se conoce como SQL corresponde a la expresión inglesa Structured

Query Language (entendida en español como Lenguaje de Consulta Estructurado), la
cual identifica a un tipo de lenguaje vinculado con la gestión de bases de datos de
carácter relacional que permite la especificación de distintas clases de operaciones
entre éstas. Gracias a la utilización del álgebra y de cálculos relacionales, el SQL
brinda la posibilidad de realizar consultas con el objetivo de recuperar información de
las bases de datos de manera sencilla.

En esencia, el SQL es un lenguaje declarativo de alto nivel ya que, al manejar

conjuntos de registros y no registros individuales, ofrece una elevada productividad en
la codificación y en la orientación a objetos. Una sentencia de SQL puede resultar
equivalente a más de un programa que emplee un lenguaje de bajo nivel.

Una base de datos implica la coexistencia de múltiples tipos de lenguajes. El

denominado Data Definition Language (también conocido como DDL) es aquél que
permite modificar la estructura de los objetos contemplados por la base de datos por
medio de cuatro operaciones básicas. SQL, por su parte, es un lenguaje que permite
manipular datos (Data Manipulation Language o DML) que contribuye a la gestión de
las bases de datos a través de consultas.

 Lenguaje de definición de datos (DDL)

Las sentencias DDL se utilizan para crear y modificar la estructura de las tablas así
como otros objetos de la base de datos.

 CREATE - para crear objetos en la base de datos.

 ALTER - modifica la estructura de la base de datos.

 DROP - borra objetos de la base de datos.

 TRUNCATE - elimina todos los registros de la tabla, incluyendo todos los

espacios asignados a los registros.

 Lenguaje de manipulación de datos (DML)

Las sentencias de lenguaje de manipulación de datos (DML) son utilizadas para

gestionar datos dentro de los schemas. Algunos ejemplos:

 SELECT - para obtener datos de una base de datos.

 INSERT - para insertar datos a una tabla.

 UPDATE - para modificar datos existentes dentro de una tabla.

 DELETE - elimina todos los registros de la tabla; no borra los espacios

asignados a los registros.

Uno de los puntos básicos a la hora de construir una base de datos es la indexación.
Para entender este concepto, veamos brevemente un ejemplo práctico de base:
supongamos que una compañía desea almacenar la información personal de sus
clientes y hacer un seguimiento de sus transacciones; para ello, una posibilidad
consistiría en tener una tabla para sus datos (nombre, apellido, dirección de e-mail,
etcétera), otra para la descripción de los productos (nombre del artículo, precio,
detalles) y una para las ventas. Antes de pasar a detallar qué campos podrían estar
presentes en esta última tabla, cabe mencionar que en las restantes falta un elemento
indispensable para una buena organización: una clave única de identificación.

Generalmente llamada ID, suele ser un número entero (sin decimales) y positivo que la
base de datos asigna automáticamente a cada nuevo registro (en este caso, cada
nuevo cliente o producto) y que nunca se repite, de modo que lo identifique desde su
nacimiento (momento de creación) hasta su muerte (cuando se elimine). De esta
forma, si tomamos por ejemplo el registro “103 Pablo Bernal pbernal@[Link]”,
notamos que su ID es 103. ¿Cuál es su utilidad? En pocas palabras, buscar un cliente
cuyo nombre sea n, su apellido, a, y su e-mail, e, toma mucho más tiempo que pedir a
la base que nos devuelva todos los datos del cliente con ID “103”. Si bien es probable
que en la primera operación especifiquemos toda su información, una vez que el
programa lo encuentre, podremos valernos de este número para el resto de las
consultas.

Sentencia SELECT

La sentencia SELECT se utiliza para seleccionar datos de una base de datos.

Se guarda el resultado en una tabla llamada "result-set".

Sintaxis de la Sentencia SELECT 1:

SELECT column_name,column_name FROM table_name;

Sintaxis de la Sentencia SELECT 2:

SELECT * FROM table_name;
NOTA: EL asterisco * significa que queremos todas las columnas de la tabla.

Sentencia SQL WHERE

La sentencia WHERE se usa para extraer sólo los registros que cumplan con una
condición. Funciona como un filtro.

Sintaxis de la sentencia SQL WHERE

SELECT column_name,column_name
FROM table_name
WHERE column_name operator value;

Claúsula ORDER BY

La claúsula ORDER BY se utiliza para ordenar los resultados a través de una o más
columnas.

La claúsula ORDER BY ordena los registros de manera ascendente por defecto. Para
hacerlo de manera descendente, se puede utilizar la claúsula DESC.
Sintaxis de la claúsula SQL ORDER BY
SELECT column_name,column_name
FROM table_name
ORDER BY column_name,column_name ASC|DESC;

CREACION DE TABLAS (create - describe - all_tables - drop table)

Existen varios objetos de base de datos: tablas, constraints (restricciones), vistas,

secuencias, índices, agrupamientos (clusters), disparadores (triggers), instantaneas
(snapshots), procedimientos, funciones, paquetes, sinónimos, usuarios, perfiles,
privilegios, roles, etc.

Los primeros objetos que veremos son tablas.

Una base de datos almacena su información en tablas, que es la unidad básica de

almacenamiento.

Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada
columna es un campo (o atributo) y cada fila, un registro. La intersección de una
columna con una fila, contiene un dato específico, un solo valor.

Cada registro contiene un dato por cada columna de la tabla. Cada campo (columna)
debe tener un nombre. El nombre del campo hace referencia a la información que
almacenará.

Cada campo(columna) también debe definir el tipo de dato que almacenará.

Las tablas forman parte de una base de datos.

Para ver las tablas existentes tipeamos:

select *from all_tables;

Aparece una tabla que nos muestra en cada fila, los datos de una tabla específica; en
la columna "TABLE_NAME" aparece el nombre de cada tabla existente.

Al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de
datos almacenarán cada uno de ellos, es decir, su estructura.

 La sintaxis básica y general para crear una tabla es la siguiente:

create table NOMBRETABLA(

NOMBRECAMPO1 TIPODEDATO,

...

NOMBRECAMPON TIPODEDATO

)
La tabla debe ser definida con un nombre que la identifique y con el cual accederemos
a ella.

Creamos una tabla llamada "usuarios" y entre paréntesis definimos los campos y sus
tipos:

create table usuarios(

nombre varchar2(30),

clave varchar2(10)

);

Cada campo con su tipo debe separarse con comas de los siguientes, excepto el
último.

Cuando se crea una tabla debemos indicar su nombre y definir al menos un campo
con su tipo de dato. En esta tabla "usuarios" definimos 2 campos:

- nombre: que contendrá una cadena de caracteres de 30 caracteres de longitud, que

almacenará el nombre de usuario y

- clave: otra cadena de caracteres de 10 de longitud, que guardará la clave de cada

usuario.

Cada usuario ocupará un registro de esta tabla, con su respectivo nombre y clave.

Para nombres de tablas, se puede utilizar cualquier caracter permitido para nombres
de directorios, el primero debe ser un caracter alfabético y no puede contener
espacios. La longitud máxima es de 30 caracteres.

Si intentamos crear una tabla con un nombre ya existente (existe otra tabla con ese
nombre), mostrará un mensaje indicando que a tal nombre ya lo está utilizando otro
objeto y la sentencia no se ejecutará.

Para ver la estructura de una tabla usamos el comando "describe" junto al nombre de
la tabla:

describe usuarios;

Aparece la siguiente información:

Name Null Type

-------------------------------

NOMBRE VARCHAR2(30)

CLAVE VARCHAR2(10)

Esta es la estructura de la tabla "usuarios"; nos muestra cada campo, su tipo y longitud
y otros valores que no analizaremos por el momento.

Para eliminar una tabla usamos "drop table" junto al nombre de la tabla a eliminar:

drop table NOMBRETABLA;

En el siguiente ejemplo eliminamos la tabla "usuarios":

drop table usuarios;

Si intentamos eliminar una tabla que no existe, aparece un mensaje de error indicando
tal situación y la sentencia no se ejecuta.

INGRESAR REGISTROS (insert into- select)

Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada
registro tiene un dato por cada columna (campo). Nuestra tabla "usuarios" consta de 2
campos, "nombre" y "clave".

Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de
los campos.

La sintaxis básica y general es la siguiente:

insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn)

values (VALORCAMPO1, ..., VALORCAMPOn);

Usamos "insert into", luego el nombre de la tabla, detallamos los nombres de los
campos entre paréntesis y separados por comas y luego de la cláusula "values"
colocamos los valores para cada campo, también entre paréntesis y separados por
comas.

En el siguiente ejemplo se agrega un registro a la tabla "usuarios", en el campo

"nombre" se almacenará "Mariano" y en el campo "clave" se guardará "payaso":

insert into usuarios (nombre, clave)

values ('Mariano','payaso');

Luego de cada inserción aparece un mensaje indicando la cantidad de registros

ingresados.

Note que los datos ingresados, como corresponden a cadenas de caracteres se

colocan entre comillas simples.

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

select *from usuarios;

NOTA: Es importante ingresar los valores en el mismo orden en que se nombran los
campos: En el siguiente ejemplo se lista primero el campo "clave" y luego el campo
"nombre" por eso, los valores también se colocan en ese orden:

insert into usuarios (clave, nombre)

 values ('River','Juan');

Si ingresamos los datos en un orden distinto al orden en que se nombraron los

campos, no aparece un mensaje de error y los datos se guardan de modo incorrecto.

En el siguiente ejemplo se colocan los valores en distinto orden en que se nombran los
campos, el valor de la clave (la cadena "Boca") se guardará en el campo "nombre" y el
valor del nombre (la cadena "Luis") en el campo "clave":

insert into usuarios (nombre,clave)

values ('Boca','Luis');

TIPOS DE DATOS

Ya explicamos que al crear una tabla debemos resolver qué campos (columnas)
tendrá y que tipo de datos almacenará cada uno de ellos, es decir, su estructura.

El tipo de dato especifica el tipo de información que puede guardar un campo:

caracteres, números, etc.

Estos son algunos tipos de datos básicos de Oracle (posteriormente veremos otros y
con más detalle):

- varchar2: se emplea para almacenar cadenas de caracteres. Una cadena es una

secuencia de caracteres. Se coloca entre comillas simples; ejemplo: 'Hola', 'Juan
Perez', 'Colon 123'. Este tipo de dato define una cadena de longitud variable en la cual
determinamos el máximo de caracteres entre paréntesis. Puede guardar hasta xxx
caracteres. Por ejemplo, para almacenar cadenas de hasta 30 caracteres, definimos
un campo de tipo varchar2 (30), es decir, entre paréntesis, junto al nombre del campo
colocamos la longitud.

Si intentamos almacenar una cadena de caracteres de mayor longitud que la definida,

la cadena no se carga, aparece un mensaje indicando tal situación y la sentencia no
se ejecuta.

Por ejemplo:

Si definimos un campo de tipo varchar(10) e intentamos almacenar en él la cadena

'Buenas tardes', aparece un mensaje indicando que el valor es demasiado grande para
la columna.

- number(p,s): se usa para guardar valores numéricos con decimales, de 1.0 x10-120 a
9.9...(38 posiciones). Definimos campos de este tipo cuando queremos almacenar
valores numéricos con los cuales luego realizaremos operaciones matemáticas, por
ejemplo, cantidades, precios, etc.

Puede contener números enteros o decimales, positivos o negativos. El parámetro "p"

indica la precisión, es decir, el número de dígitos en total (contando los decimales) que
contendrá el número como máximo. El parámetro "s" especifica la escala, es decir, el
máximo de dígitos decimales. Por ejemplo, un campo definido "number(5,2)" puede
contener cualquier número entre 0.00 y 999.99 (positivo o negativo).
Para especificar número enteros, podemos omitir el parámetro "s" o colocar el valor 0
como parámetro "s". Se utiliza como separador el punto (.).

Si intentamos almacenar un valor mayor fuera del rango permitido al definirlo, tal valor
no se carga, aparece un mensaje indicando tal situación y la sentencia no se ejecuta.

Por ejemplo, si definimos un campo de tipo number(4,2) e intentamos guardar el valor

123.45, aparece un mensaje indicando que el valor es demasiado grande para la
columna. Si ingresamos un valor con más decimales que los definidos, el valor se
carga pero con la cantidad de decimales permitidos, los dígitos sobrantes se omiten.

Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato
adecuado para cada uno de ellos.

Por ejemplo:

Si en un campo almacenaremos números telefónicos o unos números de documento,

usamos "varchar2", no "number" porque si bien son dígitos, con ellos no realizamos
operaciones matemáticas.

Si en un campo guardaremos apellidos, y suponemos que ningún apellido superará los

20 caracteres, definimos el campo "varchar2(20)".

Si en un campo almacenaremos precios con dos decimales que no superarán los

999.99 pesos definimos un campo de tipo "number(5,2)", es decir, 5 dígitos en total,
con 2 decimales.

Si en un campo almacenaremos valores enteros de no más de 3 dígitos, definimos un

campo de tipo "number(3,0)".

RECUPERAR ALGUNOS CAMPOS (select)

Hemos aprendido cómo ver todos los registros de una tabla, empleando la instrucción
"select".

La sintaxis básica y general es la siguiente:

select *from NOMBRETABLA;

El asterisco (*) indica que se seleccionan todos los campos de la tabla.

Podemos especificar el nombre de los campos que queremos ver, separándolos por
comas:

select titulo,autor from libros;

La lista de campos luego del "select" selecciona los datos correspondientes a los
campos nombrados. En el ejemplo anterior seleccionamos los campos "titulo" y "autor"
de la tabla "libros", mostrando todos los registros.

RECUPERAR ALGUNOS REGISTROS (where)

Hemos aprendido a seleccionar algunos campos de una tabla.

También es posible recuperar algunos registros.

Existe una cláusula, "where" con la cual podemos especificar condiciones para una
consulta "select". Es decir, podemos recuperar algunos registros, sólo los que cumplan
con ciertas condiciones indicadas con la cláusula "where". Por ejemplo, queremos ver
el usuario cuyo nombre es "Marcelo", para ello utilizamos "where" y luego de ella, la
condición:

select nombre, clave

from usuarios

where nombre='Marcelo';

La sintaxis básica y general es la siguiente:

select NOMBRECAMPO1, ..., NOMBRECAMPOn

from NOMBRETABLA

where CONDICION;

Para las condiciones se utilizan operadores relacionales (tema que trataremos más
adelante en detalle). El signo igual(=) es un operador relacional. Para la siguiente
selección de registros especificamos una condición que solicita los usuarios cuya clave
es igual a "River":

select nombre,clave

from usuarios

where clave='River';

Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún

registro.

Entonces, con "where" establecemos condiciones para recuperar algunos registros.

Para recuperar algunos campos de algunos registros combinamos en la consulta la

lista de campos y la cláusula "where":

select nombre

from usuarios

where clave='River';

En la consulta anterior solicitamos el nombre de todos los usuarios cuya clave sea
igual a "River".
 OPERADORES RELACIONALES

Los operadores son símbolos que permiten realizar operaciones matemáticas,

concatenar cadenas, hacer comparaciones.

Oracle reconoce de 4 tipos de operadores:

1) relacionales (o de comparación)

2) aritméticos

3) de concatenación

4) lógicos

Por ahora veremos solamente los primeros.

Los operadores relacionales (o de comparación) nos permiten comparar dos

expresiones, que pueden ser variables, valores de campos, etc.

Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de

una tabla; por ejemplo:

select *from libros

where autor='Borges';

Utilizamos el operador relacional de igualdad.

Los operadores relacionales vinculan un campo con un valor para que Oracle compare
cada registro (el campo especificado) con el valor dado.

Los operadores relacionales son los siguientes:

= igual

<> distinto

> mayor

< menor

>= mayor o igual

<= menor o igual

Podemos seleccionar los registros cuyo autor sea diferente de "Borges", para ello
usamos la condición:

select * from libros

 where autor<>'Borges';

Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los títulos y
precios de los libros cuyo precio sea mayor a 20 pesos:

select titulo, precio

from libros

where precio>20;

Queremos seleccionar los libros cuyo precio sea menor o igual a 30:

select *from libros

where precio<=30;

Los operadores relacionales comparan valores del mismo tipo. Se emplean para
comprobar si un campo cumple con una condición.

No son los únicos, existen otros que veremos más adelante.

BORRAR REGISTROS (Delete)

Para eliminar los registros de una tabla usamos el comando "delete".

Sintaxis básica:

delete from NOMBRETABLA;

Se coloca el comando delete seguido de la palabra clave "from" y el nombre de la

tabla de la cual queremos eliminar los registros. En el siguiente ejemplo se eliminan
los registros de la tabla "usuarios":

delete from usuarios;

Luego, un mensaje indica la cantidad de registros que se han eliminado.

Si no queremos eliminar todos los registros, sino solamente algunos, debemos indicar
cuál o cuáles; para ello utilizamos el comando "delete" junto con la clausula "where"
con la cual establecemos la condición que deben cumplir los registros a borrar.

Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es "Marcelo":

delete from usuarios

where nombre='Marcelo';

Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple

con la condición especificada, aparecerá un mensaje indicando que ningún registro fue
eliminado, pues no encontró registros con ese dato.

Tenga en cuenta que si no colocamos una condición, se eliminan todos los registros
de la tabla especificada.
 ACTUALIZAR REGISTROS (Update)

Decimos que actualizamos un registro cuando modificamos alguno de sus valores.

Para modificar uno o varios datos de uno o varios registros utilizamos "update"
(actualizar).

Sintaxis básica:

update NOMBRETABLA set CAMPO=NUEVOVALOR;

Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y
su nuevo valor.

El cambio afectará a todos los registros.

Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las
claves, por "RealMadrid":

update usuarios set clave='RealMadrid';

Podemos modificar algunos registros, para ello debemos establecer condiciones de

selección con "where".

Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario

llamado "Federicolopez", queremos como nueva clave "Boca", necesitamos una
condición "where" que afecte solamente a este registro:

update usuarios set clave='Boca'

where nombre='Federicolopez';

Si Oracle no encuentra registros que cumplan con la condición del "where", un

mensaje indica que ningún registro fue modificado.

Las condiciones no son obligatorias, pero si omitimos la cláusula "where", la

actualización afectará a todos los registros.

También podemos actualizar varios campos en una sola instrucción:

update usuarios set nombre='Marceloduarte', clave='Marce'

where nombre='Marcelo';

Para ello colocamos "update", el nombre de la tabla, "set" junto al nombre del campo y
el nuevo valor y separado por coma, el otro nombre del campo con su nuevo valor.

COMENTARIOS
Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar comentarios.

Es posible ingresar comentarios en la línea de comandos, es decir, un texto que no se

ejecuta; para ello se emplean dos guiones (--):

select *from libros;--mostramos los registros de libros

en la línea anterior, todo lo que está luego de los guiones (hacia la derecha) no se
ejecuta.

Para agregar varias líneas de comentarios, se coloca una barra seguida de un

asterisco (/*) al comienzo del bloque de comentario y al finalizarlo, un asterisco
seguido de una barra (*/)

select titulo, autor

/*mostramos títulos y

nombres de los autores*/

from libros;

todo lo que está entre los símbolos "/*" y "*/" no se ejecuta.

VALORES NULOS (null)

"null' significa "dato desconocido" o "valor inexistente".

A veces, puede desconocerse o no existir el dato correspondiente a algún campo de

un registro. En estos casos decimos que el campo puede contener valores nulos.

Por ejemplo, en nuestra tabla de libros, podemos tener valores nulos en el campo
"precio" porque es posible que para algunos libros no le hayamos establecido el precio
para la venta.

En contraposición, tenemos campos que no pueden estar vacíos jamás.

Veamos un ejemplo. Tenemos nuestra tabla "libros". El campo "titulo" no debería estar
vacío nunca, igualmente el campo "autor". Para ello, al crear la tabla, debemos
especificar que tales campos no admitan valores nulos:

create table libros(

titulo varchar2(30) not null,

autor varchar2(20) not null,

editorial varchar2(15) null,

precio number(5,2)

);
Para especificar que un campo NO admita valores nulos, debemos colocar "not null"
luego de la definición del campo.

En el ejemplo anterior, los campos "editorial" y "precio" si admiten valores nulos.

Cuando colocamos "null" estamos diciendo que admite valores nulos (caso del campo
"editorial"); por defecto, es decir, si no lo aclaramos, los campos permiten valores
nulos (caso del campo "precio").

Cualquier campo, de cualquier tipo de dato permite ser definido para aceptar o no
valores nulos. Un valor "null" NO es lo mismo que un valor 0 (cero) o una cadena de
espacios en blanco (" ").

Si ingresamos los datos de un libro, para el cual aún no hemos definido el precio
podemos colocar "null" para mostrar que no tiene precio:

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

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

Note que el valor "null" no es una cadena de caracteres, NO se coloca entre comillas.

Entonces, si un campo acepta valores nulos, podemos ingresar "null" cuando no

conocemos el valor.

También podemos colocar "null" en el campo "editorial" si desconocemos el nombre

de la editorial a la cual pertenece el libro que vamos a ingresar:

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

values('Alicia en el pais','Lewis Carroll',null,25);

Una cadena vacía es interpretada por Oracle como valor nulo; por lo tanto, si
ingresamos una cadena vacía, se almacena el valor "null".

Si intentamos ingresar el valor "null" (o una cadena vacía) en campos que no admiten
valores nulos (como "titulo" o "autor"), Oracle no lo permite, muestra un mensaje y la
inserción no se realiza; por ejemplo:

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

values(null,'Borges','Siglo XXI',25);

Cuando vemos la estructura de una tabla con "describe", en la columna "Null", aparece
"NOT NULL" si el campo no admite valores nulos y no aparece en caso que si los
permita.

Para recuperar los registros que contengan el valor "null" en algún campo, no
podemos utilizar los operadores relacionales vistos anteriormente: = (igual) y <>
(distinto); debemos utilizar los operadores "is null" (es igual a null) y "is not null" (no es
null).

Los valores nulos no se muestran, aparece el campo vacío.

Entonces, para que un campo no permita valores nulos debemos especificarlo luego
de definir el campo, agregando "not null". Por defecto, los campos permiten valores
nulos, pero podemos especificarlo igualmente agregando "null".

OPERADORADORES RELACIONALES (is null())

Para recuperar los registros que contengan el valor "null" en algún campo, no
podemos utilizar los operadores relacionales vistos anteriormente: = (igual) y <>
(distinto); debemos utilizar los operadores "is null" (es igual a null) y "is not null" (no es
null).

Con la siguiente sentencia recuperamos los libros que contienen valor nulo en el
campo "editorial":

select *from libros

where editorial is null;

Recuerde que los valores nulos no se muestran, aparece el campo vacío.

Las siguientes sentencias tendrán una salida diferente:

select *from libros where editorial is null;

select *from libros where editorial=' ';

Con la primera sentencia veremos los libros cuya editorial almacena el valor "null"
(desconocido); con la segunda, los libros cuya editorial guarda una cadena de 3
espacios en blanco.

Para obtener los registros que no contienen "null", se puede emplear "is not null", esto
mostrará los registros con valores conocidos.

Para ver los libros que NO tienen valor "null" en el campo "precio" tipeamos:

select *from libros where precio is not null;

CLAVE PRIMARIA (extendemos PK)

Una clave primaria es un campo (o varios) que identifica un solo registro (fila) en una
tabla.

Para un valor del campo clave existe solamente un registro.

Veamos un ejemplo, si tenemos una tabla con datos de personas, el número de

documento puede establecerse como clave primaria, es un valor que no se repite;
puede haber personas con igual apellido y nombre, incluso el mismo domicilio (padre e
hijo por ejemplo), pero su documento será siempre distinto.

Si tenemos la tabla "usuarios", el nombre de cada usuario puede establecerse como

clave primaria, es un valor que no se repite; puede haber usuarios con igual clave,
pero su nombre de usuario será siempre diferente.

Podemos establecer que un campo sea clave primaria al momento de crear la tabla o
luego que ha sido creada. Vamos a aprender a establecerla al crear la tabla. No existe
una única manera de hacerlo, por ahora veremos la sintaxis más sencilla.

Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y "clave").

La sintaxis básica y general es la siguiente:

create table NOMBRETABLA(

CAMPO TIPO,

...,

CAMPO TIPO,

PRIMARY KEY (CAMPO)

);

Lo que hacemos agregar, luego de la definición de cada campo, "primary key" y entre
paréntesis, el nombre del campo que será clave primaria.

En el siguiente ejemplo definimos una clave primaria, para nuestra tabla "usuarios"
para asegurarnos que cada usuario tendrá un nombre diferente y único:

create table usuarios(

nombre varchar2(20),

clave varchar2(10),

primary key(nombre)

);

Una tabla sólo puede tener una clave primaria. Cualquier campo (de cualquier tipo)
puede ser clave primaria, debe cumplir como requisito, que sus valores no se repitan
ni sean nulos. Por ello, al definir un campo como clave primaria, automáticamente
Oracle lo convierte a "not null".

Luego de haber establecido un campo como clave primaria, al ingresar los registros,
Oracle controla que los valores para el campo establecido como clave primaria no
estén repetidos en la tabla; si estuviesen repetidos, muestra un mensaje y la inserción
no se realiza. Es decir, si en nuestra tabla "usuarios" ya existe un usuario con nombre
"juanperez" e intentamos ingresar un nuevo usuario con nombre "juanperez", aparece
un mensaje y la instrucción "insert" no se ejecuta.
Igualmente, si realizamos una actualización, Oracle controla que los valores para el
campo establecido como clave primaria no estén repetidos en la tabla, si lo estuviese,
aparece un mensaje indicando que se viola la clave primaria y la actualización no se
realiza.

Podemos ver el campo establecido como clave primaria de una tabla realizando la
siguiente consulta:

select uc.table_name, column_name

from user_cons_columns ucc

join user_constraints uc

on ucc.constraint_name=uc.constraint_name

where uc.constraint_type='P' and

uc.table_name='USUARIOS';

No explicaremos la consulta anterior por el momento, sólo la ejecutaremos; si la

consulta retorna una tabla vacía, significa que la tabla especificada no tiene clave
primaria. El nombre de la tabla DEBE ir en mayúsculas, sino Oracle no la encontrará.

VACIAR LA TABLA (Truncate)

Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin
condición "where".

También podemos eliminar todos los registros de una tabla con "truncate table".
Sintaxis:

truncate table NOMBRETABLA;

Por ejemplo, queremos vaciar la tabla "libros", usamos:

truncate table libros;

La sentencia "truncate table" vacía la tabla (elimina todos los registros) y conserva la
estructura de la tabla.

La diferencia con "drop table" es que esta sentencia elimina la tabla, no solamente los
registros, "truncate table" la vacía de registros.

La diferencia con "delete" es la siguiente, al emplear "delete", Oracle guarda una copia
de los registros borrados y son recuperables, con "truncate table" no es posible la
recuperación porque se libera todo el espacio en disco ocupado por la tabla; por lo
tanto, "truncate table" es más rápido que "delete" (se nota cuando la cantidad de
registros es muy grande).
 TIPOS DE DATOS ALFANUMERICOS

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es,
definir los campos y sus tipos más precisos, según el caso.

Los valores numéricos no se ingresan entre comillas. Se utiliza el punto como

separador de decimales.

Para almacenar valores NUMERICOS Oracle dispone de dos tipos de datos:

1) number(t,d): para almacenar valores enteros o decimales, positivos o negativos. Su

rango va de 1.0 x 10-130 hasta 9.999...(38 nueves). Definimos campos de este tipo
cuando queremos almacenar valores numéricos con los cuales luego realizaremos
operaciones matemáticas, por ejemplo, cantidades, precios, etc.

El parámetro "t" indica el número total de dígitos (contando los decimales) que
contendrá el número como máximo (es la precisión). Su rango va de 1 a 38. El
parámetro "d" indica el máximo de dígitos decimales (escala). La escala puede ir de -
84 a 127. Para definir número enteros, se puede omitir el parámetro "d" o colocar un 0.

Un campo definido "number(5,2)" puede contener cualquier número entre -999.99 y

999.99.

Para especificar número enteros, podemos omitir el parámetro "d" o colocar el valor 0.

Si intentamos almacenar un valor mayor fuera del rango permitido al definirlo, tal valor
no se carga, aparece un mensaje indicando tal situación y la sentencia no se ejecuta.

Por ejemplo, si definimos un campo de tipo "number(4,2)" e intentamos guardar el

valor 123.45, aparece un mensaje indicando que el valor es demasiado grande para la
columna. Si ingresamos un valor con más decimales que los definidos, el valor se
carga pero con la cantidad de decimales permitidos, los dígitos sobrantes se omiten.

2) float (x): almacena un número en punto decimal. El parámetro indica la precisión

binaria máxima; con un rango de 1 a 126. Si se omite, por defecto es 126.

Para ambos tipos numéricos:

- si ingresamos un valor con más decimales que los permitidos, redondea al más
cercano; por ejemplo, si definimos "float(4,2)" e ingresamos el valor "12.686", guardará
"12.69", redondeando hacia arriba; si ingresamos el valor "12.682", guardará "12.67",
redondeando hacia abajo.

- si intentamos ingresar un valor fuera de rango, no lo acepta.

- si ingresamos una cadena, Oracle intenta convertirla a valor numérico, si dicha

cadena consta solamente de dígitos, la conversión se realiza, luego verifica si está
dentro del rango, si es así, la ingresa, sino, muestra un mensaje de error y no ejecuta
la sentencia. Si la cadena contiene caracteres que Oracle no puede convertir a valor
numérico, muestra un mensaje de error y la sentencia no se ejecuta.
Por ejemplo, definimos un campo de tipo "numberl(5,2)", si ingresamos la cadena
'12.22', la convierte al valor numérico 12.22 y la ingresa; si intentamos ingresar la
cadena '1234.56', la convierte al valor numérico 1234.56, pero como el máximo valor
permitido es 999.99, muestra un mensaje indicando que está fuera de rango. Si
intentamos ingresar el valor '12y.25', Oracle no puede realizar la conversión y muestra
un mensaje de error.

INGRESAR ALGUNOS CAMPOS

Hemos aprendido a ingresar registros listando todos los campos y colocando valores
para todos y cada uno de ellos luego de "values".

Si ingresamos valores para todos los campos, podemos omitir la lista de nombres de
los campos.

Por ejemplo, si tenemos creada la tabla "libros" con los campos "titulo", "autor" y
"editorial", podemos ingresar un registro de la siguiente manera:

insert into libros values ('Uno','Richard Bach','Planeta');

También es posible ingresar valores para algunos campos. Ingresamos valores

solamente para los campos "titulo" y "autor":

insert into libros (titulo, autor)

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

Oracle almacenará el valor "null" en el campo "editorial", para el cual no hemos

explicitado un valor.

Al ingresar registros debemos tener en cuenta:

- la lista de campos debe coincidir en cantidad y tipo de valores con la lista de valores
luego de "values". Si se listan más (o menos) campos que los valores ingresados,
aparece un mensaje de error y la sentencia no se ejecuta.

- si ingresamos valores para todos los campos podemos obviar la lista de campos.

- podemos omitir valores para los campos que permitan valores nulos (se guardará
"null"); si omitimos el valor para un campo "not null", la sentencia no se ejecuta.

VALORES POR DEFECTO (default)

Hemos visto que si al insertar registros no se especifica un valor para un campo que
admite valores nulos, se ingresa automáticamente "null". A este valor se le denomina
valor por defecto o predeterminado.

Un valor por defecto se inserta cuando no está presente al ingresar un registro.

Para campos de cualquier tipo no declarados "not null", es decir, que admiten valores
nulos, el valor por defecto es "null". Para campos declarados "not null", no existe valor
por defecto, a menos que se declare explícitamente con la cláusula "default".

Podemos establecer valores por defecto para los campos cuando creamos la tabla.
Para ello utilizamos "default" al definir el campo. Por ejemplo, queremos que el valor
por defecto del campo "autor" de la tabla "libros" sea "Desconocido" y el valor por
defecto del campo "cantidad" sea "0":

create table libros(

titulo varchar2(40) not null,

autor varchar2(30) default 'Desconocido' not null,

editorial varchar2(20),

precio number(5,2),

cantidad number(3) default 0

);

Si al ingresar un nuevo registro omitimos los valores para el campo "autor" y

"cantidad", Oracle insertará los valores por defecto; en "autor" colocará "Desconocido"
y en cantidad "0".

Entonces, si al definir el campo explicitamos un valor mediante la cláusula "default",

ése será el valor por defecto.

La cláusula "default" debe ir antes de "not null" (si existiese), sino aparece un mensaje
de error.

Para ver si los campos de la tabla "libros" tiene definidos valores por defecto y cuáles
son, podemos realizar la siguiente consulta:

select column_name,nullable,data_default

from user_tab_columns where TABLE_NAME = 'libros';

Muestra una fila por cada campo, en la columna "data_default" aparece el valor por
defecto (si lo tiene), en la columna "nullable" aparece "N" si el campo no está definido
"not null" y "Y" si admite valores "null".

También se puede utilizar "default" para dar el valor por defecto a los campos en
sentencias "insert", por ejemplo:

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

values ('El gato con botas',default,default,default,100);

Entonces, la cláusula "default" permite especificar el valor por defecto de un campo. Si

no se explicita, el valor por defecto es "null", siempre que el campo no haya sido
declarado "not null".

Los campos para los cuales no se ingresan valores en un "insert" tomarán los valores
por defecto:

- si permite valores nulos y no tiene cláusula "default", almacenará "null";

- si tiene cláusula "default" (admita o no valores nulos), el valor definido como
predeterminado;

- si está declarado explícitamente "not null" y no tiene valor "default", no hay valor por
defecto, así que causará un error y el "insert" no se ejecutará.

Un campo sólo puede tener un valor por defecto. Una tabla puede tener todos sus
campos con valores por defecto. Que un campo tenga valor por defecto no significa
que no admita valores nulos, puede o no admitirlos.

Un campo definido como clave primaria acepta un valor "default", pero no tiene sentido
ya que el valor por defecto solamente podrá ingresarse una vez; si intenta ingresarse
cuando otro registro ya lo tiene almacenado, aparecerá un mensaje de error indicando
que se intenta duplicar la clave.

OPERADORES ARITMETICOS Y DE CONCATENACION

Aprendimos que los operadores son símbolos que permiten realizar distintos tipos de
operaciones.

Dijimos que Oracle tiene 4 tipos de operadores: 1) relacionales o de comparación (los

vimos), 2) aritméticos, 3) de concatenación y 4) lógicos (lo veremos más adelante).

Los operadores aritméticos permiten realizar cálculos con valores numéricos.

Son: multiplicación (*), división (/), suma (+) y resta (-).

Es posible obtener salidas en las cuales una columna sea el resultado de un cálculo y
no un campo de una tabla.

Si queremos ver los títulos, precio y cantidad de cada libro escribimos la siguiente
sentencia:

select titulo,precio,cantidad

from libros;

Si queremos saber el monto total en dinero de un título podemos multiplicar el precio

por la cantidad por cada título, pero también podemos hacer que Oracle realice el
cálculo y lo incluya en una columna extra en la salida:

select titulo, precio,cantidad,

precio*cantidad

from libros;

Si queremos saber el precio de cada libro con un 10% de descuento podemos incluir
en la sentencia los siguientes cálculos:

select titulo,precio,
 precio-(precio*0.1)

from libros;

También podemos actualizar los datos empleando operadores aritméticos:

update libros set precio=precio-(precio*0.1);

Para concatenar cadenas de caracteres existe el operador de concatenación ||.

Para concatenar el título y el autor de cada libro usamos el operador de concatenación

("||"):

select titulo||'-'||autor

from libros;

Note que concatenamos además un guión para separar los campos.

Oracle puede convertir automáticamente valores numéricos a cadenas para una

concatenación; por ejemplo, en el siguiente ejemplo mostramos el título y precio de
cada libro concatenado con el operador "||":

select titulo||' $'||precio

from libros;

AGRUPAR REGISTROS (group by)

Hemos aprendido que las funciones de grupo permiten realizar varios cálculos
operando con conjuntos de registros.

Las funciones de grupo solas producen un valor de resumen para todos los registros
de un campo.

Podemos generar valores de resumen para un solo campo, combinando las funciones
de agregado con la cláusula "group by", que agrupa registros para consultas
detalladas.

Queremos saber la cantidad de libros de cada editorial, podemos tipear la siguiente

sentencia:

select count(*) from libros

where editorial='Planeta';

y repetirla con cada valor de "editorial":

select count(*) from libros

where editorial='Emece';
select count(*) from libros

where editorial='Paidos';

...

Pero hay otra manera, utilizando la cláusula "group by":

select editorial, count(*)

from libros

group by editorial;

La instrucción anterior solicita que muestre el nombre de la editorial y cuente la

cantidad agrupando los registros por el campo "editorial". Como resultado aparecen
los nombres de las editoriales y la cantidad de registros para cada valor del campo.

Los valores nulos se procesan como otro grupo.

Entonces, para saber la cantidad de libros que tenemos de cada editorial, utilizamos la
función "count()", agregamos "group by" (que agrupa registros) y el campo por el que
deseamos que se realice el agrupamiento, también colocamos el nombre del campo a
recuperar; la sintaxis básica es la siguiente:

select CAMPO, FUNCIONDEAGREGADO

from NOMBRETABLA

group by CAMPO;

También se puede agrupar por más de un campo, en tal caso, luego del "group by" se
listan los campos, separados por comas. Todos los campos que se especifican en la
cláusula "group by" deben estar en la lista de selección.

select CAMPO1, CAMPO2, FUNCIONDEAGREGADO

from NOMBRETABLA

group by CAMPO1,CAMPO2;

Para obtener la cantidad libros con precio no nulo, de cada editorial utilizamos la
función "count()" enviándole como argumento el campo "precio", agregamos "group
by" y el campo por el que deseamos que se realice el agrupamiento (editorial):

select editorial, count(precio)

from libros

group by editorial;

Como resultado aparecen los nombres de las editoriales y la cantidad de registros de

cada una, sin contar los que tienen precio nulo.
Recuerde la diferencia de los valores que retorna la función "count()" cuando enviamos
como argumento un asterisco o el nombre de un campo: en el primer caso cuenta
todos los registros incluyendo los que tienen valor nulo, en el segundo, los registros en
los cuales el campo especificado es no nulo.

Para conocer el total de libros agrupados por editorial:

select editorial, sum(cantidad)

from libros

group by editorial;

Para saber el máximo y mínimo valor de los libros agrupados por editorial:

select editorial,

max(precio) as mayor,

min(precio) as menor

from libros

group by editorial;

Para calcular el promedio del valor de los libros agrupados por editorial:

select editorial, avg(precio)

from libros

group by editorial;

Es posible limitar la consulta con "where".

Si incluye una cláusula "where", sólo se agrupan los registros que cumplen las
condiciones.

Vamos a contar y agrupar por editorial considerando solamente los libros cuyo precio
sea menor a 30 pesos:

select editorial, count(*)

from libros

where precio<30

group by editorial;

Note que las editoriales que no tienen libros que cumplan la condición, no aparecen en
la salida.
Entonces, usamos "group by" para organizar registros en grupos y obtener un
resumen de dichos grupos. Oracle produce una columna de valores por cada grupo,
devolviendo filas por cada grupo especificado.

VARIAS TABLAS (join)

Hasta el momento hemos trabajado con una sola tabla, pero generalmente, se trabaja
con más de una.

Para evitar la repetición de datos y ocupar menos espacio, se separa la información en

varias tablas. Cada tabla almacena parte de la información que necesitamos registrar.

Por ejemplo, los datos de nuestra tabla "libros" podrían separarse en 2 tablas, una
llamada "libros" y otra "editoriales" que guardará la información de las editoriales. En
nuestra tabla "libros" haremos referencia a la editorial colocando un código que la
identifique. Veamos:

create table libros(

codigo number(4),

titulo varchar2(40) not null,

autor varchar2(30),

codigoeditorial number(3) not null,

precio number(5,2),

primary key (codigo)

);

create table editoriales(

codigo number(3),

nombre varchar2(20) not null,

primary key(codigo)

);

De esta manera, evitamos almacenar tantas veces los nombres de las editoriales en la
tabla "libros" y guardamos el nombre en la tabla "editoriales"; para indicar la editorial
de cada libro agregamos un campo que hace referencia al código de la editorial en la
tabla "libros" y en "editoriales".

Al recuperar los datos de los libros con la siguiente instrucción:

select* from libros;

vemos que en el campo "editorial" aparece el código, pero no sabemos el nombre de

la editorial. Para obtener los datos de cada libro, incluyendo el nombre de la editorial,
necesitamos consultar ambas tablas, traer información de las dos.

Cuando obtenemos información de más de una tabla decimos que hacemos un "join"
(combinación).

Veamos un ejemplo:

select *from libros

join editoriales

on [Link]=[Link];

Resumiendo: si distribuimos la información en varias tablas evitamos la redundancia

de datos y ocupamos menos espacio físico en el disco. Un join es una operación que
relaciona dos o más tablas para obtener un resultado que incluya datos (campos y
registros) de ambas; las tablas participantes se combinan según los campos comunes
a ambas tablas.

Hay tres tipos de combinaciones. En los siguientes capítulos explicamos cada una de
ellas.

COMBINACION INTERNA (join)

Un join es una operación que relaciona dos o más tablas para obtener un resultado
que incluya datos (campos y registros) de ambas; las tablas participantes se combinan
según los campos comunes a ambas tablas.

Hay tres tipos de combinaciones:

1) combinaciones internas (inner join o join),

2) combinaciones externas y

3) combinaciones cruzadas.

También es posible emplear varias combinaciones en una consulta "select", incluso

puede combinarse una tabla consigo misma.

La combinación interna emplea "join", que es la forma abreviada de "inner join". Se

emplea para obtener información de dos tablas y combinar dicha información en una
salida.

La sintaxis básica es la siguiente:

select CAMPOS

from TABLA1

join TABLA2

on CONDICIONdeCOMBINACION;

Ejemplo:

select *from libros

join editoriales

on codigoeditorial=[Link];

Analicemos la consulta anterior.

- especificamos los campos que aparecerán en el resultado en la lista de selección;

- indicamos el nombre de la tabla luego del "from" ("libros");

- combinamos esa tabla con "join" y el nombre de la otra tabla ("editoriales"); se

especifica qué tablas se van a combinar y cómo;

- cuando se combina información de varias tablas, es necesario especificar qué

registro de una tabla se combinará con qué registro de la otra tabla, con "on". Se debe
especificar la condición para enlazarlas, es decir, el campo por el cual se combinarán,
que tienen en común. "on" hace coincidir registros de ambas tablas basándose en el
valor de tal campo, en el ejemplo, el campo "codigoeditorial" de "libros" y el campo
"codigo" de "editoriales" son los que enlazarán ambas tablas. Se emplean campos
comunes, que deben tener tipos de datos iguales o similares.

La condicion de combinación, es decir, el o los campos por los que se van a combinar
(parte "on"), se especifica según las claves primarias y externas.

Note que en la consulta, al nombrar el campo usamos el nombre de la tabla también.

Cuando las tablas referenciadas tienen campos con igual nombre, esto es necesario
para evitar confusiones y ambiguedades al momento de referenciar un campo. En el
ejemplo, si no especificamos "[Link]" y solamente tipeamos "codigo",
Oracle no sabrá si nos referimos al campo "codigo" de "libros" o de "editoriales" y
mostrará un mensaje de error indicando que "codigo" es ambiguo.

Entonces, si las tablas que combinamos tienen nombres de campos iguales, DEBE
especificarse a qué tabla pertenece anteponiendo el nombre de la tabla al nombre del
campo, separado por un punto (.).

Si una de las tablas tiene clave primaria compuesta, al combinarla con la otra, en la
cláusula "on" se debe hacer referencia a la clave completa, es decir, la condición
referenciará a todos los campos clave que identifican al registro.

Se puede incluir en la consulta join la cláusula "where" para restringir los registros que
retorna el resultado; también "order by", "distinct", etc..

Se emplea este tipo de combinación para encontrar registros de la primera tabla que
se correspondan con los registros de la otra, es decir, que cumplan la condición del
"on". Si un valor de la primera tabla no se encuentra en la segunda tabla, el registro no
aparece; si en la primera tabla el valor es nulo, tampoco aparece.

Para simplificar la sentencia podemos usar un alias para cada tabla:

select [Link],titulo,autor,nombre

from libros l

join editoriales e

on [Link]=[Link];

En algunos casos (como en este ejemplo) el uso de alias es para fines de

simplificación y hace más legible la consulta si es larga y compleja, pero en algunas
consultas es absolutamente necesario.

COMBINACION EXTERNA IZQUIERDA (Join)

Vimos que una combinación interna (join) encuentra registros de la primera tabla que
se correspondan con los registros de la segunda, es decir, que cumplan la condición
del "on" y si un valor de la primera tabla no se encuentra en la segunda tabla, el
registro no aparece.

Si queremos saber qué registros de una tabla NO encuentran correspondencia en la

otra, es decir, no existe valor coincidente en la segunda, necesitamos otro tipo de
combinación, "outer join" (combinación externa).

Las combinaciones externas combinan registros de dos tablas que cumplen la

condición, más los registros de la segunda tabla que no la cumplen; es decir, muestran
todos los registros de las tablas relacionadas, aún cuando no haya valores
coincidentes entre ellas.

Este tipo de combinación se emplea cuando se necesita una lista completa de los
datos de una de las tablas y la información que cumple con la condición. Las
combinaciones externas se realizan solamente entre 2 tablas.

Hay tres tipos de combinaciones externas: "left outer join", "right outer join" y "full outer
join"; se pueden abreviar con "left join", "right join" y "full join" respectivamente.

Vamos a estudiar las primeras.

Se emplea una combinación externa izquierda para mostrar todos los registros de la
tabla de la izquierda. Si no encuentra coincidencia con la tabla de la derecha, el
registro muestra los campos de la segunda tabla seteados a "null".

En el siguiente ejemplo solicitamos el título y nombre de la editorial de los libros:

select titulo,nombre

from editoriales e
 left join libros l

on codigoeditorial = [Link];

El resultado mostrará el título y nombre de la editorial; las editoriales de las cuales no

hay libros, es decir, cuyo código de editorial no está presente en "libros" aparece en el
resultado, pero con el valor "null" en el campo "titulo".

Es importante la posición en que se colocan las tablas en un "left join", la tabla de la

izquierda es la que se usa para localizar registros en la tabla de la derecha.

Entonces, un "left join" se usa para hacer coincidir registros en una tabla (izquierda)
con otra tabla (derecha); si un valor de la tabla de la izquierda no encuentra
coincidencia en la tabla de la derecha, se genera una fila extra (una por cada valor no
encontrado) con todos los campos correspondientes a la tabla derecha seteados a
"null". La sintaxis básica es la siguiente:

select CAMPOS

from TABLAIZQUIERDA

left join TABLADERECHA

on CONDICION;

En el siguiente ejemplo solicitamos el título y el nombre la editorial, la sentencia es

similar a la anterior, la diferencia está en el orden de las tablas:

select titulo,nombre

from libros l

left join editoriales e

on codigoeditorial = [Link];

El resultado mostrará el título del libro y el nombre de la editorial; los títulos cuyo
código de editorial no está presente en "editoriales" aparecen en el resultado, pero con
el valor "null" en el campo "nombre".

Un "left join" puede tener clausula "where" que restringa el resultado de la consulta
considerando solamente los registros que encuentran coincidencia en la tabla de la
derecha, es decir, cuyo valor de código está presente en "libros":

select titulo,nombre

from editoriales e

left join libros l

on [Link]=codigoeditorial

where codigoeditorial is not null;

También podemos mostrar las editoriales que NO están presentes en "libros", es decir,
que NO encuentran coincidencia en la tabla de la derecha:

select titulo,nombre

from editoriales e

left join libros l

on [Link]=codigoeditorial

where codigoeditorial is null;

COMBINACION EXTERNA DERECHA (right join)

Vimos que una combinación externa izquierda (left join) encuentra registros de la tabla
izquierda que se correspondan con los registros de la tabla derecha y si un valor de la
tabla izquierda no se encuentra en la tabla derecha, el registro muestra los campos
correspondientes a la tabla de la derecha seteados a "null".

Una combinación externa derecha ("right outer join" o "right join") opera del mismo
modo sólo que la tabla derecha es la que localiza los registros en la tabla izquierda.

En el siguiente ejemplo solicitamos el título y nombre de la editorial de los libros

empleando un "right join":

select titulo,nombre as editorial

from libros l

right join editoriales e

on codigoeditorial = [Link];

El resultado mostrará el título y nombre de la editorial; las editoriales de las cuales no

hay libros, es decir, cuyo código de editorial no está presente en "libros" aparece en el
resultado, pero con el valor "null" en el campo "titulo".

Es FUNDAMENTAL tener en cuenta la posición en que se colocan las tablas en los

"outer join". En un "left join" la primera tabla (izquierda) es la que busca coincidencias
en la segunda tabla (derecha); en el "right join" la segunda tabla (derecha) es la que
busca coincidencias en la primera tabla (izquierda).

En la siguiente consulta empleamos un "left join" para conseguir el mismo resultado

que el "right join" anterior":

select titulo,nombre

from editoriales e
 left join libros l

on codigoeditorial = [Link];

Note que la tabla que busca coincidencias ("editoriales") está en primer lugar porque
es un "left join"; en el "right join" precedente, estaba en segundo lugar.

Un "right join" hace coincidir registros en una tabla (derecha) con otra tabla (izquierda);
si un valor de la tabla de la derecha no encuentra coincidencia en la tabla izquierda, se
genera una fila extra (una por cada valor no encontrado) con todos los campos
correspondientes a la tabla izquierda seteados a "null". La sintaxis básica es la
siguiente:

select CAMPOS

from TABLAIZQUIERDA

right join TABLADERECHA

on CONDICION;

Un "right join" también puede tener cláusula "where" que restringa el resultado de la
consulta considerando solamente los registros que encuentran coincidencia en la tabla
izquierda:

select titulo,nombre

from libros l

right join editoriales e

on [Link]=codigoeditorial

where codigoeditorial is not null;

Mostramos las editoriales que NO están presentes en "libros", es decir, que NO

encuentran coincidencia en la tabla de la derecha empleando un "right join":

select titulo,nombre

from libros l

right join editoriales e

on [Link]=codigoeditorial

where codigoeditorial is null;

BIBLIOGRAFIA:

Información, ejemplos y ejercicios extraídos de:

[Link]

[Link]

[Link]