¿Qué es el SQL?

Antes de empezar debes tener unas nociones básicas de bases de

datos relacionales, si quieres repasarlas haz clic aquí
El SQL (Structured query language), lenguaje de consulta estructurado,
es un lenguaje surgido de un proyecto de investigación de IBM para el
acceso a bases de datos relacionales. Actualmente se ha convertido en un
estándar de lenguaje de bases de datos, y la mayoría de los sistemas de
bases de datos lo soportan, desde sistemas para ordenadores personales,
hasta grandes ordenadores.

Por supuesto, a partir del estándar cada sistema ha desarrollado su propio

SQL que puede variar de un sistema a otro, pero con cambios que no
suponen ninguna complicación para alguien que conozca un SQL concreto,
como el que vamos a ver aquí corespondiente al Access2000.

Como su nombre indica, el SQL nos permite realizar consultas a la

base de datos. Pero el nombre se queda corto ya que SQL además realiza
funciones de definición, control y gestión de la base de datos. Las
sentencias SQL se clasifican según su finalidad dando origen a tres
‘lenguajes’ o mejor dicho sublenguajes:

el DDL (Data Description Language), lenguaje de definición de

datos, incluye órdenes para definir, modificar o borrar las tablas en las que
se almacenan los datos y de las relaciones entre estas. (Es el que más
varia de un sistema a otro)

el DCL (Data Control Language), lenguaje de control de datos,

contiene elementos útiles para trabajar en un entorno multiusuario, en el
que es importante la protección de los datos, la seguridad de las tablas y el
establecimiento de restricciones en el acceso, así como elementos para
coordinar la compartición de datos por parte de usuarios concurrentes,
asegurando que no interfieren unos con otros.

el DML (Data Manipulation Language), lenguaje de manipulación de

datos, nos permite recuperar los datos almacenados en la base de datos y
también incluye órdenes para permitir al usuario actualizar la base de datos
añadiendo nuevos datos, suprimiendo datos antiguos o modificando datos
previamente almacenados.

SQL

El Lenguaje de consulta estructurado (SQL [/esekuele/ en español, /ɛskjuːˈɛl / en

inglés] Structured Query Language ) es un lenguaje declarativo de acceso a bases de
datos relacionales que permite especificar diversos tipos de operaciones sobre las
mismas. Una de sus características es el manejo del álgebra y el cálculo relacional
permitiendo lanzar consultas con el fin de recuperar -de una forma sencilla- información
de interés de una base de datos, así como también hacer cambios sobre la misma. Es un
lenguaje de cuarta generación (4GL).

Orígenes y evolución
Los orígenes del SQL están ligados a los de las bases de datos relacionales. En 1970 E.
F. Codd propone el modelo relacional y asociado a este un sublenguaje de acceso a los
datos basado en el cálculo de predicados. Basándose en estas ideas, los laboratorios de
IBM definen el lenguaje SEQUEL (Structured English QUEry Language) que más
tarde sería ampliamente implementado por el SGBD experimental System R,
desarrollado en 1977 también por IBM. Sin embargo, fue Oracle quien lo introdujo por
primera vez en 1979 en un programa comercial.

El SEQUEL terminaría siendo el predecesor de SQL, siendo éste una versión

evolucionada del primero. El SQL pasa a ser el lenguaje por excelencia de los diversos
SGBD relacionales surgidos en los años siguientes y es por fin estandarizado en 1986
por el ANSI, dando lugar a la primera versión estándar de este lenguaje, el SQL-86 o
SQL1. Al año siguiente este estándar es también adoptado por la ISO.

Sin embargo este primer estándar no cubre todas las necesidades de los desarrolladores
e incluye funcionalidades de definición de almacenamiento que se consideraron
suprimir. Así que en 1992 se lanza un nuevo estándar ampliado y revisado del SQL
llamado SQL-92 o SQL2.

En la actualidad el SQL es el estándar de facto de la inmensa mayoría de los SGBD

comerciales. Y, aunque la diversidad de añadidos particulares que incluyen las distintas
implementaciones comerciales del lenguaje es amplia, el soporte al estándar SQL-92 es
general y muy amplio.

El ANSI SQL sufrió varias revisiones y agregados a lo largo del tiempo:

Año Nombre Alias Comentarios

