Escuela SQL intro8SinOracle

1.
INTRODUCCIÓN
1.1. LENGUAJE SQL
SQL es un lenguaje estándar para bases de datos relacionales. Una base de

datos relacional es una colección de objetos individuales, con nombre
denominados tablas. No se especifica la ruta de acceso a las tablas y no se
necesita saber como están dispuestos los datos físicamente.
Para acceder a la base de datos, se ejecuta un comando del Lenguaje de

Consulta estructurado (Structured Query Language – SQL). El lenguaje
contiene un conjunto numeroso de operadores para particionar y combinar
relaciones. La base de datos puede ser fácilmente modificada usando
comandos SQL. El modelo relacional permite la independencia completa de los
datos.
• El American National Standards Institute (ANSI) ha adoptado el SQL como

lenguaje estándar para los sistemas de administración de bases de datos
relacionales.
1.1.1. Características del Lenguaje SQL
El lenguaje SQL puede ser usado por cualquier tipo de usuario.
El lenguaje SQL no es un lenguaje procedural, es decir, las sentencias no dicen

cómo obtener los datos sino qué datos obtener.
El lenguaje SQL reduce la cantidad de tiempo requerido para crear y mantener

sistemas.
El lenguaje SQL es similar al idioma inglés.
1.1.2. Sentencias SQL
Sentencias de recuperación de datos SELECT

Sentencias e manipulación de datos INSERT, UPDATE, DELETE,
COMMIT, ROLLBACK
Sentencias de definición de estructuras CREATE, ALTER, DROP,
Sentencias de control de datos GRANT, REVOKE, AUDIT,
NOAUDIT, LOCK
2. RECUPERACIÓN DE DATOS
2.1. SENTENCIA SELECT
Una sentencia SELECT permite recuperar los datos almacenados en la Base

de Datos. Describiremos en primer lugar la forma más simple de la sentencia
SELECT.
Sintaxis
SELECT [DISTINCT] {*,columna [[AS] alias] [,columna [[AS] alias]...]}
FROM tabla
donde:
SELECT sirve para elegir las columnas a recuperar, DISTINCT

indica que deben recuperarse las combinaciones de datos distintas, *
indica que deben recuperarse todas las columnas de la tabla, alias
indica el nombre que se utilizará como encabezado de la columna en el
resultado.
FROM especifica el nombre de una tabla (obligatorio)
Ejemplo: Seleccionar todas las columnas y todas las filas de la tabla

DEPARTAMENTOS
SQL> select * from departamentos;
CODIGO NOMBRE
--------- ------------------------------
1 CONTABILIDAD
2 RECURSOS HUMANOS
3 PRODUCCION
4 SISTEMAS
5 MARKETING
6 COMERCIALIZACION
6 rows selected.
Ejemplo: Seleccionar las columnas codigo_prov y nombre, y todas las filas de

la tabla PROVEEDOR. Nombrar la columna codigo_prov
como prov.
SQL> SELECT codigo prov, nombre

2 FROM proveedores;
PROV NOMBRE
--------- -----------------------------
1 ATALAYA S.R.L.
2 ROCAMORA E HIJOS
3 LA PERUANA
4 RUTA S.A.
5 COMODINES
6 LA SEXTA
7 AGUSTINEZ Y HERMANOS S.A.
8 PEREZ, PEREZ, Y RODRIGUEZ
9 AGUSTIN FERNANDEZ Y ASOCIADOS
10 COMODO S.R.L.
11 PARIS
12 MIS LAPICES
12 rows selected.
2.1.1. Alias de Columna
Por default el título de una columna es el nombre de la misma en la tabla. Para

sustituirlo se indica un alias. Esta sustitución tiene en cuenta las siguientes
pautas:
• Si la expresión a usar como título contuviera espacios, caracteres

