Viernes, 12 Junio 2020 03:49

Restricción y Ordenación de Datos SQL

Rate this item
(0 votes)

Objetivos:

  • Limitar las filas recuperadas por una consulta.
  • Ordenar las filas recuperadas por una consulta.
  • Mostrar el uso de la Variables de Sustitución.

NOTA: Usamos como ejemplo la base de datos: ORCL, la cual viene por defecto en cualquier versión de ORACLE.


SINTAXIS clausula WHERE:

SELECT *|{[DISTINCT] column|expression [alias],...}
FROM table
[WHERE condition(s)];

En la sintaxis:

  • WHERE restringe las filas que retorna la consulta, debe ir después de la cláusula FROM
  • La cláusula WHERE puede comparar valores en columnas, valores de literales, expresiones aritméticas o funciones.
  • condition(s)puede ser cualquier tipo de expresión lógica, Se compone de nombres de columna, expresiones, constantes o un operador de comparación. 
  • Las comparaciones que envuelven caracteres son CASE SENSITIVE, last_name ='KING' es diferente de last_name = 'King' o/y diferente a last_name = 'king'. 
  • La o las columnas usadas en la cláusula WHERE no tienen que estar presentes necesariamente en la cláusula SELECT.

Condiciones de Comparación.

Operador                            Significado

      =                                    Igual que

      >                                    Mayor que

      >=                                  Mayor o igual que

      <                                    Menor que

      <=                                  Menor o igual que

      <>                                  Distinto de

      BETWEEN ...AND...   Entre dos valores (ambos inclusive)

      IN(set)                           Se corresponde con cualquier valor de una lista

      LIKE                             Se corresponde con un patrón de caracteres

      IS NULL                       Es un valor nulo

Ejemplos:

SELECT last_name AS name,
                   salary AS salary,
                   phone_number AS phone
FROM employees
WHERE department_id = 90;

/*El query anterior retorna el nombre, salario y numero de teléfono de todos los empleados del departamento 90*/

SELECT job_title AS "Posición",
                min_salary AS "Salario Mínimo"
FROM jobs
WHERE min_salary > 8000;

/*El query anterior retorna el nombre y respectivos salarios mínimos de las posiciones con un salario mínimo mayor a 8000  */

SELECT first_name AS empleado, salary AS salario
FROM employees
WHERE salary >= 9000;

/*El query anterior retorna el nombre y salario de los empleados  con salarios mayores o iguales a 9000*/

SELECT *
FROM employees
WHERE hire_date < TO_DATE('01/01/2003', 'MM/DD/YYYY');

/*El query anterior retorna el detalle de los empleados contratados antes del 1ro de Enero del Año 2003, la función TO_DATE es explicada Aquí!!!*/

SELECT *
FROM employees
WHERE employee_id <= 103;

/*El query anterior retorna el detalle de los empleados con un código de empleado(ID) menor o igual a 103*/

SELECT employee_id,email, department_id
FROM employees
WHERE department_id <> 80;

/*El query anterior retorna el código, correo y departamento de los empleado que no sean del departamento 80*/

SELECT employee_id,salary
FROM employees
WHERE salary BETWEEN 10500 AND 11000;

/*El query anterior retorna el código y salario de los empleados con salarios entre 10500 y 11000*/

SELECT last_name,job_id
FROM employees
WHERE job_id IN ('PR_REP','PU_CLERK','PU_MAN');

/*El query anterior retorna el apellido y puesto de los empleados con puestos como PR_REP, PU_CLERK o PU_MAN*/

 

Ejemplos con LIKE

Nota: la Expresión  LIKE podría usarse en lugar del operador "=" si se usa para caracteres, pero LIKE es mucho mas completo:

En los ejemplos siguientes:

'%' Significa: Cualquier carácter y cualquier cantidad de dicho carácter.

'_' Significa: Un(1) carácter cualquiera en la posición especificada.

ESCAPE '!' Significa: Trata el Carácter seguido de '!' como un Literal como tal.

 

SELECT employee_id, manager_id
FROM employees
WHERE first_name LIKE 'K%';

/*El query anterior retorna el código de empleado y código de manager de los empleados que tengan una letra 'K' como inicial del primer nombre*/

 

SELECT first_name, employee_id,
FROM employees
WHERE first_name LIKE '_u%';

/*El query anterior retorna el nombre y código de los empleados que tengan una letra 'u' como segunda letra del primer nombre*/

 

SELECT last_name, job_id
FROM employees
WHERE job_id LIKE 'AD!_%' ESCAPE '!';

/*El query anterior retorna el nombre y puesto de trabajo de los empleados con puesto de trabajo que empiecen con 'AD_'*/

SELECT last_name, job_id, manager_id
FROM employees
WHERE manager_id IS NULL;

/*El query anterior retorna el nombre, puesto de trabajo y código de manager de los empleados que no tienen ningún manager*/

Nota: La Expresión  WHERE manager_id IS NULL no es igual a WHERE manager_id = NULL, debido a que NULL es NULL no igual a NULL(NULL es la ausencia de valor).


Condiciones Lógicas:

  Operador                                      Significado                                     

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

      AND                                     Retorna TRUE si ambas

                                                    condiciones son verdaderas.

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

      OR                                        Retorna TRUE si por lo menos

                                                    una de las condiciones verdadera.

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

      NOT                                     Retorna TRUE si la condición

                                                    siguiente es falsa.

  • Una condición lógica combina el resultado de dos condiciones componentes para crear un único resultado basándose en esas condiciones.

Ejemplos:

SELECT employee_id, last_name, job_id, salary
FROM   employees
WHERE  salary >=10000
AND    job_id LIKE '%MAN%';