1986 SQL-86 SQL-87 Primera publicación hecha por ANSI. Confirmada por ISO en
1987.
1989 SQL-89 Revisión menor.
1992 SQL-92 SQL2 Revisión mayor.
1999 SQL:1999 SQL2000 Se agregaron expresiones regulares, consultas recursivas
(para relaciones jerárquicas), triggers y algunas
características orientadas a objetos.
2003 SQL:2003 Introduce algunas características de XML, cambios en las
funciones, estandarización del objeto sequence y de las
columnas autonumericas.
(Ver Eisenberg et al.: SQL:2003 Has Been Published.)
2006 SQL:2006 ISO/IEC 9075-14:2006 Define las maneras en las cuales el
SQL se puede utilizar conjuntamente con XML. Define
maneras importar y guardar datos XML en una base de datos
SQL, manipulándolos dentro de la base de datos y
publicando el XML y los datos SQL convencionales en forma
XML. Además, proporciona facilidades que permiten a las
aplicaciones integrar dentro de su código SQL el uso de
XQuery, lenguaje de consulta XML publicado por el W3C
(World Wide Web Consortium) para acceso concurrente a
datos ordinarios SQL y documentos XML.
Objetivo
 Empezaremos por estudiar la sentencia SELECT, que permite recuperar datos
de una o varias tablas. La sentencia SELECT es con mucho la más compleja y
potente de las sentencias SQL. Empezaremos por ver las consultas más simples,
basadas en una sola tabla.

Esta sentencia forma parte del DML (lenguaje de manipulación de datos), en

este tema veremos cómo seleccionar columnas de una tabla, cómo seleccionar
filas y cómo obtener las filas ordenadas por el criterio que queramos.

El resultado de la consulta es una tabla lógica, porque no se guarda en el disco

sino que está en memoria y cada vez que ejecutamos la consulta se vuelve a
calcular.

Cuando ejecutamos la consulta se visualiza el resultado en forma de tabla con

columnas y filas, pues en la SELECT tenemos que indicar qué columnas queremos
que tenga el resultado y qué filas queremos seleccionar de la tabla origen.

Si no conoces todavía las tablas que utilizaremos para los ejemplos y ejercicios
clic aquí

SQL > SQL Sintaxis 

En esta página, enumeramos la sintaxis SQL para cada uno de los comandos SQL en esta guía de
referencia. Para obtener explicaciones detalladas para cada sintaxis SQL, por favor diríjase a la
sección individual haciendo clic en la palabra clave.

El propósito de esta página es brindar una página de referencia rápida para la sintaxis SQL. Le
sugerimos que agregue esta página a favoritos ahora presionando Control-D para que pueda
tener esta página de sintaxis a mano.

Select
SELECT "nom de colonne" FROM "nombre_tabla"

Distinct
SELECT DISTINCT "nombre_columna"
FROM "nombre_tabla"

Where
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condition"

And/Or
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición simple"
{[AND|OR] "condición simple"}+

In
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" IN ('valor1', 'valor2', ...)

Between
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" BETWEEN 'valor1' AND 'valor2'

Like
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" LIKE {patrón}

Order By
SELECT "nombre_columna"
FROM "nombre_tabla"
[WHERE "condición"]
ORDER BY "nombre_columna" [ASC, DESC]

Count
SELECT COUNT("nombre_columna")
FROM "nombre_tabla"

Group By
SELECT "nombre_columna 1", SUM("nombre_columna 2")
FROM "nombre_tabla"
GROUP BY "nombre_columna 1"

Having
SELECT "nombre_columna 1", SUM("nombre_columna 2")
FROM "nombre_tabla"
GROUP BY "nombre_columna 1"
HAVING (condición de función aritmética)

Create Table
CREATE TABLE "nombre_tabla"
("columna 1" "tipo_de_datos_para_columna_1",
"columna 2" "tipo_de_datos_para_columna_2",
... )

Drop Table
DROP TABLE "nombre_tabla"

Truncate Table
TRUNCATE TABLE "nombre_tabla"

Insert Into
INSERT INTO "nombre_tabla" ("colonne 1", "colonne 2", ...)
valorS ("valor 1", "valor 2", ...)

Update
UPDATE "nombre_tabla"
SET "colonne 1" = [nuevo valor]
WHERE {condition}

Delete From
DELETE FROM "nombre_tabla"
WHERE {condición}
Sintaxis de la sentencia SELECT (consultas
simples)