especiales, o se desea que se respeten mayúsculas y minúsculas, debe
encerrarse la misma entre comillas (").
• El nombre de la columna se separa de su alias con un espacio.
• La palabra AS es opcional.
Ejemplo: Seleccionar el nombre y dirección de cada proveedor.
SQL> select nombre Proveedor, direccion "Direccion del

Proveedor"
2 from proveedores;
PROVEEDOR Direccion del Proveedor

------------------------------ ------------------------
ATALAYA S.R.L. Maipu 385
ROCAMORA E HIJOS Av. Caseros 3567
LA PERUANA Tagle 1945
RUTA S.A. Lacroze 892
COMODINES Olazabal 675
LA SEXTA Capitan Muinez 4334
AGUSTINEZ Y HERMANOS S.A. Puente Paricci 42 Of.45
PEREZ, PEREZ, Y RODRIGUEZ Cochabamba 1152
AGUSTIN FERNANDEZ Y ASOCIADOS Guido 675
COMODO S.R.L. Olazabal 7878
PARIS Julian Alvarez 1275
MIS LAPICES Cafe Paris s/n
12 rows selected.
2.1.2. Cláusula DISTINCT
La cláusula DISTINCT aplicada a una sentencia SELECT permite indicar que

deben eliminarse las filas duplicadas antes de mostrar el resultado que la
sentencia ha recuperado. La cláusula se aplica a toda la sentencia y no
solamente a una columna.
Ejemplo: Seleccionar las fechas en que se han emitido órdenes de compra.
SQL> select distinct forden

2 from ordenes;
FORDEN
---------
12-DEC-95
18-MAY-96
23-MAR-97
28-AUG-97
02-OCT-97
13-NOV-97
20-JAN-98
21-JAN-98
22-JAN-98
23-JAN-98
19-MAY-98
31-OCT-98
30-NOV-98
18-JAN-99
23-JAN-99
23-APR-99
16 rows selected.
Ejemplo: Seleccionar las fechas en que se han emitido órdenes de compras

junto con el correspondiente identificador del proveedor.
SQL> select distinct forden, codigo_prv

2 from ordenes;
FORDEN CODIGO_PRV
--------- ----------
12-DEC-95 12
18-MAY-96 12
23-MAR-97 6
28-AUG-97 6
02-OCT-97 8
13-NOV-97 8
20-JAN-98 1
20-JAN-98 3
21-JAN-98 4
22-JAN-98 2
23-JAN-98 5
19-MAY-98 9
31-OCT-98 7
30-NOV-98 7
18-JAN-99 11
23-JAN-99 5
23-JAN-99 12
23-APR-99 3
18 rows selected.
2.2. CONDICIONES DE BÚSQUEDA
La búsqueda de datos puede condicionarse de dos maneras. En primer lugar

es posible condicionar cuáles datos son mostrados y cuales no mediante la
inclusión de la cláusula WHERE. En segundo lugar es posible condicionar el
orden en que los datos recuperados son mostrados. Esto se lleva a cabo
mediante la cláusula ORDER BY.
2.2.1. Cláusula WHERE
La cláusula WHERE aplicada a una sentencia SELECT permite indicar que

deben restringirse las filas a recuperar por las condiciones incluidas en la
cláusula. La cláusula WHERE indica siempre una condición de búsqueda para
mostrar solamente aquellos datos que la cumplen.
Sintaxis

FROM tabla
WHERE condición
donde:
condición La condición es una expresión lógica, la cual se evalúa

para cada fila de la tabla de la cual se seleccionan los
datos. Serán mostradas sólo aquellas filas para las cuales
la condición resulte verdadera. La condición está
compuesta por nombres de columnas, expresiones,
constantes, operadores de comparación, y operadores
lógicos.
Ejemplo: Seleccionar los proveedores de Capital Federal.
SQL> select nombre, direccion, ciudad

2 from proveedores
3 where ciudad = 'Capital Federal';
NOMBRE DIRECCION CIUDAD

------------------------- --------------- -----------------
ATALAYA S.R.L. Maipu 385 Capital Federal
LA PERUANA Tagle 1945 Capital Federal
PEREZ, PEREZ, Y RODRIGUEZ Cochabamba 1152 Capital Federal
Operadores de Comparación
Los operadores de comparación permiten escribir una condición comparando

dos expresiones. El resultado es siempre un valor de verdad que indica si la
condición de búsqueda se cumple o no, por lo tanto, si los datos son mostrados
o no.
• Operadores =, !=,<>, >, >=, <, <=
Los operadores = (igual a), != (distinto de, también pueden usarse !=, <>, ^=),
> (mayor a), >= (mayor o igual a), < (menor a), <= (menor o igual a) permiten
comparar expresiones de cualquier tipo de dato, y se utilizará en la
comparación la definición de orden correspondiente (orden numérico, orden
temporal, orden lexicográfico). En el caso de las cadenas de caracteres la
comparación contra literales es exacta, vale decir que debe prestarse atención
especial al uso de mayúsculas y minúsculas.
Ejemplo: Seleccionar los productos cuyo identificador sea mayor a 8000000.
SQL> select * from productos

2 where codigo > 8000000;
CODIGO NOMBRE
--------- ------------------------
8080801 BIROME TRAZO FINO
8080803 BIROME TRAZO GRUEZO
9002003 PIZARRA BLANCA
9002004 PIZARRON
9002005 PIZARRA BLANCA CON HOJAS
9002006 REPUESTO HOJAS PIZARRA
6 rows selected.
Ejemplo: Seleccionar las órdenes de compra emitidas antes del 22 de enero

de 1998.
SQL> select * from ordenes

2 where forden < '22-JAN-98';
NRO_ORDEN FORDEN CODIGO_PRV CODIGO_EMP FENTREGA TIPO_PAGO C

--------- --------- ---------- ---------- --------- ---------- -
1 20-JAN-98 1 1 CONTADO N
2 20-JAN-98 3 1 CREDITO N
3 21-JAN-98 4 3 23-JAN-98 CONTADO S
6 18-MAY-96 12 7 25-JUN-96 CONTADO S
7 12-DEC-95 12 8 27-DEC-95 CONTADO S
8 23-MAR-97 6 10 25-NOV-97 CREDITO S
9 28-AUG-97 6 11 25-SEP-97 CREDITO S
10 02-OCT-97 8 11 25-JAN-98 CREDITO S
11 13-NOV-97 8 11 15-NOV-98 CONTADO S
9 rows selected.
Ejemplo: Seleccionar las órdenes de compra cuya forma de pago es al

contado.

2 where tipo_pago = 'Contado';
no rows selected

2 where tipo_pago = 'CONTADO';

--------- --------- ---------- ---------- --------- ---------- -
6 18-MAY-96 12 7 25-JUN-96 CONTADO S
7 12-DEC-95 12 8 27-DEC-95 CONTADO S
11 13-NOV-97 8 11 15-NOV-98 CONTADO S
12 19-MAY-98 9 12 15-FEB-99 CONTADO S
15 30-NOV-98 7 16 CONTADO N
16 31-OCT-98 7 17 CONTADO N
10 rows selected.
• Operador LIKE
El operador LIKE se utiliza para la comparación de cadenas de caracteres y

tiene la forma general: [NOT] LIKE expresión_regular, donde la cláusula NOT
es opcional y permite obtener el resultado contrario en la comparación, y
expresión_regular es una cadena de caracteres que puede contener los
caracteres especiales % (porcentaje), y _ (guión bajo). El símbolo % indica en
la expresión regular que puede ser sustituído por cualquier cadena de
caracteres incluyendo la caden vacía, el símbolo _ indica en la expresión
regular que puede ser sustituído por uno y sólo un carácter. Estos caracteres
son también conocidos como comodines o wild cards. La comparación es
verdadera cuando el valor de la fila corresponde a la expresión regular.
Ejemplo: Seleccionar los proveedores cuyo nombre comienza con 'R'.
SQL> select nombre, direccion

2 from proveedores
3 where nombre like 'R%';
NOMBRE DIRECCION
------------------------------ ----------------
ROCAMORA E HIJOS Av. Caseros 3567
RUTA S.A. Lacroze 892
Ejemplo: Seleccionar los productos cuyo nombre contenga la palabra HOJA.

2 where nombre like '%HOJA%';
CODIGO NOMBRE
--------- --------------------------
1000225 CUADERNO 50 HOJAS
1034219 REPUESTO HOJA RALLADA
1034310 REPUESTO HOJA CUADRICULADA
1034311 REPUESTO HOJA PENTAGRAMA
7 rows selected.
Ejemplo: Seleccionar los productos cuyo nombre contenga la letra A en el

tercer lugar.

2 where nombre like '__A%';
CODIGO NOMBRE
--------- -------------------------------
1034108 PLASTICOLA
6007023 CUADERNO ECOLOGICO CUADRICULADO
6007034 CUADERNO ECOLOGICO RAYADO
6008070 CRAYONES CAJA 12 UNIDADES
6 rows selected.
Ejemplo: Seleccionar los productos cuya fecha de vigencia es de 1998.
SQL> select * from precios

2 where fvigencia like '%98';
CODIGO_PRO PRECIO FVIGENCIA

---------- --------- ---------
1000223 2.05 12-JAN-98
1002025 3.8 23-NOV-98
1034007 1.93 19-SEP-98
1034108 1.1 24-JUL-98
1034219 4.5 24-JUL-98
1034311 2.1 05-FEB-98
4210003 1.52 12-SEP-98
4210004 1.5 12-OCT-98
6007023 1.5 12-APR-98
6007034 1.5 12-APR-98
6007045 1.4 12-APR-98
6007055 1.4 12-APR-98
6007066 1.4 12-APR-98
7078080 .5 12-DEC-98
7078090 .6 12-DEC-98
15 rows selected.
Ejemplo: Seleccionar los productos cuyo nombre no contiene la cadena LA.

2* where nombre not like '%LA%';
CODIGO NOMBRE
--------- ----------------------------------------
1002025 CARPETA NRO 6
1002106 CARTULINA
1100333 MARCADOR PUNTA FINA
1100334 MARCADOR PUNTA GRUESA
4555102 AGENDA MICKEY
4555104 AGENDA BARBY
4555106 AGENDA RICO MC.PATO
6007045 BLOCK ECOLOGICO LISO
6007066 BLOCK ECOLOGICO RAYADO
6008055 RESALTADOR FLUO
6008058 RESALTADOR FLUO DOS COLORES
7078080 CLIPS METALICOS
9002004 PIZARRON
21 rows selected.
• Operador BETWEEN
El operador BETWEEN se utiliza para la comparación de expresiones de

cualquier tipo de dato y tiene la forma general: [NOT] BETWEEN valor1 AND
valor2, donde la cláusula NOT es opcional y permite obtener el resultado
contrario en la comparación. La comparación es verdadera cuando el valor de
la fila está en el intervalor definido por los valores valor1 y valor2, es decir, es
mayor o igual a valor1 y menor o igual a valor2.
Ejemplo: Seleccionar los productos cuyo precio está entre 4 y 5 pesos.

2 where precio between 4 and 5;

---------- --------- ---------
1000224 4.1 12-JAN-96
1000224 4.2 02-JAN-97
1034219 4.5 24-JUL-98
1034310 4.8 24-JUL-94
1034310 4.9 05-NOV-96
Ejemplo: Seleccionar las órdenes de compra cuya fecha de emisión esté entre
el 20 y el 22 de Enero de 1998.

2 where forden between '20-JAN-98' and '22-JAN-98';

--------- --------- ---------- ---------- --------- ---------- -
• Operador IN
El operador IN se utiliza para la comparación de expresiones de cualquier tipo

de dato y tiene la forma general: [NOT] IN (valor1, valor2, ...), donde la cláusula
NOT es opcional y permite obtener el resultado contrario en la comparación. La
comparación es verdadera cuando el valor de la fila es igual a uno de los
valores contenidos en la lista, es decir, es igual a valor1, o es igual a valor2,
etc..
Ejemplo: Seleccionar las órdenes emitidas para los proveedores 1 y 4.

2 where codigo_prv in (1,4);

--------- --------- ---------- ---------- --------- ---------- -
Ejemplo: Seleccionar los empleados de los departamentos 1, 2 y 3.
SQL> select nombre, codigo_dep

2 from empleados
3 where codigo_dep in (1,2,3);
NOMBRE CODIGO_DEP
---------------------------------------- ----------
Perez Carlos Alberto 1
Jaime Daniel 3
Miranda Adriana 2
Scorza Miguel 1
Deluca Luis 2
Cosio Alejandro 3
Fernandez Maria Cristina 3
Fernandez Sofia 3
Puan Sandra Maria 2
Asalez Marcos 3
10 rows selected.
• Operador IS NULL
El operador IS NULL se utiliza para la comparación de expresiones de

cualquier tipo de dato contra valores nulos y tiene la forma general: IS [NOT]
NULL, donde la cláusula NOT es opcional y permite obtener el resultado
contrario en la comparación. La comparación es verdadera cuando el valor de
la fila es nulo. Tener en cuenta que un valor nulo no es comparable contra
ningún valor, por ello este operador es la única forma válida para localizar un
valor nulo.
Ejemplo: Seleccionar las órdenes que no tienen fecha de entrega.

2 where fentrega = null;
no rows selected

2 where fentrega is null;

--------- --------- ---------- ---------- --------- ---------- -
13 18-JAN-99 11 14 CREDITO N
14 23-APR-99 3 16 CREDITO N
15 30-NOV-98 7 16 CONTADO N
16 31-OCT-98 7 17 CONTADO N
17 23-JAN-99 12 17 CREDITO N
9 rows selected.
Ejemplo: Seleccionar aquellos empleados que no tienen comisión.
SQL> select * from empleados

2 where comision = 0;
no rows selected
SQL> select nombre from empleados

2 where comision is null;
NOMBRE
---------------------------------
Jaime Daniel
Cucagna Karina
Soria Laura
Scorza Miguel
Fernandez Maria Cristina
Coronda Ana Laura
Martinez Javier Alberto
Asalez Marcos
8 rows selected.
Operadores Lógicos
Los operadores lógicos permiten escribir un criterio de búsqueda compleja

combinando varias condiciones de búsqueda. Estos operadores son AND, OR,
y NOT. El resultado vuelve a ser un valor de verdad que indica si la condición
de búsqueda se cumple.
• Operador AND
El operador AND se utiliza para indicar que deben cumplirse ambas

condiciones de búsqueda. Tiene la forma general: condición1 AND condición2.
La operación es verdadera cuando se condición1 es verdadera, y condición2 es
verdadera para los valores de la fila evaluada.
Ejemplo: Seleccionar los precios cuyo precio es mayor a 2 pesos y cuya fecha
de vigencia es de 1998.

2 where precio > 2 and fvigencia like '%98';

---------- --------- ---------
1000223 2.05 12-JAN-98
1002025 3.8 23-NOV-98
1034219 4.5 24-JUL-98
1034311 2.1 05-FEB-98
• Operador OR
El operador OR se utiliza para indicar que debe cumplirse por lo menos una de
las condiciones de búsqueda. Tiene la forma general: condición1 OR
condición2. La operación es verdadera cuando se condición1 es verdadera, o
condición2 es verdadera, o ambas condiciones son verdaderas para los valores
de la fila evaluada.
Ejemplo: Seleccionar los productos cuyo nombre empieza con C o con E.

2 where nombre like 'C%'
3 or nombre like 'E%';
CODIGO NOMBRE
--------- -------------------------------
1002106 CARTULINA
1034007 ESCUADRA PLASTICA
6007023 CUADERNO ECOLOGICO CUADRICULADO
7078090 CLIPS PLASTICOS COLOR C023
7078092 CLIPS PLASTICOS COLOR C045
11 rows selected.
• Operador NOT
El operador NOT se utiliza para indicar que no debe cumplirse una de las
condición de búsqueda. Tiene la forma general: NOT condición. La operación
es verdadera cuando se condición es falsa para los valores de la fila evaluada.
Ejemplo: Seleccionar los productos cuyo nombre no contiene la cadena LA ni

la cadena LO.

2* where not (nombre like '%LA%' or nombre like '%LO%');
CODIGO NOMBRE
--------- ----------------------------------------
1002106 CARTULINA
1100333 MARCADOR PUNTA FINA
1100334 MARCADOR PUNTA GRUESA
4555102 AGENDA MICKEY
4555104 AGENDA BARBY
9002004 PIZARRON
17 rows selected.
• Reglas de precedencia
Los operadores AND, OR, y NOT pueden utilizarse en una misma condición de
búsqueda. Los resultados de todas las condiciones se evalúan según el orden
determinado por la precedencia de operadores lógicos. Cuando los operadores
tienen igual precedencia se evalúan de izquierda a derecha. Pueden utilizarse
paréntesis para modificar el orden de evaluación.
El orden de evaluación es el siguiente:
1. Todos los operadores de comparación (=,<>,>,>=,<,<=,IN, LIKE,

BETWEEN, IS NULL).
2. Operador NOT
3. Operador AND
4. Operador OR
2.2.2. Cláusula ORDER BY
La cláusula ORDER BY aplicada a una sentencia SELECT permite indicar que

deben ordenarse las filas recuperadas. La cláusula ORDER BY es opcional, si
no se incluye, las filas recuperadas son mostradas en un orden indefinido.
Sintaxis

FROM tabla
WHERE condición
ORDER BY expresión [{ASC | DESC}] [,expresión ... ]
donde:
expresión indica una columna o combinación de columnas por cuyo

resultado se ordenan las filas obtenidas, ASC indica que el
ordenamiento es ascendente (default), DESC indica que el
ordenamiento es descendente. Cuando se ordena por más
de una expresión se entiende que la segunda ordena sobre
los valores repetidos de la primera, y así sucesivamente.
Las cláusulas ASC, DESC se aplican a cada expresión por
la que se ordena.
El ordenamiento depende del tipo de dato de la expresión o expresiones

incluidas en la cláusula ORDER BY. Orden numérico para datos de tipo
NUMBER, orden temporal para datos de tipo DATE, orden alfabético para
datos de tipos VARCHAR2. Los valores nulos se muestran últimos en las
secuencias ascendentes y primeros en las secuencias descendentes
Ejemplo: Seleccionar los proveedores ordenados por nombre.
SQL> select nombre, ciudad

2 from proveedores
3 order by nombre;
NOMBRE CIUDAD
------------------------------ ----------------
AGUSTIN FERNANDEZ Y ASOCIADOS Mar del Plata
AGUSTINEZ Y HERMANOS S.A. Bernal
ATALAYA S.R.L. Capital Federal
COMODINES Quilmes
COMODO S.R.L. Cordoba
LA PERUANA Capital Federal
LA SEXTA Cordoba
MIS LAPICES Munro
PARIS La Plata
PEREZ, PEREZ, Y RODRIGUEZ Capital Federal
ROCAMORA E HIJOS San Martin
RUTA S.A. Moreno
12 rows selected.
Ejemplo: Seleccionar los proveedores ordenados por ciudad y nombre.
SQL> select nombre, ciudad

2 from proveedores
3 order by ciudad, nombre;
NOMBRE CIUDAD
------------------------------ ---------------
AGUSTINEZ Y HERMANOS S.A. Bernal
ATALAYA S.R.L. Capital Federal
LA PERUANA Capital Federal
PEREZ, PEREZ, Y RODRIGUEZ Capital Federal
COMODO S.R.L. Cordoba
LA SEXTA Cordoba
PARIS La Plata
AGUSTIN FERNANDEZ Y ASOCIADOS Mar del Plata
RUTA S.A. Moreno
MIS LAPICES Munro
COMODINES Quilmes
ROCAMORA E HIJOS San Martin
12 rows selected.
Ejemplo: Seleccionar las órdenes de compra entregadas ordenando por la

fecha más reciente.

2 where fentrega is not null
3 order by fentrega desc;

--------- --------- ---------- ---------- --------- ---------- -
12 19-MAY-98 9 12 15-FEB-99 CONTADO S
11 13-NOV-97 8 11 15-NOV-98 CONTADO S
5 23-JAN-98 5 7 25-JAN-98 CREDITO S
10 02-OCT-97 8 11 25-JAN-98 CREDITO S
8 23-MAR-97 6 10 25-NOV-97 CREDITO S
9 28-AUG-97 6 11 25-SEP-97 CREDITO S
6 18-MAY-96 12 7 25-JUN-96 CONTADO S
7 12-DEC-95 12 8 27-DEC-95 CONTADO S
9 rows selected.
2.3. FUNCIONES DE FILA
Las funciones a nivel de fila permiten construir expresiones a partir de

columnas y valores constantes. Pueden utilizarse en la lista de valores a
seleccionar, en las condiciones de búsqueda, así como también en las
condiciones de ordenamiento. Las funciones de fila pueden tener argumentos
de entrada, y devuelven un valor para cada fila evaluada. Pueden combinarse
entre sí para obtener expresiones más complejas.
2.3.1. Operadores Aritméticos
Los operadores aritméticos son funciones numéricas que por su notación son
llamados operadores. Estos son + (suma), - (resta), * (multiplicación), /
(división). Tienen la precedencia usual, es decir, evalúan primero multiplicación
y división, y después suma y resta, y la misma puede ser modificada mediante
el uso de paréntesis.
Ejemplo: Seleccionar par la orden 1 el total comprado por renglón.

SQL> select nro_orden, nro_renglon, codigo_pro, precio *
cantidad
2 from renglones
3 where nro_orden = 1
4 order by nro_renglon;
NRO_ORDEN NRO_RENGLON CODIGO_PRO PRECIO*CANTIDAD

--------- ----------- ---------- ---------------
1 1 1000223 14.5
1 2 7078080 90
1 3 9002006 480
Ejemplo: Seleccionar para cada empleado, el 20% del salario anual.

SQL> select nombre, 12 * salario * 20 / 100 "20% del Salario
Anual"
2* from empleados;
NOMBRE 20% del Salario Anual

---------------------------------------- ---------------------
Perez Carlos Alberto 6240
Jaime Daniel 3600
Miranda Adriana 4200
Cucagna Karina 3600
Soria Laura 4800
Scorza Miguel 3600
Deluca Luis 4320
Cosio Alejandro 4560
Fernandez Maria Cristina 3120
Fernandez Sofia 3120
Rodriguez Carlos Alberto 6960
Marto Lima Fracesca 6960
Coronda Ana Laura 2160
Casaso Martin 3360
Martinez Javier Alberto 1680
Puan Sandra Maria 2640
Valle Alerce Maria 9360
Asalez Marcos 1680
18 rows selected.
2.3.2. Funciones de Caracteres
Las funciones de caracteres son aquellas que se aplican a datos o expresiones

de tipo carácter. El tipo de dato que devuelven depende de cada función. Un
caso particular es la concatenación que está disponible también como operador
infijo.
• Función CONCAT (expresión1, expresión2)
La función devuelve una cadena de caracteres resultante de la unión de las

expresiones expresión1 y expresión2. El operador infijo equivales es notado
como ||, en este caso la expresión resultante se obtiene como expresión1 ||
expresión2.
Ejemplo: Seleccionar cada proveedor seguido de su "Dirección, Ciudad".
SQL> select nombre, direccion || ' , ' || ciudad Direccion

2* from proveedores;
NOMBRE DIRECCION
------------------------------ ---------------------------------
ATALAYA S.R.L. Maipu 385 , Capital Federal
ROCAMORA E HIJOS Av. Caseros 3567 , San Martin
LA PERUANA Tagle 1945 , Capital Federal
RUTA S.A. Lacroze 892 , Moreno
COMODINES Olazabal 675 , Quilmes
LA SEXTA Capitan Muinez 4334 , Cordoba
AGUSTINEZ Y HERMANOS S.A. Puente Paricci 42 Of.45 , Bernal
PEREZ, PEREZ, Y RODRIGUEZ Cochabamba 1152 , Capital Federal
AGUSTIN FERNANDEZ Y ASOCIADOS Guido 675 , Mar del Plata
COMODO S.R.L. Olazabal 7878 , Cordoba
PARIS Julian Alvarez 1275 , La Plata
MIS LAPICES Cafe Paris s/n , Munro
12 rows selected.
• Función LOWER (expresión)
La función devuelve una cadena de caracteres resultante de la conversión de

todos los caracteres alfabéticos de expresión a minúsculas.
Ejemplo: Seleccionar para cada empleado su dirección seguida de la ciudad

en minúsculas.
SQL> select nombre, lower(direccion || ' , ' || ciudad)

Direccion
2 from proveedores;
NOMBRE DIRECCION
------------------------------ ---------------------------------
ATALAYA S.R.L. maipu 385 , capital federal
ROCAMORA E HIJOS av. caseros 3567 , san martin
LA PERUANA tagle 1945 , capital federal
RUTA S.A. lacroze 892 , moreno
COMODINES olazabal 675 , quilmes
LA SEXTA capitan muinez 4334 , cordoba
AGUSTINEZ Y HERMANOS S.A. puente paricci 42 of.45 , bernal
PEREZ, PEREZ, Y RODRIGUEZ cochabamba 1152 , capital federal
AGUSTIN FERNANDEZ Y ASOCIADOS guido 675 , mar del plata
COMODO S.R.L. olazabal 7878 , cordoba
PARIS julian alvarez 1275 , la plata
MIS LAPICES cafe paris s/n , munro
12 rows selected.
Ejemplo: Seleccionar para cada empleado su dirección en minúsculas seguida

de la ciudad.
SQL> select nombre, lower(direccion) || ' , ' || ciudad

Direccion
2 from proveedores;
NOMBRE DIRECCION
------------------------------ ---------------------------------
ATALAYA S.R.L. maipu 385 , Capital Federal
ROCAMORA E HIJOS av. caseros 3567 , San Martin
LA PERUANA tagle 1945 , Capital Federal
RUTA S.A. lacroze 892 , Moreno
COMODINES olazabal 675 , Quilmes
LA SEXTA capitan muinez 4334 , Cordoba
AGUSTINEZ Y HERMANOS S.A. puente paricci 42 of.45 , Bernal
PEREZ, PEREZ, Y RODRIGUEZ cochabamba 1152 , Capital Federal
AGUSTIN FERNANDEZ Y ASOCIADOS guido 675 , Mar del Plata
COMODO S.R.L. olazabal 7878 , Cordoba
PARIS julian alvarez 1275 , La Plata
MIS LAPICES cafe paris s/n , Munro
12 rows selected.
2.3.3. Funciones Numéricas
Las funciones numéricas son aquellas que se aplican a datos o expresiones de

tipo numérico. El tipo de dato que devuelven depende de cada función. Un
caso particular son los operadores aritméticos ya descriptos.
• Función ROUND (expresión, n)
La función redondea el resultado de expresión a n posiciones decimales. Si n

no se indica se redondea a cero posiciones decimales. Si n es negativo se
redondean posiciones enteras.
SQL> select codigo_pro, precio, round(precio)

2 from precios
3* where fvigencia like '%98';
CODIGO_PRO PRECIO ROUND(PRECIO)

---------- --------- -------------
1000223 2.05 2
1002025 3.8 4
1034007 1.93 2
1034108 1.1 1
1034219 4.5 5
1034311 2.1 2
4210003 1.52 2
4210004 1.5 2
6007023 1.5 2
6007034 1.5 2
6007045 1.4 1
6007055 1.4 1
6007066 1.4 1
7078080 .5 1
7078090 .6 1
15 rows selected.
• Función TRUNC (expresión, n)
La función trunca el resultado de expresión a n posiciones decimales. Si n no

se indica se trunca a cero posiciones decimales. Si n es negativo se truncan
posiciones enteras.
SQL> select codigo_pro, precio, trunc(precio)

2 from precios
3* where fvigencia like '%98';
CODIGO_PRO PRECIO TRUNC(PRECIO)

---------- --------- -------------
1000223 2.05 2
1002025 3.8 3
1034007 1.93 1
1034108 1.1 1
1034219 4.5 4
1034311 2.1 2
4210003 1.52 1
4210004 1.5 1
6007023 1.5 1
6007034 1.5 1
6007045 1.4 1
6007055 1.4 1
6007066 1.4 1
7078080 .5 0
7078090 .6 0
15 rows selected.
2.3.4. Funciones de Fechas
Las funciones de fechas son aquellas que se aplican a datos o expresiones de

tipo fecha. El tipo de dato que devuelven depende de cada función.
• Operadores de Fecha
ESTO ES ORACLE!!!
Los operadores de fecha permiten aplicar con notación infija, funciones de
fecha. Estas son:
Operación Tipo del Resultado Resultado
Fecha + Número Fecha Fecha obtenida de sumar la cantidad de
dias a la fecha inicial.
Fecha - Número Fecha Fecha obtenida de restar la cantidad de
dias a la fecha inicial.
Fecha - Fecha Número Cantidad de dias entre ambas fechas.
Ejemplo: Obtener la cantidad de dias entre la fecha de entrega y de emisión de

las órdenes entregadas.
SQL> select nro_orden, fentrega - forden dias

2 from ordenes
3* where fentrega is not null;
NRO_ORDEN DIAS
--------- ---------
3 2
5 2
6 38
7 15
8 247
9 28
10 115
11 367
12 272
9 rows selected.
• Función SYSDATE
La función devuelve la fecha del sistema.
Ejemplo: Obtener la diferencia de días entre la fecha de emisión de las

órdenes y la fecha actual para las ordenes emitidas en enero.
SQL> select nro_orden, forden, sysdate - forden

2 from ordenes
3* where forden like ‘%JAN%’;
NRO_ORDEN FORDEN SYSDATE-FORDEN

--------- --------- --------------
1 20-JAN-98 541.70095
2 20-JAN-98 541.70095
3 21-JAN-98 540.70095
4 22-JAN-98 539.70095
5 23-JAN-98 538.70095
13 18-JAN-99 178.70095
17 23-JAN-99 173.70095
18 23-JAN-99 173.70095
8 rows selected.
• Función MONTHS_BETWEEN (expresión1, expresión2)

La función devuelve la cantidad de meses entre expresión1 y expresión2. Si
expresión1 evalúa a una fecha menor que expresión2 el resultado es negativo.
Si la cantidad de meses entre ambas fechas no es exacto el resultado tiene
fracción decimal, la cual representa la fracción de días correspondiente.
Ejemplo: Seleccionar la cantidad de meses desde la fecha de emisión de las

órdenes de compra a la fecha para las ordenes emitidas en marzo.
SQL> select nro_orden, forden, months_between(sysdate,forden)
2* from ordenes where forden like ‘%MAR%’;
NRO_ORDEN FORDEN MONTHS_BETWEEN(SYSDATE,FORDEN)

--------- --------- ------------------------------
8 23-MAR-97 27.764599
2.3.5. Funciones Aplicables a Todos los Tipos de Datos
Las funciones que se describen a continuación son aplicables a datos de tipo

caracter, número, y fecha. En todos los casos los parámetros deben ser del
mismo tipo de dato.
• Función NVL (expresión1, expresión2)
La función evalúa la expresión expresión1, si la misma es nula entonces

devuelve expresión2, sino devuelve expresión1. Esta función opera como un
"traductor de valores nulos".
Ejemplo: Seleccionar los empleados solteros con su dirección. Aquellos en los
que no se indica piso poner la expresión "(casa)".
SQL> select nombre, calle||' '||numero||' '||nvl(piso,'(casa)')

Direccion
2* from empleados where estado_civil = 'SOLTERO';
NOMBRE DIRECCION
------------------------ ---------------------------
Perez Carlos Alberto Parana 555 (casa)
Cucagna Karina Forest 856 PB
Fernandez Maria Cristina Cordoba 4885 1
Coronda Ana Laura Rawson 123 (casa)
Martinez Javier Alberto Del Solar 32 (casa)
Asalez Marcos Sarandi 455 6
6 rows selected.
• Función GREATEST (expresión1, expresión2, ..., expresiónN)
La función evalúa cada expresión y devuelve el valor mayor de la lista. Antes

de la comparación, todos los valores de la lista son convertidos al tipo de dato
de la primera expresión.
• Función LEAST (expresión1, expresión2, ..., expresiónN)

La función evalúa cada expresión y devuelve el valor menor de la lista. Antes
de la comparación, todos los valores de la lista son convertidos al tipo de dato
de la primera expresión.
2.4. FUNCIONES DE GRUPO
Las funciones a nivel de grupo permiten construir expresiones a partir de

resultados que se calculan sobre un conjunto de filas. Este conjunto será
determinado por el grupo. Las funciones de grupo se utilizan en la cláusula
SELECT. Los grupos sobre los que actúan estas funciones están deterninados
por la cláusula GROUP BY. Puede expresarse un filtro sobre los datos
seleccionados a partir del resultado de una función grupo utilizando la cláusula
HAVING.
2.4.1. Funciones de Grupo
• Función AVG ([DISTINCT] expresión)
La función calcula el promedio de los valores de expresión, ignorando aquellos

que dan resultado nulo. Si se incluye la cláusula DISTINCT se eliminan los
valores duplicados antes de calcular el promedio. La evaluación de expresión
debe resultar en un valor numérico.
Ejemplo: Seleccionar el promedio de salarios de los empleados.
SQL> select avg(salario) from empleados;
AVG(SALARIO)
------------
1758.3333
• Función COUNT ([DISTINCT] expresión | *)
La función calcula la cantidad de filas para las que expresión resulta en un

valor no nulo. Si se incluye la cláusula DISTINCT se eliminan los valores
duplicados antes de calcular la cantidad. Si se utiliza * como expresión, se
cuentan todas las filas, incluyendo duplicados y valores nulos.
Ejemplo: Seleccionar la cantidad de empleados, y la cantidad de empleados

que tienen comisión.
SQL> select count(*), count(comision) from empleados;
COUNT(*) COUNT(P_COMISION)
--------- -----------------
18 10
• Función MAX ([DISTINCT] expresión)

La función calcula el máximo de los valores de expresión, ignorando aquellos
valores duplicados antes de calcular el máximo.
• Función MIN ([DISTINCT] expresión)
La función calcula el mínimo de los valores de expresión, ignorando aquellos

valores duplicados antes de calcular el mínimo.
• Función SUM ([DISTINCT] expresión)
La función calcula la suma de los valores de expresión, ignorando aquellos que

dan resultado nulo. Si se incluye la cláusula DISTINCT se eliminan los valores
duplicados antes de calcular la suma. La evaluación de expresión debe resultar
en un valor numérico.
Ejemplo: Calcular el total de la orden 1.
SQL> select sum(precio * cantidad)

2 from renglones
3* where nro_orden = 1;
SUM(P_REAL*Q_RENGLON)
---------------------
584.5
• Función STDDEV ([DISTINCT] expresión)
La función calcula la desviación estándar de los valores de expresión,

ignorando aquellos que dan resultado nulo. Si se incluye la cláusula DISTINCT
se eliminan los valores duplicados antes de calcular la desviación. La
evaluación de expresión debe resultar en un valor numérico.
• Función VARIANCE ([DISTINCT] expresión)
La función calcula la varianza de los valores de expresión, ignorando aquellos

valores duplicados antes de calcular la varianza. La evaluación de expresión
debe resultar en un valor numérico.
2.4.2. Cláusula GROUP BY
La cláusula GROUP BY permite dividir las filas seleccionadas en grupos sobre

los que aplicar las funciones descriptas. Si no se incluye esta cláusula, se
entiende implícitamente que el único grupo está conformado por todas las filas
seleccionadas.
Sintaxis
FROM tabla
WHERE condición
GROUP BY expresión [,expresión ... ]
ORDER BY lista_de_ordenamiento
donde:
expresión indica una columna o combinación de columnas por cuyo

resultado se agrupan las filas obtenidas, es decir que cada
grupo está conformado por combinaciones distintas de los
valores de agrupación.
Si se utilizan conjuntamente las cláusulas WHERE y GROUP BY, las filas son
eliminadas según la condición de búsqueda antes de formar los grupos. Por
defecto, las filas se ordenan en forma ascendente de acuerdo a la lista GROUP
BY. Esto puede modificarse utilizando la cláusula ORDER BY.
Se requiere incluir una expresión GROUP BY por cada expresión incluida en la

lista SELECT a la que no se haya aplicado una función de grupo.
Ejemplo: Seleccionar el total de las ordenes 1,2 y 4.
SQL> select nro_orden, sum(precio * cantidad) total

2 from renglones where nro_orden in (1,2,4)
3* group by nro_orden;
NRO_ORDEN TOTAL
--------- ---------
1 584.5
2 569.4
4 1055
2.4.3. Cláusula HAVING
La cláusula HAVING se utiliza para eliminar grupos. No es posible eliminar filas

a partir del resultado de un grupo en la cláusula WHERE. La cláusula HAVING
se aplica una vez calculados los grupos y sus resultados.
Sintaxis

FROM tabla
WHERE condición_where
GROUP BY expresión [,expresión ... ]
HAVING condición_having
donde:
condición_having es una expresión lógica, la cual se evalúa

para cada grupo resultante. Serán mostradas
sólo aquellos grupos para los cuales la
condición resulte verdadera.
Oracle evaluará una sentencia SELECT de la siguiente manera:
• Se eliminan las filas según la cláusula WHERE.

• Se forman los grupos según la cláusula GROUP BY.
• Se calculan los resultados por grupo.
• Se eliminan los grupos según la cláusula HAVING.
• Se ordenan los grupos que hayan quedado según al cláusula ORDER BY.
Ejemplo: Seleccionar el precio promedio de cada producto durante los años

1997 y 1998. Mostrar sólo aquellos productos cuyos precios oscilen entre 2 y 5
pesos.
SQL> select codigo_pro, avg(precio)

2 from precios
3 where to_number(to_char(fvigencia,'yyyy')) in (1997,1998)
4 group by codigo_pro
5* having min(precio) > 2 and max(precio) < 5;
CODIGO_PRO AVG(PRECIO)
---------- -----------
1000224 4.2
1002025 3.8
1034219 4.5
1100333 2.1
1100334 2.1
2.5. RECUPERACIÓN DE DATOS A PARTIR DE VARIAS TABLAS
2.5.1. Combinación JOIN
Hasta ahora se han descripto las características de la sentencia SELECT

teniendo en cuenta la recuperación de datos a partir de una tabla de la base de
datos. Es posible recuperar datos a partir de varias tablas, en este caso será
necesario proveer una condición de join, la cual indicará la forma de combinar
los datos de las tablas seleccionadas. Usualmente estas condiciones están
dadas por la relación clave primaria - clave foránea.
Toda vez que en la cláusula FROM se indique más de una tabla, Oracle calcula
para la evaluación de las filas el producto cartesiano de dichas tablas. No todas
estas combinaciones tienen sentido, es por ello que se proveen condiciones de
join para eliminar filas. No es obligatorio incluir condiciones de join en la
cláusula WHERE.
Sintaxis

FROM tabla1 [, tabla2, ..., tablaN]
WHERE condición_where
donde:
• Los nombres de las columnas deben estar calificados con el nombre

de la tabla a la que pertenece la columna, si es que hay ambigüedad
en los nombres, tanto en la lista SELECT como los restantes lugares
donde sean incluidas. Es recomendable esta práctica aunque no
hayan nombres duplicados ya que facilita la lectura de la sentencia y
mejora la performance de la misma.
• Es posible incluir aquí agrupaciones de datos. No se muestran en la
sintaxis para simplificar la visualización de la cláusula.
• Si se incluyen N tablas en la cláusula FROM, deberían incluirse al
menos N -1 condiciones de join en la cláusula WHERE (además de
las requeridas para eliminar filas). Si en algún caso la relación entre
las tablas es compuesta entonces las condiciones de join pueden ser
más que las mencionadas.
• Las condiciones de join no son únicamente por igualdad, si bién esto
es lo más usual, especialmente en el caso de relación entre clave
primaria y clave foránea. Una condición por igualdad también es
conocida como equijoin, mientras que una condición por desigualdad
es llamada non-equijoin, una condición de una tabla consigo misma
self-join (usualmente una clave foránea que apunta a la misma tabla).
• Para simplificar la escritura es posible utilizar un alias o sinónimo
temporario para el nombre de las tablas. En este caso la calificación
de los nombres de las columnas se hace con el alias. El alias puede
ser cualquier cadena de caracteres que no contenga caracteres
raros. Usualmente se utilizan nombres muy breves, pues el objetivo
es simplificar la escritura de la cláusula.
Ejemplo: Seleccionar los precios de lista de 1997 mayores a 7 junto con el

código y descripción de cada producto.
SQL> select codigo, nombre, precio

2 from productos, precios
3 where productos.codigo = precios.codigo_pro
4 and fvigencia like '%97'
5* and precio > 7
CODIGO NOMBRE PRECIO

--------- ---------------------------------------- ---------
1002024 CUADERNO 100 HOJAS 7.75
1002024 CUADERNO 100 HOJAS 7.8
6008059 MARCADOR PIZARRA BLANCA 10.25
2.5.2. Combinación OUTER JOIN

Cuando se incluye una condición de join en una cláusula SELECT, las filas
serán eliminadas por dicha condición. En los casos en que refleja una relación
clave primaria - clave foránea, la condición de join elimina las filas que no
tengan otras filas relacionadas (en la tabla subordinada).
Ejemplo: Seleccionar los proveedores 10, 11 y 12 con los números de órdenes

emitidas.
SQL> select p.codigo, p.nombre, o.nro_orden

2 from proveedores p, ordenes o
3 where p.codigo = o.codigo_prv and p.codigo in (10,11,12);
CODIGO NOMBRE NRO_ORDEN

--------- ------------------------------ ---------
12 MIS LAPICES 6
12 MIS LAPICES 7
12 MIS LAPICES 17
11 PARIS 13
El proveedor 10 no aparece en el ejemplo debido a que no tiene órdenes

emitidas, es decir que no verifica la condición de join p.codigo = o.codigo_prv.
Para solucionar una situación tal se requiere utilizar el operador OUTER JOIN
que indica que una fila sea mostrada aún cuando no hayan filas que cumplan la
condición de join. El operador OUTER JOIN, que es un signo (+) (más entre
paréntesis) se aplica a la expresión a la cual podría faltarle información, en este
caso los empleados.
Ejemplo: Seleccionar los proveedores 10, 11 y 12 con los números de órdenes

emitidas.
SQL> select p.codigo, p.nombre, o.nro_orden

2 from proveedores p, ordenes o
3 where p.codigo = o.codigo_prv (+)
4* and p.codigo in (10,11,12)
CODIGO NOMBRE NRO_ORDEN

--------- ------------------------------ ---------
10 COMODO S.R.L.
11 PARIS 13
12 MIS LAPICES 6
12 MIS LAPICES 17
12 MIS LAPICES 7
2.5.3. Subconsultas
La subconsulta es una forma que toma la cláusula SELECT cuando una

condición se escribe a partir de otra sentencia SELECT. La misma puede
recuperar datos de otras tablas que la sentencia principal. Las subconsulta
puede ser incluida en las cláusulas WHERE, HAVING, y FROM (V7.3 o mayor),
además de las sentencias de modificación y definición de datos aún no
descriptas. Una subconsulta es también conocida como select anidado o sub-
select.
Sintaxis
SELECT lista_select
FROM lista_tablas
WHERE expresión operador (sentencia_select)
ORDER BY lista_ordenamiento
donde:
expresión es una expresión simple o una lista.

sentencia_select es una sentencia SELECT como las descriptas que
no contiene cláusula ORDER BY. La misma debe
retornar tantas columnas como elementos tiene la
lista expresión.
operador es un operador de comparación. Si se utiliza un
operador de fila simple (>, >=, <, <=, =, !=) entonces
la sentencia SELECT interna debe retornar
exactamente una fila. Si se utiliza un operador de
filas múltiples (IN, NOT IN) entonces la sentencia
SELECT interna puede retornar más de una fila.
La condición de búsqueda expresión operador (sentencia_select) evalúa a

verdadero si las filas retornadas por la sentencia SELECT interna cumplen la
condición.
La sentencia SELECT interna se evalúa primero si es que no tiene relación con

la externa, es decir, si no incluye ninguna referencia a elementos de dicha
sentencia. De lo contrario se evalúa una vez para cada fila recuperada por la
sentencia externa.
Una subconsulta puede contener otra subconsulta. Oracle no impone

restricciones en este sentido.
Ejemplo: Seleccionar los producto no incluidos en ninguna orden.

SQL> select codigo, nombre
2 from productos
3 where codigo not in
4* (select codigo_pro from renglones);
CODIGO NOMBRE
--------- -------------------------
1034007 ESCUADRA PLASTICA
4452023 RESMA PAPEL BLANCO A4
6008059 MARCADOR PIZARRA BLANCA
8 rows selected.
Ejemplo: Obtener los precios de los productos que empiezan con 100 cuya
fecha de vigencia es la más actual.
SQL> select o.codigo_pro, o.precio, o.fvigencia
2 from precios o
3 where o.codigo_pro like '100%'
4 and o.fvigencia = (select max(i.fvigencia)
5 from precios i
6* where i.codigo_pro = o.codigo_pro);

---------- --------- ---------
1000223 2.05 12-JAN-98
1000224 4.2 02-JAN-97
1000225 5.2 02-JAN-96
1002024 7.8 23-DEC-97
1002025 3.85 02-JAN-99
1002106 .59 18-NOV-97
6 rows selected.
3. MODIFICACIÓN DE DATOS
La modificación de datos se lleva a cabo mediante la ejecución de las

sentencias de manipulación de datos. Estas sentencias, llamadas también DML
(Data Manipulation Language) son aquellas que permiten modificar los datos
guardados en las tablas de la base de datos, mediante la inserción de nuevas
filas (sentencia INSERT), la modificación de filas existentes (sentencia
UPDATE), y la eliminación de filas existentes (sentencia UPDATE).
La única forma de manipular datos en una base de datos Oracle es a través de

estas sentencias, es decir que no es posible alcanzar ni modificar datos sino
mediante el uso del lenguaje SQL.
3.1. SENTENCIA INSERT
La sentencia INSERT permite agregar filas a una tabla de la base de datos.
3.1.1. Inserción de una Fila
Sintaxis
INSERT INTO tabla [ (columna [,columna ...] )]

VALUES (valor [,valor...] )
donde:
tabla es el nombre de una tabla de la base de datos.

columna es el nombre de una columna de la tabla. No se requiere
incluir una lista de columnas, o una lista completa de
columnas.
valor es un valor a insertar en la columna correspondiente.
La asociación columna-valor es posicional. Si no se incluye una lista de
columnas, se asume que la lista es completa y en el orden de descripción de la
tabla (comando describe). Si se incluye una lista de columnas incompleta, se
insertará el valor default o, en ausencia de éste, el valor nulo en dicha columna.
Los valores deben cumplir con los tipos de datos definidos.
Los valores constantes de tipo carácter o fecha deben ir encerrados entre

comillas simples (' ').
Siempre que se intenta insertar una fila de datos en una tabla, la base de datos
Oracle comprueba todos los tipos de datos, rangos, y restricciones de
integridad existentes sobre dicha tabla. Si una de estas validaciones fracasa, la
fila no es insertada.
Ejemplo: Insertar un nuevo empleado para el departamento 2.
SQL> insert into empleados

2 (codigo, nombre, calle, numero, piso, depto, sexo,
3 tipo_documento, nro_documento, estado_civil, salario,
4 comision, codigo_dep)
5 values
6 (29, 'RODRIGUEZ JUAN CARLOS', 'PUAN', '303', '8', 'J', 'M',
7 'CI', 7444545, 'DIVORCIADO', 800,
8* NULL, 2);
1 row created.
Ejemplo: Insertar una nueva orden de compra.
SQL> insert into renglones

2 (nro_orden, nro_renglon, codigo_pro, precio, cantidad)
3 values
4* (26, 1, 9002004, 3.50, 2);
insert into renglones
*
ERROR at line 1:
ORA-02291: integrity constraint (CURSO.REN_PK) violated - parent
key not found
Ha fallado la clave foránea, debe insertarse primero la fila correspondiente a la

tabla ORDEN, y luego las correspondientes a la tabla RENGLON.
SQL> insert into ordenes

2 (nro_orden, forden, codigo_prv, codigo_emp, tipo_pago,
3 completa)
4 values
5 (26, trunc(sysdate), 2, 1, 'CONTADO',
6* 'N');
1 row created.
SQL> insert into renglones values
2 (26, 1, 8080803, 3.5, 2);
1 row created.

2 (26, 2, 6008058, 0.80, 5);
1 row created.
3.1.2. Inserción de un Conjunto de Filas
Sintaxis
INSERT INTO tabla [ (columna [,columna ...] )]

sentencia_select
donde:
sentencia_select es una sentecia cuyas filas resultantes serán

insertadas en la tabla.
La asociación columna-valor también es posicional. La sentencia SELECT

deberá devolver las columnas necesarias según la lista especificada.
En este caso se inserta cada fila retornada por la sentencia SELECT. La base
de datos Oracle verifica igualmente los tipos de datos, rangos, y restricciones
de integridad. Si la validación de una fila resulta en una falla, la sentencia de
inserción no se ejecuta, es decir que no se inserta ninguna fila aunque la que
hubiera fallado fuera la última.
3.2. SENTENCIA UPDATE
La sentencia UPDATE permite modificar filas de una tabla de la base de datos.
3.2.1. Modificación de Filas
Sintaxis
UPDATE tabla
SET columna = valor [,columna = valor...]
WHERE condición
donde:

columna es el nombre de una columna de la tabla.
valor es un valor a insertar en la columna correspondiente,
reemplazando el anterior.
condición es una condición de búsqueda
La cláusula SET indica las columnas que serán modificadas e igualadas a su

nuevo valor, las restantes columnas conservan su valor anterior. Si la
modificación provoca la violación de alguna restricción de integridad, la
sentencia falla y no se modifica ninguna fila.
La cláusula WHERE indica cuales filas serán modificadas. Si no se incluye,

entonces se actualizan todas las filas de la tabla.
Ejemplo: Modficar la orden de compra 2 para indicar que ha sido entregada en

su totalidad.
SQL> update ordenes

2 set fentrega = trunc(sysdate),
3 completa = 'S'
4 where nro_orden = 2;
1 row updated.
Ejemplo: Subir la comisión de los empleados del departamento 2 en un 10%.
SQL> update empleados

2 set comision = comision * 1.1
3 where codigo_dep = 2
4* and comision is not null;
3 rows updated.
3.3. SENTENCIA DELETE
La sentencia DELETE permite eliminar filas de una tabla de la base de datos.
3.3.1. Eliminación de Filas
Sintaxis
DELETE [FROM] tabla

WHERE condición
donde:

condición es una condición de búsqueda
La cláusula WHERE indica cuales filas serán modificadas. Si no se incluye,

entonces se eliminan todas las filas de la tabla. La eliminación de todas las filas
de una tabla no implica la eliminación de su definición en la base de datos (es
decir, en el Diccionario de Datos).
Si la eliminación provoca la violación de alguna restricción de integridad, la

sentencia falla y no se elimina ninguna fila.
3.4. CONTROL DE LA TRANSACCIÓN
Las sentencias descriptas hasta ahora provocan cambios en la base de datos.

Estos cambios no son escritos en forma permanente a la base de datos, y sólo
son visibles a la conexión del usuario que los realizó hasta que sean
confirmados o rechazados (con excepción de la sentencia TRUNCATE). Las
sentencias que permiten confirmar o rechazar las modificaciones de los datos
son las sentencias de control de transacción.
Una transacción es un conjunto de sentencias DML cuya ejecución sólo tiene

sentido si se ejecutan en su totalidad, es decir que llevan a cabo un cambio en
los datos en forma consistente. Por ejemplo, la inserción de una orden de
compra sólo tienen sentido si se insertan los datos de cabecera, así como
también todos los renglones, y no existe la posibilidad de que pueda quedar
insertada a medias.
Durante una transacción las filas afectadas son bloqueadas a otros usuarios
para evitar inconsistencias.
Las sentecias de control de transacción COMMIT y ROLLBACK determinan el

comienzo y terminación de las transacciones en curso. Una transacción
comienza con la conexión a la base de datos y termina con la ejecución de una
sentencia COMMIT o ROLLBACK, la cual da comienzo a una nueva
transacción. El proceso continúa de esta manera hasta la desconexión de la
base de datos que cierra la última transacción en curso.
• COMMIT
La sentecia COMMIT hace permanentes los cambios pendientes, finalizando la

transacción en curso. Es decir que luego de la ejecución de la sentencia, los
cambios han sido escritos a la base de datos y ya no es posible recuperar el
estado anterior. Todos los usuarios con acceso a los datos pueden ver ahora
los cambios, y se eliminan los bloqueos que afectaban a las filas. Los
savepoints contenidos en la transacción son borrados.
Un COMMIT puede ejecutarse en forma automática por la ejecución de una

sentencia DDL (Data Definition Language), o por la ejecución de una sentencia
DCL (Data Control Language). En SQL*Plus puede ejecutarse un COMMIT en
forma implícita debido a que el parámetro AUTOCOMMIT tiene valor ON, lo
que provoca que cada sentencia DML ejecute un COMMIT a continuación, o
por la salida normal de la herramienta (comando EXIT o QUIT).
Ejemplo: Insertar una nueva orden de compra.

SQL> insert into ordenes values
2 (28, trunc(sysdate), 4, 1, null, 'CREDITO', 'N');
1 row created.

2 (28, 1, 4555104, 0.32, 20);
1 row created.

2 (28, 2, 1034311, 1.5, 15);
1 row created.

2 (28, 3, 1034219, 4.7, 23);
1 row created.
SQL> commit;
Commit complete.
SQL> select o.nro_orden orden, o.forden fecha,

2 o.codigo_prv prov, o.tipo_pago pago,
3 r.nro_renglon it, r.codigo_pro prod,
4 r.precio, r.cantidad
5 from ordenes o, renglones r
6 where o.nro_orden = r.nro_orden
7 and o.nro_orden = 28;
ORDEN FECHA PROV PAGO IT PROD PRECIO CANTIDAD

----- --------- ---- ------- -- -------- ------ --------
28 15-JUL-99 4 CREDITO 3 1034219 4.7 23
28 15-JUL-99 4 CREDITO 2 1034311 1.5 15
28 15-JUL-99 4 CREDITO 1 4555104 .32 20
• ROLLBACK
La sentecia ROLLBACK deshace los cambios pendientes, finalizando la

transacción en curso. Es decir que luego de la ejecución de la sentencia, los
cambios han sido descartado y ha sido recuperado el estado anterior de los
datos. Se eliminan los bloqueos que afectaban a las filas. Los SAVEPOINTS
contenidos en la transacción son borrados.
Si se ejecuta una sentencia ROLLBACK TO SAVEPOINT se deshacen los

cambios pendientes entre el SAVEPOINT y la sentencia ROLLBACK. En este
caso la transacción queda abierta y no se eliminan todos los SAVEPOINTS.
Un ROLLBACK puede ejecutarse en forma automática por la terminación

anormal de una sesión en SQL*Plus o por la detección de una falla del sistema
(por ejemplo, detección de un deadlock).
Ejemplo: Dar de baja el empleado 4.

SQL> delete from empleados;
18 rows deleted.
SQL> rollback;
Rollback complete.
SQL> delete from empleados

2 where codigo = 4;
1 row deleted.
4. ESTRUCTURAS DE DATOS
La creación, modificación y eliminación de estructuras de datos se lleva a cabo

mediante la ejecución de las sentencias de definición de datos. Estas
sentencias, llamadas también DDL (Data Definition Language) son aquellas
que permiten crear nuevas estructuras de datos como ser tablas, vistas,
índices, secuencias, y sinónimos, guardados en las tablas del diccionario de
datos (sentencia CREATE), la modificación de estructuras existentes (sentencia
ALTER), y la eliminación de estructuras existentes (sentencia DROP).
La única forma de manipular estructuras en una base de datos Oracle es a

través de estas sentencias, es decir que no es posible alcanzar ni modificar las
estructuras de datos sino mediante el uso del lenguaje SQL.
Las sentencias DDL ejecutan un COMMIT implícito antes y después de su

ejecución, es decir que no tienen posibilidad de ser deshechas. Incluso en el
caso de falla ejecutan un primer COMMIT por lo que luego de ejecución
siempre se está en una nueva transacción. Cualquier modificación de datos
pendiente es confirmada.
Todas las estructuras de datos son creadas bajo algún esquema. Un esquema
es precisamente una colección de objetos, los cuales hacen referencia a los
datos en una base de datos. Cuando un usuario quiere hacer referencia a un
objeto debe hacerlo por su nombre, en este caso se asume que el mismo está
en su propio esquema. Si un usuario quiere hacer referencia a objetos que
están en otro esquema, debe calificarse el nombre del objeto con el del
esquema.
4.2. TABLAS
Una tabla es la estructura que permite almacenar datos en la base. Una

tabla tiene un nombre que la identifica y que no debe repetirse dentro del
esquema de su dueño, y un conjunto de columnas, cada una con
nombre, obligatoriedad y tipo de dato.
4.2.1. Creación de Tablas

Para crear una tabla se debe tener privilegio CREATE TABLE. Antes de llevar a
cabo la creación de una tabla es muy conveniente planificar los siguientes
elementos:
• nombre de la tabla
• nombre de cada columna
• tipo de datos almacenados en cada columna
• tamaño de cada columna
• información adicional (restricciones, comentarios, propiedades de
almacenamiento, etc.)
El nombre de una tabla debe tener una longitud máxima de 30 caracteres,

comenzando con un carácter alfabético, y utilizando caracteres alfanuméricos y
subrayado. Se considera que el uso de mayúsculas y minúsculas es indistinto.
Las definición de tamaño de las columnas no incrementa los requisitos de

espacio en disco para las tablas, pues cada tabla consume tanto espacio como
sea necesario para mantener sus filas.
Sintaxis
CREATE TABLE [esquema.]nombre

(columna tipo_dato [DEFAULT expresión] [restricción_columna],
...
[restricción_tabla],
...)
donde:
esquema indica el usuario bajo el cual se crea la tabla.

nombre indica el nombre de la tabla.
columna indica el nombre de cada columna.
tipo_dato indica el tipo de dato de cada columna.
DEFAULT expresión indica un valor por defecto si la columna no es
incluida en la sentencia INSERT.
restricción_columna indica una restricción de integridad a nivel de
la columna.
restricción_tabla indica una restricción de integridad a nivel de
la tabla.
La expresión incluida en la cláusula DEFAULT puede ser un literal, una fórmula,

o una referencia a las funciones SYSDATE o USER. No puede ser el nombre
de otra columna o pseudocolumna. Si no se incluye una expresión DEFAULT
se asume NULL. La expresión DEFAULT es utilizada cuando la columna no es
nombrada en una sentencia INSERT.
Los tipos de datos que pueden utilizarse son los siguientes:

ESTO ES ORACLE!!!
NUMBER [(L[,D])] Numérico de (L - D) enteros y D decimales.
CHAR [(L)] Alfanumérico de longitud fija L (hasta 255).
VARCHAR2 [(L)] Alfanumérico de longitud variable, L como
máximo (hasta 2000).
DATE Fecha y hora
LONG Alfanumérico variable de hasta 2 Gbytes. Se
acepta como máximo una olumna de tipo
LONG por tabla.
RAW Binario de hasta 2000.
LONG RAW Binario de hasta 2 Gbytes.
Ejemplo: Crear una tabla para guardar los proyectos en que trabaja cada
departamento. Cada proyecto tiene código, descripción, presupuesto, fecha de
inicio y de finalización, y una marca que indica si el proyecto está cerrado. Por
defecto, el presupuesto se inicializa en 0, con fecha de inicialización igual a la
del sistema.
SQL> CREATE TABLE proyectos (

2 codigo NUMBER(4) NOT NULL
3 nombre VARCHAR2(30) NOT NULL,
4 codigo_dep NUMBER(3),
5 presupuesto NUMBER(11,2)
6 DEFAULT 0
7 finicio DATE
8 DEFAULT sysdate NOT NULL,
9 ffinalizacion DATE,
10 cerrado VARCHAR2(1)
11 DEFAULT 'N' NOT NULL
12* );
Table created.
SQL> desc proyectos

Name Null? Type
------------------------------- -------- ----
CODIGO NOT NULL NUMBER(4)
NOMBRE NOT NULL VARCHAR2(30)
CODIGO_DEP NUMBER(3)
PRESUPUESTO NUMBER(11,2)
FINICIO NOT NULL DATE
FFINALIZACION DATE
CERRADO NOT NULL VARCHAR2(1)
Ejemplo: Crear una tabla para guardar los proyectos en que trabaja cada
empleado. La tabla debe registrar fecha de ingreso al proyecto, que por defecto
es la fecha del sistema.
SQL> CREATE TABLE empleados_proyectos (

2 codigo_dep NUMBER(3) NOT NULL,
3 codigo_emp NUMBER(6) NOT NULL,
4 codigo_pry NUMBER(4) NOT NULL,
5 fingreso DATE
6 DEFAULT SYSDATE NOT NULL,
7* );
Table created.
SQL> desc empleados_proyectos
Name Null? Type
------------------------------- -------- ----
CODIGO_DEP NOT NULL NUMBER(3)
CODIGO_EMP NOT NULL NUMBER(6)
CODIGO_PRY NOT NULL NUMBER(4)
FINGRESO NOT NULL DATE
4.2.2. Restricciones de Integridad
Las restricciones de integridad definidas para una tabla permiten garantizar el

cumplimiento de reglas asociadas a la tabla cada vez que una fila es insertada,
modificada o eliminada. Si la restricción no se cumple la operación falla y no se
realiza.
Los tipos de restricciones de integridad que pueden utilizarse son los

siguientes:
NOT NULL Indica que la columna no puede contener un valor

nulo.
UNIQUE Indica que los valores de la/s columna/s deben ser
únicos.
PRIMARY KEY Indica que los valores de la/s columna/s identifican
en forma unívoca a cada fila de la tabla.
FOREIGN KEY Indica que los valores de la/s columna/s deben
coincidir con la clave primaria de otra tabla.
CHECK Indica una condición que debe cumplirse para cada
fila de la tabla.
Las restricciones pueden definirse a nivel de columna o de tabla, en cada caso

la sintaxis es diferente. Pueden definirse junto con la tabla a la que pertenecen,
o ser agregadas posteriormente. En cualquier caso pueden crearse y
habilitarse conjuntamente, o crearse deshabilitadas. En cualquier momento
puede habilitarse o deshabilitarse una restricción de integridad.
Cuando la restricción de integridad se define a nivel de columna, la misma hace

referencia a una única columna de la tabla, implíctamente aquella en la cual se
define. Todas las restricciones pueden definirse a este nivel.
Sintaxis
[CONSTRAINT nombre] tipo_restricción {[referencia (columna_ref)] |

(condición)}
donde:
nombre indica el nombre de la restricción.

tipo_restricción indica el tipo de la restricción.
referencia indica, para el caso de una restricción de tipo
FOREIGN KEY, el nombre de la tabla a la cual hace
referencia. En este caso, como tipo de restricción se
indica la palabra REFERENCES.
columna_ref indica, para el caso de una restricción de tipo
FOREIGN KEY, el nombre de la columna a la cual
hace referencia.
condición indica, para el caso de una restricción de tipo
CHECK, la condición que debe cumplirse para los
valores de la columna.
Ejemplo: Volver a crear la tabla para guardar los proyectos creando las
restricciones de integridad necesarias. Garantizar además que el presupuesto,
dado que es un importe, sea siempre positivo.

2 codigo NUMBER(4) NOT NULL
3 CONSTRAINT pry_pk PRIMARY KEY,
5 codigo_dep NUMBER(3)
6 CONSTRAINT pry_dep_fk REFERENCES departamentos (codigo),
8 DEFAULT 0
9 CONSTRAINT pry_ck CHECK (presupuesto >= 0),
10 finicio DATE
14 DEFAULT 'N' NOT NULL
15 CONSTRAINT pry_ck2 CHECK (cerrado IN ('S','N'))
16* );
Cuando la restricción de integridad se define a nivel de tabla, la misma puede

