Este documento describe las consultas a una base de datos utilizando el lenguaje SQL. Explica la sentencia SELECT para recuperar datos de una tabla especificada, así como cláusulas como WHERE, LIKE, BETWEEN, IN y ORDER BY para filtrar y ordenar los resultados. También resume funciones como COUNT, AVG, SUM y otras utilizadas comúnmente en consultas SQL.

1. Ayudantía de base de datos.
Consultas a la Base de Datos
La sentencia select es usada para consultar la base de datos y recibir los datos
seleccionados que se igualan al criterio que usted haya especificado. He aquí el formato
de una instrucción simple de selección:
select "columna1"[,"columna2",etc] from "Nombre_Tabla"
[where "condición"];
[] = opcional
*El nombre de la Columna que sigue a la palabra clave Select determina qué columnas
serán retornadas en los resultados. Se puede seleccionar tantos Nombres de columna
como quiera, o puede usar un "*" para seleccionar todas las columnas.
*El Nombre_Tabla que sigue a la palabra clave from especifica la tabla que será
consultada para recuperar los resultados deseados.
*La cláusula where (opcional) especifica qué valores de datos o filas serán retornados o
desplegados, basado en el criterio descrito después de la palabra clave where.
Las selecciones condicionales usadas en la cláusula where son:
= Igual
> Mayor que
< Menor que
>= Mayor o igual a
<= Menor o igual a
<> No igual a (Distinto de)
LIKE *Vea la nota siguiente
• El operador de emparejado de patrones LIKE también puede ser usado en
selecciones condicionales con cláusula Where. Like es un operador muy poderoso
que le premite seleccionar sólo las filas que son "tal como" las que usted especificó. El
símbolo porcentaje "%" puede ser usado como un comodín para igualar algún posible
carácter que pueda aparecer después o antes de los caracteres especificados. Por
ejemplo:

2. Ayudantía de base de datos.
select first, last, city
from empinfo
where first LIKE 'Er%';
La sentencia SQL igualará cualquier nombre inicial (first name) que comience con 'Er'.
Las cadenas sólo deberán incluir comilla simple (p.e.:'Hola').
Otro Ejemplo:
select first, last
from empinfo
where last LIKE '%s';
Esta sentencia igualará cualquier apellido (last name) que finalice en 's'.
select * from empinfo
where first = 'Eric';
Esto sólo seleccionará las filas donde el primer nombre (firt name) sea exactamente igual
a 'Eric'.
Contenido de las Tablas Students y Courses
Tabla STUDENTS
SQL> select * from students;
STUDENTI
D
NAME MAJOR GPA TUTORID
102 Mary CIS 3,1
103 Sue Marketing 2,95 102
104 Tom Finance 3,5 106
105 Alex CIS 2,75 106
106 Sam Marketing 3,25 103
107 Jane Finance 2,9 102
101 Bill CIS 3,45 102

3. Ayudantía de base de datos.
Tabla COURSES
SQL> select * from courses;
STUDENTID COURSENUMBER COURSENAME SEMESTER YEAR GR
101 CIS3400 DBMS I FALL 1997 B+
101 CIS3100 OOP I SPRING 1999 A-
101 MKT3000 Marketing FALL 1997 A
102 CIS3400 DBMS I SPRING 1997 A-
102 CIS3500 Network I SUMMER 1997 B
102 CIS4500 Network II FALL 1997 B+
103 MKT3100 Advertizing SPRING 1998 A
103 MKT3000 Marketing FALL 1997 A

4. Ayudantía de base de datos.
Remueva filas duplicadas, antes que los resultados de
la sentencia de selección los retorne, con DISTINCT.
Sintaxis
Selelect DISTINCT columna1[,columna2, columna3, ...]
From Tabla;
Ejemplo
Select DISTINCT CourseName
From courses;
Resultado:
coursename
Advertizing
DBMS I
Marketing
Marketing II
Network I
Network II
OOP I
Si se da cuenta, sólo han aparecido una vez los nombres y no el listado completo que los
incluye n veces y además desordenados.
Definición de Alias o cabeceras de columnas sustitutas,
en una sentencia Select
Ejemplo:
Select DISTINCT CourseName "Nombre Curso"
From Courses;
Resultado:
Nombre Curso
Advertizing
DBMS I
Marketing
Marketing II
Network I
Network II

5. Ayudantía de base de datos.
OOP I