Características generales
El SQL es un lenguaje de acceso a bases de datos que explota la flexibilidad y potencia
de los sistemas relacionales permitiendo gran variedad de operaciones sobre los
mismos.

Es un lenguaje declarativo de alto nivel o de no procedimiento, que gracias a su fuerte

base teórica y su orientación al manejo de conjuntos de registros, y no a registros
individuales, permite una alta productividad en codificación. De esta forma una sola
sentencia puede equivaler a uno o más programas que utilizasen un lenguaje de bajo
nivel orientado a regro.

Optimización
Como ya se dijo arriba, y como suele ser común en los lenguajes de acceso a bases de
datos de alto nivel, el SQL es un lenguaje declarativo. O sea, que especifica qué es lo
que se quiere y no cómo conseguirlo, por lo que una sentencia no establece
explícitamente un orden de ejecución.

El orden de ejecución interno de una sentencia puede afectar gravemente a la eficiencia

del SGBD, por lo que se hace necesario que éste lleve a cabo una optimización antes de
la ejecución de la misma. Muchas veces, el uso de índices acelera una instrucción de
consulta, pero ralentiza la actualización de los datos. Dependiendo del uso de la
aplicación, se priorizará el acceso indexado o una rápida actualización de la
información. La optimización difiere sensiblemente en cada motor de base de datos y
depende de muchos factores.

Existe una ampliación de SQL conocida como FSQL (Fuzzy SQL, SQL difuso) que
permite el acceso a bases de datos difusas, usando la lógica difusa. Este lenguaje ha sido
implementado a nivel experimental y está evolucionando rápidamente.

Cómo se crea una sentencia SQL en ACCESS2000

Este manual está basado en el SQL del motor de base de datos que utiliza el Access2000,
el Microsoft Jet 4.x, para que los ejemplos y ejercicios se puedan ejecutar y probar.
Para crear y después ejecutar una sentencia SQL en Access, lo fácil es utilizar la ventana
SQL de las consultas.

Para crear una consulta de selección, seguir los siguientes pasos:

Abrir la base de datos donde se encuentra la consulta a crear.
Hacer clic sobre el objeto Consulta que se encuentra a la izquierda de la ventana de la
base de datos.
Hacer clic sobre el botón Nuevo de la ventana de la base de datos.

Aparecerá el siguiente cuadro de diálogo:

Seleccionar Vista Diseño.

Hacer clic sobre el botón Aceptar.

Aparecerá el siguiente cuadro de diálogo:

Como no queremos utilizar el generador de consultas sino escribir nuestras propias
sentencias SQL, no agregamos ninguna tabla.
 Hacer clic sobre el botón Cerrar.

Aparecerá la ventana de diseño de consultas.

Hacer clic sobre el botón , este botón es el que permite

elegir la vista de la consulta, puede adoptar una de estas tres
formas

Al apretar el botón cerrar de la pantalla anterior se abre esta ventana donde introducimos
la sentencia SQL.

Una vez escrita sólo nos queda ver si está bien hecha.
Hacer clic sobre el botón de la barra de herramientas para ejecutar la sentencia.
Si nos hemos equivocado a la hora de escribir la sintaxis, Access nos saca un mensaje de
error y muchas veces el cursor se queda posicionado en la palabra donde ha saltado el
error. Ojo, a veces el error está antes o después de donde se ha quedado el cursor.

Consultas recusivas y jerárquicas usando SQL Server

Technorati Tags: SQL Server, Performance

Las jerarquías son muy comunes en los sistemas de información, se utilizan para organizar
elementos por orden de importancia o por tamaño, como por ejemplo en un sistema de archivos o
en el organigrama de la empresa.

Por lo general cualquier conjunto de elementos en el cual todos los elementos exceptuando al
elemento raíz tienen un solo padre y cero o más hijos, puede ser considerado una jerarquías, o
como también se les conoce, un árbol invertido.

Ejemplo de jerarquía organizacional:

Para almacenar este tipo de estructuras en la base de datos se utiliza lo que se conoce como lista
de adyacencia, en donde cada nodo de la jerarquía guarda el Id del nodo padre.

Esta forma de almacenar es bastante eficiente en cuanto a almacenamiento y flexibilidad, puesto