hacer referencia a una o más columnas de la tabla, las cuales se mencionan en
la definición. A este nivel pueden definirse todas las restricciones excepto la
restricción NOT NULL, que exclusiva de columna.
Sintaxis
[CONSTRAINT nombre] tipo_restricción {(columna, ...) [REFERENCES

referencia (columna_ref, ...) [ON DELETE CASCADE]] |
(condición)}
donde:
nombre indica el nombre de la restricción.

tipo_restricción indica el tipo de la restricción.
columna indica cada columna sobre la que se define la
restricción.
referencia indica, para el caso de una restricción de tipo
FOREIGN KEY, el nombre de la tabla a la cual
hace referencia.
columna_ref indica, para el caso de una restricción de tipo
FOREIGN KEY, el nombre de cada columna a
la cual hace referencia.
condición indica, para el caso de una restricción de tipo
CHECK, la condición que debe cumplirse para
los valores de la columna.
Las definiciones de las restricciones se almacenan en el diccionario de datos.

Para hallarlas es importantes darles un nombre significativo. Si no se asigna un
nombre, Oracle asigna uno según la siguiente regla: asigna el nombre
SYS_Cn, donde n es un número entero. Los nombres de las restricciones de
integridad son nombres existentes en el esquema de creación, por ello deben
ser nombres únicos.
Cuando se define una restricción de tipo PRIMARY KEY sobre una tabla, se
garantiza que la combinación de valores de las columnas que la componen no
se repitan en la tabla, así como también que ninguna de las columnas de la
restricción tengan valores nulos.
La restricción de tipo FOREIGN KEY indica que se está construyendo una