6. Ayudantía de base de datos.
Uso de la Cláusula WHERE y
sus operadores
Operadores de Comparación
Operador Descripción
= Igual a
!= <> ^= No igual a
> Mayor que
>= Mayor o Igual que
< Menor que
<= Menor o Igual que
Between... And... Entre dos valores
IN(lista) Igual a algún elemento de la
siguiente lista
IS NULL Es el valor NULL
LIKE Iguala un patrón de caracteres
usando caracteres comodines
Ejemplos
Select CourseName
from Courses
where Year <= 1997;
Resultado
CourseName
DBMS I
Marketing
DBMS I
Network I
Network II
Marketing
Select Name
from Students
where StudentID=101;

7. Ayudantía de base de datos.
Resultado
studentID name major gpa tutorID
101 Bill CIS 3.45 102
Select StudentID, Coursename
from courses
where semester <> 'FALL';
Resultado
StudentID Coursename
101 OOP I
102 DBMS I
102 Network I
103 Advertizing
103 Marketing II
Uso de Between... And...
Ejemplo
SELECT StudentID, Coursename
FROM courses
WHERE StudentID BETWEEN 101 and 102;
Resultado
StudentID Coursename
101 DBMS I
101 OOP I
101 Marketing
102 DBMS I
102 Network I
102 Network II
Antes de continuar, vamos a agregar la columna BirthDate a la tabla Students, para
almacenar la fecha de nacimiento de nuestros estudiantes.
Alter table Students
Add (BirthDate DATE)

8. Ayudantía de base de datos.
Luego agregamos los datos:
Update Students Set birthDate = TO_DATE('14-11-1960', 'DD-MM-YYYY')
Where StudentID = 101;
Update Students Set birthDate = TO_DATE('20-10-1964', 'DD-MM-YYYY')
Where StudentID = 102;
Update Students Set birthDate = TO_DATE('16-04-1970', 'DD-MM-YYYY')
Where StudentID = 103;
Update Students Set birthDate = TO_DATE('28-02-1969', 'DD-MM-YYYY')
Where StudentID = 104;
Update Students Set birthDate = TO_DATE('23-05-1975', 'DD-MM-YYYY')
Where StudentID = 105;
Update Students Set birthDate = TO_DATE('18-01-1977', 'DD-MM-YYYY')
Where StudentID = 106;
Update Students Set birthDate = TO_DATE('25-12-1967', 'DD-MM-YYYY')
Where StudentID = 107;
Un ejemplo clásico de selección utilizando la cláusula BETWEEN... AND... es para buscar
tuplas que están entre determindas fechas. Por ejemplo:
Select Name, Major
from Students
Where BirthDate Between '01-01-1965' And '31-12-1975';
Resultado
Name Major
Sue Marketing
Tom Finance
Alex CIS
Jane Finance
Uso del Operador IN
Ejemplo
Select *
from Students
Where StudentID IN (101, 102);
Resultado
studentID name major gpa TutorID BirthDate

9. Ayudantía de base de datos.
101 Bill CIS 3.45 102 14/11/60
102 Mary CIS 3.1 20/10/64
Seleccionar información usando caracteres
comodines con el operador LIKE
Caracteres comodines
% iguala algún número de caracteres
_ iguala un único carácter
Ejemplos:
Select StudentID, Name
from Students
Where Name Like 'S%';
Resultado:
StudentID Name
103 Sue
106 Sam
Select StudentID, Name
from Students
Where Name Like '%a%';
Resultado
StudentID Name
102 Mary
105 Alex
106 Sam
107 Jane
Select StudentID, Name
from Students
Where StudentID Like '10_';

10. Ayudantía de base de datos.
Resultado
StudentID Name
101 Bill
102 Mary
103 Sue
104 Tom
105 Alex
106 Sam
107 Jane
Operador NOT se puede usar para anteponerlo antes de los operadores antes
mencionados para invertir el resultado de una consulta.
Utilizando Operador NOT
Select StudentID, Name
from Students
Where Name NOT Like '%a%';
Resultado
StudentID Name
101 Bill
103 Sue
104 Tom
Sin Operador NOT
Select StudentID, Name
from Students
Where Name Like '%a%';
Resultado
StudentID Name
102 Mary
105 Alex
106 Sam
107 Jane