que no tiene limitaciones en cuanto a la profundidad del árbol, ni tampoco en la cantidad de hijos
que puede tener cada nodo. Las listas de adyacencia no contienen información repetida entre los
nodos lo que permite realizar modificaciones a partes de la jerarquía sin afectar al resto de los
nodos.

Las desventajas aparecen cuando se trata de recuperar la información de la jerarquía, puesto que
no es posible realizar una sola consulta a la base de datos que devuelva toda o parte de la
jerarquía.

Un ejemplo de una consulta que no resulta fácil de contestar cuando se utilizan las listas de
adyacencia es “Cual es el sueldo total del área de Patricia”.

La primera ayuda para resolver este tipo de consultas vino de la mano de SQL Server 2000 con la
introducción de las Inline Table-Value User-Defined Function. Estas funciones permiten que una
función retorne datos en forma de tabla y tomar el resultado de dicha función como cualquier otra
tabla de la base de datos.

Definiendo la siguiente función:

CREATE FUNCTION [dbo].[GetIdEmpleados](@JefeId int)

RETURNS @retEmpleados TABLE (Id int)
AS
BEGIN
DECLARE @EmpleadosDirectos_Id int

DECLARE EmpleadosDirectos CURSOR STATIC LOCAL FOR

SELECT Id FROM dbo.Empleado WHERE JefeId=@JefeId

INSERT INTO @retEmpleados VALUES(@JefeId)

OPEN EmpleadosDirectos

FETCH NEXT FROM EmpleadosDirectos

INTO @EmpleadosDirectos_Id

WHILE (@@FETCH_STATUS = 0)
BEGIN
INSERT INTO @retEmpleados
SELECT * FROM dbo.GetIdEmpleados(@EmpleadosDirectos_Id)
 FETCH NEXT FROM EmpleadosDirectos
INTO @EmpleadosDirectos_Id
END

CLOSE EmpleadosDirectos
DEALLOCATE EmpleadosDirectos

RETURN
END

Esta función es capaz de devolver todos los identificadores de los empleados que reportan directa
o indirectamente a una persona. Utilizando el resultado de esta función es posible responder a la
consulta “Cual es el sueldo total del área de Patricia”, primero buscando el Id de Patricia, luego
llamando a la función GetIdEmpleados con ese Id como parámetro, realizando un join entre el
resultado de la función la tabla empleado, para finalmente obtener la suma de los sueldos de los
empleados.

select sum(Sueldo) as SueldoTotal From GetIdEmpleados(

(select Id from dbo.Empleado WHERE Nombre='Patricia')
) emp inner join dbo.Empleado e on emp.Id = e.Id

En SQL Server 2005 se introdujo una nueva funcionalidad al motor que facilita aun más el trabajo
con jerarquías. Esta nueva funcionalidad se llama Recursive Common Table Expressions (Recursive
CTE) y permite realizar una consulta recursiva sin tener que definir una función para realizar dicha
operación.

WITH CTE_Empleados (Id, Sueldo)

AS
(
SELECT Id, Sueldo FROM Empleado WHERE Nombre = 'Patricia'
UNION ALL
SELECT e.Id, e.Sueldo FROM Empleado e
INNER JOIN CTE_Empleados cte ON e.JefeId = cte.Id
)

SELECT sum(Sueldo) FROM CTE_Empleados

Esta consulta se resuelve de forma mucho más eficiente pues el motor entiende de mejor manera
que es lo que se quiere hacer, con lo que se obtienen mejoras considerable. Algunas pruebas
realizadas en SQL 2005 utilizando las 2 técnicas descritas mostraron que las consultas que
utilizaban los Recursive CTEs demoraban 4 a 10 veces menos que las que utilizaban las técnicas
descritas para la versión para 2000.

La versión de SQL Server 2008 trae aun más mejoras al desempeño y a la facilidad de uso de las
consultas sobre jerarquías. En un próximo post escribiré sobre el nuevo tipo de datos llamado
HierarchyID

Consultas de Combinación entre tablas de SQL

Las vinculaciones entre tablas se realizan mediante la cláusula INNER que combina
 registros de dos tablas siempre que haya concordancia de valores en un campo
común. Su sintaxis es:

SELECT campos FROM tb1 INNER JOIN tb2 ON

tb1.campo1 comp tb2.campo2

En donde:

tb1, tb2 Son los nombres de las tablas desde las que se combinan los registros.
Son los nombres de los campos que se combinan. Si no son numéricos,
campo1,
los campos deben ser del mismo tipo de datos y contener el mismo tipo
campo2
de datos, pero no tienen que tener el mismo nombre.
Es cualquier operador de comparación relacional: =, <,<>, <=, =>, ó
comp
>.

Se puede utilizar una operación INNER JOIN en cualquier cláusula FROM. Esto crea
una combinación por equivalencia, conocida también como unión interna. Las
combinaciones equivalentes son las más comunes; éstas combinan los registros de
dos tablas siempre que haya concordancia de valores en un campo común a ambas
tablas. Se puede utilizar INNER JOIN con las tablas Departamentos y Empleados
para seleccionar todos los empleados de cada departamento. Por el contrario, para
seleccionar todos los departamentos (incluso si alguno de ellos no tiene ningún
empleado asignado) se emplea LEFT JOIN o todos los empleados (incluso si alguno
no está asignado a ningún departamento), en este caso RIGHT JOIN.

Si se intenta combinar campos que contengan datos Memo u Objeto OLE, se

produce un error. Se pueden combinar dos campos numéricos cualesquiera, incluso
si son de diferente tipo de datos. Por ejemplo, puede combinar un campo Numérico
para el que la propiedad Size de su objeto Field está establecida como Entero, y un
campo Contador.

El ejemplo siguiente muestra cómo podría combinar las tablas Categorías y

Productos basándose en el campo IDCategoria:

SELECT
NombreCategoria, NombreProducto
FROM
Categorias
INNER JOIN
Productos
ON
Categorias.IDCategoria = Productos.IDCategoria

En el ejemplo anterior, IDCategoria es el campo combinado, pero no está incluido

en la salida de la consulta ya que no está incluido en la instrucción SELECT. Para
incluir el campo combinado, incluir el nombre del campo en la instrucción SELECT,
en este caso, Categorias.IDCategoria.

También se pueden enlazar varias cláusulas ON en una instrucción JOIN, utilizando

la sintaxis siguiente:

SELECT campos FROM tabla1 INNER JOIN tabla2

ON (tb1.campo1 comp tb2.campo1 AND ON tb1.campo2 comp tb2.campo2)
OR ON (tb1.campo3 comp tb2.campo3)

También puede anidar instrucciones JOIN utilizando la siguiente sintaxis:

SELECT campos FROM tb1 INNER JOIN (tb2 INNER JOIN [( ]tb3
[INNER JOIN [( ]tablax [INNER JOIN ...)]
ON tb3.campo3 comp tbx.campox)]
ON tb2.campo2 comp tb3.campo3)
ON tb1.campo1 comp tb2.campo2

Un LEFT JOIN o un RIGHT JOIN puede anidarse dentro de un INNER JOIN, pero un
INNER JOIN no puede anidarse dentro de un LEFT JOIN o un RIGHT JOIN.

Ejemplo:

SELECT DISTINCT
Sum(PrecioUnitario * Cantidad) AS Sales,
(Nombre + ' ' + Apellido) AS Name
FROM
Empleados
INNER JOIN(
Pedidos
INNER JOIN
DetallesPedidos
ON
Pedidos.IdPedido = DetallesPedidos.IdPedido)
ON
Empleados.IdEmpleado = Pedidos.IdEmpleado
GROUP BY
Nombre + ' ' + Apellido

(Crea dos combinaciones equivalentes: una entre las tablas Detalles de pedidos y
Pedidos, y la otra entre las tablas Pedidos y Empleados. Esto es necesario ya que la
tabla Empleados no contiene datos de ventas y la tabla Detalles de pedidos no
contiene datos de los empleados. La consulta produce una lista de empleados y sus
ventas totales.)

Si empleamos la cláusula INNER en la consulta se seleccionarán sólo aquellos

registros de la tabla de la que hayamos escrito a la izquierda de INNER JOIN que
contengan al menos un registro de la tabla que hayamos escrito a la derecha. Para
solucionar esto tenemos dos cláusulas que sustituyen a la palabra clave INNER,
estas cláusulas son LEFT y RIGHT. LEFT toma todos los registros de la tabla de la
izquierda aunque no tengan ningún registro en la tabla de la izquierda. RIGHT
realiza la misma operación pero al contrario, toma todos los registros de la tabla de
la derecha aunque no tenga ningún registro en la tabla de la izquierda.