relación de padre-hijo entre dos tablas.
Ejemplo: Volver a crear la tabla de proyectos definiendo sus restricciones de

integridad a nivel de tabla e indicando que cuando se elimine un departamento
deben eliminarse conjuntamente todos los proyectos.

2 codigo NUMBER(4) NOT NULL,
4 codigo_dep NUMBER(3),
6 DEFAULT 0,
7 finicio DATE
11 DEFAULT 'N' NOT NULL,
12 CONSTRAINT pry_pk PRIMARY KEY (codigo),
13 CONSTRAINT pry_ck CHECK (presupuesto >= 0),
14 CONSTRAINT pry_ck2 CHECK (cerrado IN ('S','N')),
15 CONSTRAINT pry_dep_fk FOREIGN KEY (codigo_dep)
16 REFERENCES departamentos (codigo) ON DELETE CASCADE
17* );
Table created.
4.2.3. Creación de una Tabla a partir de una Consulta
Es posible crear una tabla partiendo de una consulta a la base de datos, es

decir, de una sentencia SELECT. En este caso la tabla es creada con las
columnas y las filas seleccionadas en la sentencia.
Sintaxis
CREATE TABLE [esquema.]nombre [(columna, ...)] AS consulta
donde:
esquema indica el usuario bajo el cual se crea la tabla.
columna indica el nombre dado a cada columna.
consulta indica una sentencia SELECT.
Si no se indica una lista de nombres de columnas, la tabla será creada con los
nombres indicados en la sentencia SELECT. Puede indicarse también un valor
por defecto. El tipo de dato de la columna se asume a partir del valor
seleccionado.
La única restricción de integridad heredada de la tabla a partir de la cual se