11. Ayudantía de base de datos.
Cláusula ORDER BY
Ejemplo:
Select *
From Students
Order by BirthDate;
Resultado
studentID name major gpa tutorID BirthDate
101 Bill CIS 3.45 102 14/11/1960
102 Mary CIS 3.1 20/10/1964
107 Jane Finance 2.9 102 25/12/1967
104 Tom Finance 3.5 106 28/02/1969
103 Sue Marketing 2.95 102 16/04/1970
105 Alex CIS 2.75 106 23/05/1975
106 Sam Marketing 3.25 103 18/01/1977
El resultado por defecto es ordenado en forma Ascendente. (De Menor a Mayor)
En orden Descendente (de mayor a menor) se realiza con la siguiente instrucción:
Select *
From Students
Order by BirthDate DESC;
Resultado
studentID name major gpa tutorID BirthDate
106 Sam Marketing 3.25 103 18/01/1977
105 Alex CIS 2.75 106 23/05/1975
103 Sue Marketing 2.95 102 16/04/1970
104 Tom Finance 3.5 106 28/02/1969
107 Jane Finance 2.9 102 25/12/1967
102 Mary CIS 3.1 20/10/1964
101 Bill CIS 3.45 102 14/11/1960

12. Ayudantía de base de datos.
Operadores Lógicos utilizados
comúnmente en consultas
AND
OR
NOT
Operadores Aritméticos
para consultas
+
-
*
/
Funciones Utilizadas
NVL: Convierte un valor NULO en otro NO NULO para propósitos de realizar cálculos con
campos que puedan tener valores NULOS.
Sintaxis:
NVL(expr1, expr2)
NVL evalúa expr1, si es NOT NULL se retorna dicha expresión, en caso contrario se
retorna el valor contenido en expr2.
Ejemplo de Uso:
Select NombreEmpleado, Cargo, Sueldo, Comision, NVL (SUELDO, 0) +
NVL(Comision, 0)
From Empleados
Where NumDepto = 30;
NombreEmpleado Cargo Sueldo Comision NVL(Sueldo,0) +
NVL(Comision,0)
ALLEN VENDEDOR 1600 300 1900
WARD VENDEDOR 1250 500 1750

13. Ayudantía de base de datos.
JONES VENDEDOR 2975 2975
MARTIN VENDEDOR 1250 1400 2650
BLAKE ADMINISTRATIVO 2850 2850
SCOTT VENDEDOR 3150 3150
TURNER VENDEDOR 1500 0 1500

14. Ayudantía de base de datos.
Funciones Numéricas
Función Ejemplo Resultado
MOD MOD(7,5) El resto de dividir 7 en 5, o
sea 2
SQRT SQRT(25) Raíz Cuadrada de 25, es
decir 5
ROUND ROUND(SUELDO, 2) Se redondea la Columna
SUELDO en el digito 2.
Ejemplo ROUND(3.25, 1) da
como resultado 3.3
TRUNC TRUNC(SUELDO, 2) Se trunca SUELDO en el
dígito 2 después de la coma.
Ejemplo, TRUNC(3.25,1) da
como resultado 3.2
POWER POWER(SUELDO,3) Sueldo al Cubo
Más Funciones en SQL
SUM
Se utiliza para realizar una sumatoria sobre una cierta columna determinada dentro de
una instrucción como SELECT.
Sintaxis
SUM([DISTINCT|ALL] n)
Ejemplo
SELECT SUM(sueldo) "Total"
FROM empleados
Resultado
Total
----------
29081

15. Ayudantía de base de datos.
AVG
Se utiliza para obtener el promedio (AVERAGE) sobre una determinada columna dentro
de una instrucción como SELECT.
Sintaxis
AVG([DISTINCT|ALL] n)
Ejemplo
SELECT AVG(sueldo) "Sueldo Promedio"
FROM empleados;
Resultado:
Sueldo Promedio
------------------
2077.21429
COUNT
Permite realizar el conteo de filas resultantes en una consulta.
Sintaxis
COUNT({* | [DISTINCT|ALL] expr})
Ejemplos
SELECT COUNT(*) "Total"
FROM empleados
Resultado:
Total
----------
18
SELECT COUNT(Trabajo) "Cuantos Empleados"
FROM empleados;
Resultado:

16. Ayudantía de base de datos.
Cuantos Empleados
------------------
14
SELECT COUNT(DISTINCT Trabajo) "Trabajos"
FROM empleados;
Resultado:
Trabajos
----------------
5
INITCAP
Regresa la primera letra del parámetro en mayúscula y el resto de la palabra en
minúsculas.
Sintaxis
INITCAP (expr)
Ejemplo
SELECT INITCAP(nombre_empl) "Nombre Empleado", trabajo
FROM empleados;
Resultado:
Nombre Empleado Trabajo
----------------------------------------------
Juan administrativo
UPPER
Retorna el contenido del parámetro con todas sus letras en Mayúscula.
Sintaxis
UPPER(expr)