La sintaxis expuesta anteriormente pertenece a ACCESS, en donde todas las

sentencias con la sintaxis funcionan correctamente. Los manuales de SQL-SERVER
dicen que esta sintaxis es incorrecta y que hay que añadir la palabra reservada
OUTER: LEFT OUTER JOIN y RIGHT OUTER JOIN. En la práctica funciona
correctamente de una u otra forma.

No obstante, los INNER JOIN ORACLE no es capaz de interpretarlos, pero existe una
sintaxis en formato ANSI para los INNER JOIN que funcionan en todos los sistemas.
Tomando como referencia la siguiente sentencia:

SELECT
Facturas.*,
Albaranes.*
FROM
Facturas
INNER JOIN
Albaranes
ON
Facturas.IdAlbaran = Albaranes.IdAlbaran
WHERE
Facturas.IdCliente = 325
La transformación de esta sentencia a formato ANSI sería la siguiente:

SELECT
Facturas.*,
Albaranes.*
FROM
Facturas, Albaranes
WHERE
Facturas.IdAlbaran = Albaranes.IdAlbaran
AND
Facturas.IdCliente = 325

Como se puede observar los cambios realizados han sido los siguientes:

1. Todas las tablas que intervienen en la consulta se especifican en la cláusula

FROM.
2. Las condiciones que vinculan a las tablas se especifican en la cláusula
WHERE y se vinculan mediante el operador lógico AND.

Referente a los OUTER JOIN, no funcionan en ORACLE y además conozco una

sintaxis que funcione en los tres sistemas. La sintaxis en ORACLE es igual a la
sentencia anterior pero añadiendo los caracteres (+) detrás del nombre de la tabla
en la que deseamos aceptar valores nulos, esto equivale a un LEFT JOIN:

SELECT
Facturas.*,
Albaranes.*
FROM
Facturas, Albaranes
WHERE
Facturas.IdAlbaran = Albaranes.IdAlbaran (+)
AND
Facturas.IdCliente = 325

Y esto a un RIGHT JOIN:

SELECT
Facturas.*,
Albaranes.*
FROM
Facturas, Albaranes
WHERE
Facturas.IdAlbaran (+) = Albaranes.IdAlbaran
AND
Facturas.IdCliente = 325

En SQL-SERVER se puede utilizar una sintaxis parecida, en este caso no se utiliza

los caracteres (+) sino los caracteres =* para el LEFT JOIN y *= para el RIGHT
JOIN.

Consultas de Autocombinación

La autocombinación se utiliza para unir una tabla consigo misma, comparando

valores de dos columnas con el mismo tipo de datos. La sintaxis en la siguiente:

SELECT
alias1.columna, alias2.columna, ...
FROM
tabla1 as alias1, tabla2 as alias2
WHERE
alias1.columna = alias2.columna
AND
otras condiciones
Por ejemplo, para visualizar el número, nombre y puesto de cada empleado, junto
con el número, nombre y puesto del supervisor de cada uno de ellos se utilizaría la
siguiente sentencia:

SELECT
t.num_emp, t.nombre, t.puesto, t.num_sup,s.nombre, s.puesto
FROM
empleados AS t, empleados AS s
WHERE
t.num_sup = s.num_emp

Consultas de Combinaciones no Comunes

La mayoría de las combinaciones están basadas en la igualdad de valores de las

columnas que son el criterio de la combinación. Las no comunes se basan en otros
operadores de combinación, tales como NOT, BETWEEN, <>, etc.

Por ejemplo, para listar el grado salarial, nombre, salario y puesto de cada
empleado ordenando el resultado por grado y salario habría que ejecutar la
siguiente sentencia:

SELECT
grados.grado,empleados.nombre, empleados.salario, empleados.puesto
FROM
empleados, grados
WHERE
empleados.salario BETWEEN grados.salarioinferior And grados.salariosuperior
ORDER BY
grados.grado, empleados.salario

Para listar el salario medio dentro de cada grado salarial habría que lanzar esta otra
sentencia:

SELECT
grados.grado, AVG(empleados.salario)
FROM
empleados, grados
WHERE
empleados.salario BETWEEN grados.salarioinferior And grados.salariosuperior
GROUP BY
grados.grado