seleccionan los datos es la restricción NOT NULL.
Ejemplo: Crear una tabla para guardar los productos dados de baja.
SQL> create table productos_baja as select * from productos

where 1 1 = 2;
Table created.
SQL> desc productos_baja

Name Null? Type
------------------------------- -------- ----
CODIGO NOT NULL NUMBER(8)
NOMBRE NOT NULL VARCHAR2(40)
4.2.5. Eliminación de Tablas
Puede eliminarse la definición de una tabla mediante la sentencia DROP

TABLE. Para ello se debe ser el dueño de la tabla o poseer los privilegios
adecuados (DROP ANY TABLE). Al eliminar una tabla, se eliminan todos sus
datos y todos sus objetos dependientes.
Sintaxis
DROP TABLE [esquema.]nombre [CASCADE CONSTRAINTS]
donde:
esquema indica el usuario dueño de la tabla.

CASCADE CONSTRAINTS indica que se eliminan las restricciones
de integridad dependientes.
Debe tenerse en cuenta que al eliminar una tabla, otras estructuras de la base
de datos podrían dejar de ser válidas (por ejemplo, vistas, sinónimos, etc.).
Ejemplo: Eliminar la tabla proyectos.
SQL> drop table proyectos;
Table dropped.

Escuela SQL intro8SinOracle

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Escuela SQL intro8SinOracle