17. Ayudantía de base de datos.
Ejemplo
SELECT UPPER(nombre_empl) "Nombre Empleado", UPPER (trabajo)
FROM empleados;
Resultado:
Nombre Empleado Trabajo
-------------------------------------------------------
JUAN ADMINISTRATIVO
LOWER
Retorna todos los caracteres de una cadena en minúscula.
Sintaxis
LOWER(expr)
Ejemplo
SELECT LOWER(nombre_empl) "Nombre Empleado", LOWER (trabajo)
FROM empleados;
Resultado:
Nombre Empleado Trabajo
----------------------------------------------
juan administrativo

18. Ayudantía de base de datos.
SUBSTR
Retorna una subcadena indicada por un carácter de inicio y la cantidad de caracteres que
se copiarán a partir de dicho carácter. En pocas palabras trabaja como la función COPY
de PASCAL o la instrucción MID de VISUAL BASIC.
Sintaxis
SUBSTR(cadena, carácter_inicio, cuántos_se_copian)
Ejemplo
SELECT INITCAP(nombre_empl) "Nombre Empleado",
SUBSTR(INITCAP(trabajo),1,5)
FROM empleados;
Resultado:
Nombre Empleado Trabajo
----------------------------------------------
Juan Admin
LENGTH
Entrega el número de caracteres de una cadena. Funciona tal como lo hace LENGTH de
PASCAL, STRLEN de C o LEN de VISUAL BASIC.
Ejemplo
SELECT LENGTH(nombre_empl) "Numero de Caracteres"
FROM empleados;
Resultado:
Numero de Caracteres
--------------------
4
CLAUSULA GROUP BY
La cláusula GROUP BY se utiliza dentro de instrucciones SELECT y permite realizar
agrupamientos, generalmente con cálculos.
Ejemplo:
Se quiere saber cuántos empleados trabajan en cada departamento de la empresa.

19. Ayudantía de base de datos.
SELECT Depto, COUNT(*) "Numero de Trabajadores"
FROM EMPLEADOS
GROUP By Depto;

20. Ayudantía de base de datos.
Resultado:
DEPTO NUMERO DE TRABAJADORES
-------------------------------------------------------------
101 3
102 15
450 13
Ejemplo:
Se quiere conocer el promedio de notas por alumno de la carrera de COMPUTACION.
Esta es toda la tabla:
Nombre NOTA Carrera
-------------------- --------- --------------------
CLAUDIO 5 Computacion
CLAUDIO 4 Computacion
CLAUDIO 6 Computacion
ANDREA 6 Computacion
ANDREA 3 Computacion
ANDREA 7 Computacion
Esta la instrucción de selección:
SELECT SUBSTR(nombre,1,20) "Alumno" , avg(nota) "Promedio"
FROM notas
GROUP BY nombre;
y el siguiente el resultado:
Alumno Promedio
-------------------- ---------
ANDREA 5,3333333
CLAUDIO 5
CLAUSULA HAVING
La cláusula Having sirve para condicionar consultas que utilizan GROUP BY.
Por ejemplo, supongamos que queremos saber el promedio anual del sueldo para todas
los cargos en los cuales hay más de dos empleados.

21. Ayudantía de base de datos.
SELECT cargo, 12*AVG(sueldo)
FROM empleados
GROUP BY cargo
HAVING COUNT(*) > 2;

22. Ayudantía de base de datos.
Resultado:
Cargo 12 * AVG(sueldo)
------------------------ -----------------------------
SECRETARIA 124500
VENDEDOR 234500
Dentro de este Tipo de consultas se puede condicionar algunas operaciones como la
sumatoria o incluso el promedio.
Ejemplo:
SELECT NumDEPTO, SUM(sueldo)
FROM empleados
WHERE cargo <> ‘SECRETARIA’
GROUP BY NumDEPTO
HAVING SUM(sueldo) > 80000
ORDER BY SUM(sueldo);
SECUENCIAS
Las secuencias se utilizan para generar números sucesivos. Su uso más común es con
las claves primarias o foráneas cuyos valores requieren ser generados en sucesión y
automáticamente. El caso más común es el tipo de dato AUTONUMERICO de ACCESS.
EJEMPLO:
CREATE SEQUENCE seq_nota
INCREMENT BY 1
START 1;