/*El query anterior retorna los registros que cumplen  ambas condiciones, empleados que ganan 10000 o mas y que también su posiciona de trabajo tenga un hombre que contenga 'MAN'*/

SELECT employee_id, last_name, job_id, salary
FROM   employees
WHERE  salary >=10000
OR     job_id LIKE '%MAN%';

/*El query anterior retorna los registros que cumplan con una cualquiera o ambas condiciones, empleados que ganan 10000 o mas o empleado que su posiciona de trabajo tenga un hombre que contenga 'MA', este quiery tiene una población mayor ya que incluye los registros que retorna el anterior mas lo que solo cumplen con una de las dos condiciones*/

 

SELECT last_name,job_id
FROM employees
WHERE job_id NOT IN ('PR_REP','PU_CLERK','PU_MAN');

/*El query anterior retorna los registros de empleados con puestos de trabajo diferentes a PR_REP, PU_CLERK y PU_MAN*/

Nota: El operador NOT también se puede combinar con otros operadores SQL, como BETWEENLIKE NULL:

... WHERE job_id NOT IN('AC_ACCOUNT', 'AD_VP'); 

... WHERE salary NOT BETWEEN 10000 AND 15000;

... WHERE last_name NOT LIKE '%A%';

... WHERE commission_pct IS NOT NULL;---


Cláusula ORDER BY.

  • Su función es ordenar las filas recuperadas, utilice la cláusulaORDER BYcon: 

ASC: par orden ascendente, (por defecto). 

DESC: para orden descendente. 

  • La cláusula ORDER BYse coloca al final de la sentenciaSELECT
  • En tablas con grandes cantidades de registros se recomiendo ordenar por columnas indexadas, ya que una consulta para millones de registro tomaría mucho tiempo si se ordena por una columna sinINDEX

Es posible ordenar por un alias de columna o por una columna no especificada en el SELECT.

SINTAXIS clausula ORDER BY.

SELECT expr 
FROM table
[WHERE condition(s)]
[ORDER BY {column, expr, numeric_position} [ASC|DESC]];

Ejemplos:

SELECT last_name, job_id, department_id, hire_date
FROM employees 
ORDER BY hire_date DESC;

/*Ordenando por fecha de contratación descendente, los empleados mas nuevos en la empresa aparecen primero*/

SELECT employee_id, last_name, salary*12 annsal
FROM employees
ORDER BY annsal;

/*Ordenando por el alias de un campo calculado, como no se especifica ASC/DESC el orden es ascendente por defecto*/

SELECT last_name, department_id, salary
FROM employees
ORDER BY department_id, salary DESC;

/*Puede ordenar resultados de consultas por más de una columna. El límite de ordenación es el número de columnas de la tabla en cuestión. En la cláusula ORDER BY, especifique las columnas y separe los nombres de columna mediante comas. Si desea invertir el orden de una columna, especifique DESC después de su nombre.*/


Variables de Sustitución.

  • Utilice las variables de sustitución para Almacenar valores temporalmente.
  • Dichas variables se pueden complementar en Condiciones de la cláusula WHERE, CláusulasORDER BY, Expresiones de columna, Nombres de tablas en la cláusula FROMy Sentencias SELECT completas.

Ejemplos:

SELECT employee_id, last_name, salary, department_id
FROM employees
WHERE  employee_id = &employee_num;

/*Al momento de ejecutar este query se le pide(PROMPT) al usuario que introduzca un código de empleado para así comparar con el employee_id de la Cláusulas  WHERE*/

SELECT employee_id, last_name, job_id,&column_name
FROM employees
WHERE  &condition
ORDER BY &order_column;

/*En este query el usuario recibe un PROMPT tanto para que introduzca una cuarta columna en la Cláusula SELECT, recibe otro para que especifique la condición de restricción de los registros en la Cláusula WHERE y por último se le pide que especifique la columna por lo cual se va a ordenar la consulta*/

 

Variable de Sustitución &&

  • Utilice el ampersand doble (&&) si desea volver a utilizar el valor de variable sin pedir al usuario que realice una acción cada vez.
  • Los usuarios deiSQL*Plustienen la alternativa de también usar el comando DEFINE para crear y asignar un valor a una variable.
  • Una vez no se desee usar el mismo valor para dicha variable se puede usar el comando UNDEFINE para definirla: UNDEFINEcolumn_name.

Ejemplos:

SELECT employee_id, last_name, job_id, &&column_name
FROM employees
ORDER BY &column_name;

/*El usuario verá el prompt sólo una vez para especificar la cuarta columna en la Cláusula SELECT, luego esa misma columna es usada en el ORDER BY para ordenar los registros retornados de forma ascendente(por defecto).*/

 

DEFINE employee_num = 200
SELECT employee_id, last_name, salary, department_id
FROM employees
WHERE employee_id = &employee_num;
UNDEFINE employee_num

/*En el query anterior se define la variable employee_num con un valor de 200 luego es usada como condición de restricción de la Cláusula WHERE y por último es indefinida*/


Comando VERIFY

  • Por defecto el comandoVERIFYesta ON esto hace que al momento de ejecución del query se muestre en pantalla el texto del comando antes y después de reemplazar con valores las variables de sustitución si no se quiere que esto se muestre se debe establecer dicho comando OFFSET VERIFY OFF.

Link con un Archivo de ejercicios de práctica!!!


Fuente: Base de Datos Oracle 10g: Conceptos Fundamentales de SQL 1

Read 418 times Last modified on Sábado, 22 Agosto 2020 01:47

Leave a comment

Make sure you enter all the required information, indicated by an asterisk (*). HTML code is not allowed.

Magic PL/SQL

Blog orientado al desarrollo de PL/SQL en el "Maravilloso Mundo ORACLE". Cursos Online y Tutoriales Gratis.