Încărcat de

Drepturi de autor:

Formate disponibile

1.

1.1. LENGUAJE SQL

SQL es un lenguaje estándar para bases de datos relacionales. Una base de

Para acceder a la base de datos, se ejecuta un comando del Lenguaje de

• El American National Standards Institute (ANSI) ha adoptado el SQL como

1.1.1. Características del Lenguaje SQL

El lenguaje SQL puede ser usado por cualquier tipo de usuario.

El lenguaje SQL no es un lenguaje procedural, es decir, las sentencias no dicen

El lenguaje SQL reduce la cantidad de tiempo requerido para crear y mantener

El lenguaje SQL es similar al idioma inglés.

1.1.2. Sentencias SQL

Sentencias de recuperación de datos SELECT

2.1. SENTENCIA SELECT

Una sentencia SELECT permite recuperar los datos almacenados en la Base

SELECT sirve para elegir las columnas a recuperar, DISTINCT

FROM especifica el nombre de una tabla (obligatorio)

Ejemplo: Seleccionar todas las columnas y todas las filas de la tabla

SQL> select * from departamentos;

Ejemplo: Seleccionar las columnas codigo_prov y nombre, y todas las filas de

SQL> SELECT codigo prov, nombre

Por default el título de una columna es el nombre de la misma en la tabla. Para

• Si la expresión a usar como título contuviera espacios, caracteres

Ejemplo: Seleccionar el nombre y dirección de cada proveedor.

SQL> select nombre Proveedor, direccion "Direccion del

PROVEEDOR Direccion del Proveedor

2.1.2. Cláusula DISTINCT

La cláusula DISTINCT aplicada a una sentencia SELECT permite indicar que

Ejemplo: Seleccionar las fechas en que se han emitido órdenes de compra.

SQL> select distinct forden

Ejemplo: Seleccionar las fechas en que se han emitido órdenes de compras

SQL> select distinct forden, codigo_prv

2.2. CONDICIONES DE BÚSQUEDA

La búsqueda de datos puede condicionarse de dos maneras. En primer lugar

2.2.1. Cláusula WHERE

La cláusula WHERE aplicada a una sentencia SELECT permite indicar que

SELECT [DISTINCT] {*,columna [[AS] alias] [,columna [[AS] alias]...]}

condición La condición es una expresión lógica, la cual se evalúa

Ejemplo: Seleccionar los proveedores de Capital Federal.

SQL> select nombre, direccion, ciudad

NOMBRE DIRECCION CIUDAD

Los operadores de comparación permiten escribir una condición comparando

• Operadores =, !=,<>, >, >=, <, <=

Ejemplo: Seleccionar los productos cuyo identificador sea mayor a 8000000.

SQL> select * from productos

Ejemplo: Seleccionar las órdenes de compra emitidas antes del 22 de enero

SQL> select * from ordenes

NRO_ORDEN FORDEN CODIGO_PRV CODIGO_EMP FENTREGA TIPO_PAGO C

Ejemplo: Seleccionar las órdenes de compra cuya forma de pago es al

SQL> select * from ordenes

SQL> select * from ordenes

NRO_ORDEN FORDEN CODIGO_PRV CODIGO_EMP FENTREGA TIPO_PAGO C

El operador LIKE se utiliza para la comparación de cadenas de caracteres y

Ejemplo: Seleccionar los proveedores cuyo nombre comienza con 'R'.

SQL> select nombre, direccion

Ejemplo: Seleccionar los productos cuyo nombre contenga la palabra HOJA.

SQL> select * from productos

Ejemplo: Seleccionar los productos cuyo nombre contenga la letra A en el

SQL> select * from productos

Ejemplo: Seleccionar los productos cuya fecha de vigencia es de 1998.

SQL> select * from precios

CODIGO_PRO PRECIO FVIGENCIA

Ejemplo: Seleccionar los productos cuyo nombre no contiene la cadena LA.

SQL> select * from productos

El operador BETWEEN se utiliza para la comparación de expresiones de