Manual de Sql-Server Parte II

MANUAL DE SQL-SERVER PARTE II
2 – Funciones Matemáticas
Las funciones matemáticas realizan operaciones con expresiones numéricas y retornan un

resultado, operan con tipos de datos numéricos.
Microsoft SQL Server tiene algunas funciones para trabajar con números. Aquí presentamos
algunas.
-abs(x): retorna el valor absoluto del argumento "x". Ejemplo:
select abs(-20);
retorna 20.
-ceiling(x): redondea hacia arriba el argumento "x". Ejemplo:
select ceiling(12.34);
retorna 13.
-floor(x): redondea hacia abajo el argumento "x". Ejemplo:
select floor(12.34);
retorna 12.
- %: %: devuelve el resto de una división. Ejemplos:
select 10%3;
retorna 1.
select 10%2;
retorna 0.
-power(x,y): retorna el valor de "x" elevado a la "y" potencia. Ejemplo:
select power(2,3);
retorna 8.
-round(numero,longitud): retorna un número redondeado a la longitud especificada. "longitud"
debe ser tinyint, smallint o int. Si "longitud" es positivo, el número de decimales es redondeado
según "longitud"; si es negativo, el número es redondeado desde la parte entera según el valor de
"longitud". Ejemplos:
select round(123.456,1);
retorna "123.400", es decir, redondea desde el primer decimal.
select round(123.456,2);
retorna "123.460", es decir, redondea desde el segundo decimal.
select round(123.456,-1);
retorna "120.000", es decir, redondea desde el primer valor entero (hacia la izquierda).
select round(123.456,-2);
retorna "100.000", es decir, redondea desde el segundo valor entero (hacia la izquierda).
-sign(x): si el argumento es un valor positivo devuelve 1;-1 si es negativo y si es 0, 0.
-square(x): retorna el cuadrado del argumento. Ejemplo:
select square(3); retorna 9.
-srqt(x): devuelve la raiz cuadrada del valor enviado como argumento.
SQL Server dispone de funciones trigonométricas que retornan radianes.
Se pueden emplear estas funciones enviando como argumento el nombre de un campo de tipo
numérico.
Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla si existe:
1
Vamos a mostrar los precios de los libros redondeando el valor hacia abajo y hacia arriba:
select titulo,autor,precio, floor(precio) as abajo, ceiling(precio) as arriba
from libros;
if object_id ('libros') is not null

drop table libros;
create table libros(

codigo int identity,
titulo varchar(40) not null,
autor varchar(20) default 'Desconocido',
editorial varchar(20),
precio decimal(6,2),
primary key (codigo)
);
insert into libros (titulo,autor,editorial,precio)

values('El aleph','Borges','Emece',25.33);
insert into libros
values('Java en 10 minutos','Mario Molina','Siglo XXI',50.65);
insert into libros (titulo,autor,editorial,precio)
values('Alicia en el pais de las maravillas','Lewis
Carroll','Emece',19.95);
select titulo,autor,precio,
floor(precio) as abajo,
ceiling(precio) as arriba
from libros;
Microsoft SQL Server ofrece algunas funciones para trabajar con fechas y horas. Estas son algunas:
- getdate(): retorna la fecha y hora actuales. Ejemplo:
select getdate();
- datepart(partedefecha,fecha): retorna la parte específica de una fecha, el año, trimestre, día, hora, etc.
Los valores para "partedefecha" pueden ser: year (año), quarter (cuarto), month (mes), day (dia), week
(semana), hour (hora), minute (minuto), second (segundo) y millisecond (milisegundo). Ejemplos:
select datepart(month,getdate());
retorna el número de mes actual;
select datepart(day,getdate());
retorna el día actual;
select datepart(hour,getdate());
retorna la hora actual;
- datename(partedefecha,fecha): retorna el nombre de una parte específica de una fecha. Los valores para
"partedefecha" pueden ser los mismos que se explicaron anteriormente. Ejemplos:
select datename(month,getdate());
retorna el nombre del mes actual;
select datename(day,getdate());
- dateadd(partedelafecha,numero,fecha): agrega un intervalo a la fecha especificada, es decir, retorna una
fecha adicionando a la fecha enviada como tercer argumento, el intervalo de tiempo indicado por el primer
parámetro, tantas veces como lo indica el segundo parámetro. Los valores para el primer argumento pueden
ser: year (año), quarter (cuarto), month (mes), day (dia), week (semana), hour (hora), minute (minuto),
second (segundo) y millisecond (milisegundo).
Ejemplos:
select dateadd(day,3,'1980/11/02');
2
retorna "1980/11/05", agrega 3 días.

select dateadd(month,3,'1980/11/02');
retorna "1981/02/02", agrega 3 meses.
select dateadd(hour,2,'1980/11/02');
retorna "1980/02/02 2:00:00", agrega 2 horas.
select dateadd(minute,16,'1980/11/02');
retorna "1980/02/02 00:16:00", agrega 16 minutos.
- datediff(partedelafecha,fecha1,fecha2): calcula el intervalo de tiempo (según el primer argumento) entre
las 2 fechas. El resultado es un valor entero que corresponde a fecha2-fecha1. Los valores de
"partedelafecha) pueden ser los mismos que se especificaron anteriormente. Ejemplos:
select datediff (day,'2005/10/28','2006/10/28');
retorna 365 (días).
select datediff(month,'2005/10/28','2006/11/29');
retorna 13 (meses).
- day(fecha): retorna el día de la fecha especificada. Ejemplo:
select day(getdate());
- month(fecha): retorna el mes de la fecha especificada. Ejemplo:
select month(getdate());
- year(fecha): retorna el año de la fecha especificada. Ejemplo:
select year(getdate());
Se pueden emplear estas funciones enviando como argumento el nombre de un campo de tipo datetime o
smalldatetime.
Datos a cargar
drop table libros;

edicion datetime,
precio decimal(6,2)
);
insert into libros values('El

aleph','Borges','Emece','1980/10/10',25.33);
insert into libros values('Java en 10 minutos','Mario Molina','Siglo
XXI','2000/05/05',50.65);
insert into libros values('Alicia en el pais de las maravillas','Lewis
Carroll','Emece','2000/08/09',19.95);
insert into libros values('Aprenda PHP','Mario Molina','Siglo
XXI','2000/02/04',45);
3
Mostramos el título del libro y el año de edición:

select titulo, datepart (year,edicion) from libros;
Mostrar pantalla
Mostramos el título del libro y el nombre del mes de edición:

select titulo, datename (month,edicion) from libros;
Mostrar pantalla
4
Mostramos el título del libro y los años que tienen de editados:

select titulo, datediff(year,edicion,getdate()) from libros;
Mostrar pantalla
Muestre los títulos de los libros que se editaron el día 9, de cualquier mes de cualquier año:
select titulo from libros
where datepart(day,edicion)=9;
Mostrar pantalla
Ejercicio
5
Primer problema:
Una empresa almacena los datos de sus empleados en una tabla denominada
"empleados".
1- Elimine la tabla si existe:
if object_id ('empleados') is not null
drop table empleados;
2- Cree la tabla:
create table empleados(
nombre varchar(30) not null,
apellido varchar(20) not null,
documento char(8),
fechanacimiento datetime,
fechaingreso datetime,
sueldo decimal(6,2),
primary key(documento)
);
3- Ingrese algunos registros:
insert into empleados
values('Ana','Acosta','22222222','1970/10/10','1995/05/05',228.50);
values('Carlos','Caseres','25555555','1978/02/06','1998/05/05',309);
values('Francisco','Garcia','26666666','1978/10/15','1998/10/02',250.68);
values('Gabriela','Garcia','30000000','1985/10/25','2000/12/22',300.25);
values('Luis','Lopez','31111111','1987/02/10','2000/08/21',350.98);
4- Muestre nombre y apellido concatenados, con el apellido en letras

mayúsculas, el documento precedido por "DNI Nº " y el sueldo precedido
por "$ ".
Mostrar pantalla
6
5- Muestre el documento y el sueldo redondeado hacia arriba y precedido

por "$ ".
Mostrar pantalla
6- Muestre los nombres y apellidos de los empleados que cumplen años en

el mes "october" (3 registros)
Mostrar pantalla
7
7- Muestre los nombres y apellidos de los empleados que ingresaron en un

determinado año (2 registros).
Mostrar pantalla
29 - Operadores lógicos ( and - or - not)
Hasta el momento, hemos aprendido a establecer una condición con "where"

utilizando operadores relacionales. Podemos establecer más de una
condición con la cláusula "where", para ello aprenderemos los operadores
lógicos.
Son los siguientes:
- and, significa "y",
- or, significa "y/o",
- not, significa "no", invierte el resultado
- (), paréntesis
Los operadores lógicos se usan para combinar condiciones.
Si queremos recuperar todos los libros cuyo autor sea igual a "Borges" y
cuyo precio no supere los 20 pesos, necesitamos 2 condiciones:
select *from libros
where (autor='Borges') and
(precio<=20);
Los registros recuperados en una sentencia que une 2 condiciones con el

operador "and", cumplen con las 2 condiciones.
Queremos ver los libros cuyo autor sea "Borges" y/o cuya editorial sea
"Planeta":
select *from libros

where autor='Borges' or
editorial='Planeta';
En la sentencia anterior usamos el operador "or"; indicamos que recupere

los libros en los cuales el valor del campo "autor" sea "Borges" y/o el
8
valor del campo "editorial" sea "Planeta", es decir, seleccionará los

registros que cumplan con la primera condición, con la segunda condición
o con ambas condiciones.
Los registros recuperados con una sentencia que une 2 condiciones con el
operador "or", cumplen 1 de las condiciones o ambas.
Queremos recuperar los libros que NO cumplan la condición dada, por
ejemplo, aquellos cuya editorial NO sea "Planeta":
select *from libros

where not editorial='Planeta';
El operador "not" invierte el resultado de la condición a la cual

antecede.
Los registros recuperados en una sentencia en la cual aparece el operador
"not", no cumplen con la condición a la cual afecta el "NOT".
Los paréntesis se usan para encerrar condiciones, para que se evalúen
como una sola expresión.
Cuando explicitamos varias condiciones con diferentes operadores lógicos
(combinamos "and", "or") permite establecer el orden de prioridad de la
evaluación; además permite diferenciar las expresiones más claramente.
Por ejemplo, las siguientes expresiones devuelven un resultado diferente:
select*from libros
where (autor='Borges') or
(editorial='Paidos' and precio<20);
select *from libros

where (autor='Borges' or editorial='Paidos') and
(precio<20);
Si bien los paréntesis no son obligatorios en todos los casos, se

recomienda utilizarlos para evitar confusiones.
El orden de prioridad de los operadores lógicos es el siguiente: "not" se
aplica antes que "and" y "and" antes que "or", si no se especifica un
orden de evaluación mediante el uso de paréntesis.
El orden en el que se evalúan los operadores con igual nivel de
precedencia es indefinido, por ello se recomienda usar los paréntesis.
Entonces, para establecer más de una condición en un "where" es necesario
emplear operadores lógicos. "and" significa "y", indica que se cumplan
ambas condiciones; "or" significa "y/o", indica que se cumpla una u otra
condición (o ambas); "not" significa "no", indica que no se cumpla la
condición especificada.
Problema:

drop table libros;
Creamos la tabla:
);
9
Ingresamos algunos registros:

insert into libros
insert into libros
values('Antología poética','Borges','Planeta',39.50);
insert into libros
values('Java en 10 minutos','Mario Molina','Planeta',50.50);
insert into libros
Carroll','Emece',19.90);
insert into libros
values('Martin Fierro','Jose Hernandez','Emece',25.90);
insert into libros
values('Martin Fierro','Jose Hernandez','Paidos',16.80);
insert into libros
values('Aprenda PHP','Mario Molina','Emece',19.50);
insert into libros
values('Cervantes y el quijote','Borges','Paidos',18.40);
Recuperamos los libros cuyo autor sea igual a "Borges" y cuyo precio no
supere los 20 pesos:
select *from libros
where (autor='Borges') and
(precio<=20);
Seleccionamos los libros cuyo autor es "Borges" y/o cuya editorial es
"Planeta":
select *from libros
where autor='Borges' or
editorial='Planeta';
Recuperamos los libros cuya editorial NO es "Planeta":
select *from libros
where not editorial='Planeta';
Veamos cómo el uso de paréntesis hace que SQL Server evalúe en forma
diferente ciertas consultas aparentemente iguales:
Select * from libros
where (autor='Borges') or
(editorial='Paidos' and precio<20);
select *from libros

where (autor='Borges' or editorial='Paidos') and
(precio<20);
Primer problema:
Trabaje con la tabla llamada "medicamentos" de una farmacia.

1- Elimine la tabla, si existe:
if object_id('medicamentos') is not null
drop table medicamentos;
2- Cree la tabla con la siguiente estructura:

create table medicamentos(
nombre varchar(20),
laboratorio varchar(20),
10
cantidad tinyint,
primary key(codigo)
);

insert into medicamentos
values('Sertal','Roche',5.2,100);
values('Buscapina','Roche',4.10,200);
values('Amoxidal 500','Bayer',15.60,100);
values('Paracetamol 500','Bago',1.90,200);
values('Bayaspirina','Bayer',2.10,150);
values('Amoxidal jarabe','Bayer',5.10,250);
4- Recupere los códigos y nombres de los medicamentos cuyo laboratorio

sea 'Roche' y cuyo precio sea
menor a 5 (1 registro cumple con ambas condiciones)
inserte pantalla
11
5- Recupere los medicamentos cuyo laboratorio sea 'Roche' o cuyo precio

sea menor a 5 (4 registros):
select * from medicamentos
where laboratorio='Roche' or
precio<5;
Note que el resultado es diferente al del punto 4, hemos cambiado el
operador de la sentencia
anterior.
inserte pantalla
6- Muestre todos los medicamentos cuyo laboratorio NO sea "Bayer" y cuya

cantidad sea=100 (1 registro)
inserte pantalla
12
7- Muestre todos los medicamentos cuyo laboratorio sea "Bayer" y cuya

cantidad NO sea=100 (2 registros):
select * from medicamentos
where laboratorio='Bayer' and
not cantidad=100;
inserte pantalla
Analice estas 2 últimas sentencias. El operador "not" afecta a la

condición a la cual antecede, no a las siguientes. Los resultados de los
puntos 6 y 7 son diferentes.
13
8- Elimine todos los registros cuyo laboratorio sea igual a "Bayer" y su

precio sea mayor a 10 (1 registro eliminado)
inserte pantalla
9- Cambie la cantidad por 200, a todos los medicamentos de "Roche" cuyo

precio sea mayor a 5 (1 registro afectado)
inserte pantalla
14
10- Borre los medicamentos cuyo laboratorio sea "Bayer" o cuyo precio sea
menor a 3 (3 registros borrados)
inserte pantalla
Segundo problema:
Trabajamos con la tabla "peliculas" de un video club que alquila

películas en video.
1- Elimine la tabla, si existe;
if object_id('peliculas') is not null
drop table peliculas;
2- Créela con la siguiente estructura:

create table peliculas(
actor varchar(20),
duracion tinyint,
primary key (codigo)
);

insert into peliculas
values('Mision imposible','Tom Cruise',120);
values('Harry Potter y la piedra filosofal','Daniel R.',180);
values('Harry Potter y la camara secreta','Daniel R.',190);
values('Mision imposible 2','Tom Cruise',120);
values('Mujer bonita','Richard Gere',120);
values('Tootsie','D. Hoffman',90);
15

values('Un oso rojo','Julio Chavez',100);
values('Elsa y Fred','China Zorrilla',110);
4- Recupere los registros cuyo actor sea "Tom Cruise" or "Richard Gere"
(3 registros)
inserte pantalla
5- Recupere los registros cuyo actor sea "Tom Cruise" y duración menor a
100 (ninguno cumple ambas condiciones)
inserte pantalla
16
6- Cambie la duración a 200, de las películas cuyo actor sea "Daniel R."
y cuya duración sea 180 (1registro afectado)
inserte pantalla
7- Borre todas las películas donde el actor NO sea "Tom Cruise" y cuya
duración sea mayor o igual a 100 (2 registros eliminados)
inserte pantalla
Otros operadores relacionales (between)

Hemos visto los operadores relacionales: = (igual), <> (distinto), > (mayor), < (menor), >= (mayor o igual), <=
(menor o igual), is null/is not null (si un valor es NULL o no).
Otro operador relacional es "between", trabajan con intervalos de valores.
17
Hasta ahora, para recuperar de la tabla "libros" los libros con precio mayor o igual a 20 y menor o igual a 40,
usamos 2 condiciones unidas por el operador lógico "and":
select *from libros
where precio>=20 and precio<=40;
Podemos usar "between" y así simplificar la consulta:

select *from libros
where precio between 20 and 40;
Averiguamos si el valor de un campo dado (precio) está entre los valores mínimo y máximo especificados (20
y 40 respectivamente).
"between" significa "entre". Trabaja con intervalo de valores.
Este operador se puede emplear con tipos de datos numéricos y money (en tales casos incluyen los valores
mínimo y máximo) y tipos de datos fecha y hora (incluye sólo el valor mínimo).
No tiene en cuenta los valores "null".
Si agregamos el operador "not" antes de "between" el resultado se invierte, es decir, se recuperan los
registros que están fuera del intervalo especificado. Por ejemplo, recuperamos los libros cuyo precio NO se
encuentre entre 20 y 35, es decir, los menores a 15 y mayores a 25:
select *from libros
where precio not between 20 and 35;
Siempre que sea posible, emplee condiciones de búsqueda positivas ("between"), evite las negativas ("not
between") porque hace más lenta la recuperación de los datos.
Entonces, se puede usar el operador "between" para reducir las condiciones "where".
Problema:
drop table libros;
Creamos la tabla:
);
insert into libros
insert into libros
values('Cervantes y el quijote','Borges','Paidos',null);
insert into libros
values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);
insert into libros
values('Martin Fierro','Jose Hernandez','Emece',25.90);
insert into libros (titulo,autor,precio)
values('Antología poética','Borges',32);
values('Java en 10 minutos','Mario Molina',45.80);
values('Martin Fierro','Jose Hernandez',40);
18
values('Aprenda PHP','Mario Molina',56.50);

Recuperamos los registros cuyo precio esté entre 20 y 40 empleando "between":
select *from libros

where precio between 20 and 40;
Note que si el campo tiene el valor "null", no aparece en la selección.

Para seleccionar los libros cuyo precio NO esté entre un intervalo de valores antecedemos "not" al
"between":
select *from libros

where precio not between 20 and 35;
problema
Primer problema:
En una página web se guardan los siguientes datos de las visitas: número de visita, nombre, mail,
pais, fechayhora de la visita.
1- Elimine la tabla "visitas", si existe:
if object_id('visitas') is not null
drop table visitas;

create table visitas (
numero int identity,
nombre varchar(30) default 'Anonimo',
mail varchar(50),
pais varchar (20),
fechayhora datetime,
primary key(numero)
);

insert into visitas (nombre,mail,pais,fechayhora)
values ('Ana Maria Lopez','[email protected]','Argentina','2006-10-10 10:10');
values ('Gustavo Gonzalez','[email protected]','Chile','2006-10-10 21:30');
values ('Juancito','[email protected]','Argentina','2006-10-11 15:45');
values ('Fabiola Martinez','[email protected]','Mexico','2006-10-12 08:15');
values ('Fabiola Martinez','[email protected]','Mexico','2006-09-12 20:45');
insert into visitas (nombre,mail,pais)
values ('Federico1','[email protected]','Argentina');
19
4- Seleccione los usuarios que visitaron la página entre el '2006-09-12' y '2006-10-11' (5

registros)
Note que incluye los de fecha mayor o igual al valor mínimo y menores al valor máximo, y que los
valores null no se incluyen.
5- Recupere las visitas cuyo número se encuentra entre 2 y 5 (4 registros)

Note que incluye los valores límites.
32 - Otros operadores relacionales (in)
Se utiliza "in" para averiguar si el valor de un campo está incluido en una lista de valores especificada.
En la siguiente sentencia usamos "in" para averiguar si el valor del campo autor está incluido en la lista de
valores especificada (en este caso, 2 cadenas).
Hasta ahora, para recuperar los libros cuyo autor sea 'Paenza' o 'Borges' usábamos 2 condiciones:
select *from libros
where autor='Borges' or autor='Paenza';
Podemos usar "in" y simplificar la consulta:
select *from libros
where autor in('Borges','Paenza');
Para recuperar los libros cuyo autor no sea 'Paenza' ni 'Borges' usábamos:
select *from libros
where autor<>'Borges' and
autor<>'Paenza';
También podemos usar "in" anteponiendo "not":
select *from libros
where autor not in ('Borges','Paenza');
Empleando "in" averiguamos si el valor del campo está incluido en la lista de valores especificada; con "not"
antecediendo la condición, invertimos el resultado, es decir, recuperamos los valores que no se encuentran
(coindicen) con la lista de valores.
Los valores "null" no se consideran.
Recuerde: siempre que sea posible, emplee condiciones de búsqueda positivas ("in"), evite las negativas
("not in") porque con ellas se evalúan todos los registros y esto hace más lenta la recuperación de los datos.
problema
Primer problema:


nombre varchar(20),
cantidad tinyint,
fechavencimiento datetime not null,
20
primary key(codigo) );

values('Sertal','Roche',5.2,1,'2005-02-01');
values('Buscapina','Roche',4.10,3,'2006-03-01');
values('Amoxidal 500','Bayer',15.60,100,'2007-05-01');
values('Paracetamol 500','Bago',1.90,20,'2008-02-01');
values('Bayaspirina','Bayer',2.10,150,'2009-12-01');
values('Amoxidal jarabe','Bayer',5.10,250,'2010-10-01');
4- Recupere los nombres y precios de los medicamentos cuyo laboratorio sea "Bayer" o "Bago" empleando
el operador "in" (4 registros)
Inserte pantalla
21
5- Seleccione los remedios cuya cantidad se encuentre entre 1 y 5 empleando el operador "between" y
luego el operador "in" (2 registros):
select *from medicamentos
where cantidad between 1 and 5;
select *from medicamentos
where cantidad in (1,2,3,4,5);
Note que es más conveniente emplear, en este caso, el operador ""between".
Inserte pantalla
33 - Búsqueda de patrones (like - not like)

Existe un operador relacional que se usa para realizar comparaciones exclusivamente de cadenas, "like" y
"not like".
Hemos realizado consultas utilizando operadores relacionales para comparar cadenas. Por ejemplo,
sabemos recuperar los libros cuyo autor sea igual a la cadena "Borges":
select *from libros
where autor='Borges';
El operador igual ("=") nos permite comparar cadenas de caracteres, pero al realizar la comparación, busca
coincidencias de cadenas completas, realiza una búsqueda exacta.
Imaginemos que tenemos registrados estos 2 libros:
"El Aleph", "Borges";
"Antologia poetica", "J.L. Borges";
Si queremos recuperar todos los libros de "Borges" y especificamos la siguiente condición:
select *from libros
where autor='Borges';
sólo aparecerá el primer registro, ya que la cadena "Borges" no es igual a la cadena "J.L. Borges".
Esto sucede porque el operador "=" (igual), también el operador "<>" (distinto) comparan cadenas de
caracteres completas. Para comparar porciones de cadenas utilizamos los operadores "like" y "not like".
Entonces, podemos comparar trozos de cadenas de caracteres para realizar consultas. Para recuperar todos
los registros cuyo autor contenga la cadena "Borges" debemos escribir:
select *from libros
22
where autor like "%Borges%";

El símbolo "%" (porcentaje) reemplaza cualquier cantidad de caracteres (incluyendo ningún caracter). Es un
caracter comodín. "like" y "not like" son operadores de comparación que señalan igualdad o diferencia.
Para seleccionar todos los libros que comiencen con "M":
select *from libros
where titulo like 'M%';
Note que el símbolo "%" ya no está al comienzo, con esto indicamos que el título debe tener como primera
letra la "M" y luego, cualquier cantidad de caracteres.
Para seleccionar todos los libros que NO comiencen con "M":
select *from libros
where titulo not like 'M%';
Así como "%" reemplaza cualquier cantidad de caracteres, el guión bajo "_" reemplaza un caracter, es otro
caracter comodín. Por ejemplo, queremos ver los libros de "Lewis Carroll" pero no recordamos si se escribe
"Carroll" o "Carrolt", entonces tipeamos esta condición:
select *from libros
where autor like "%Carrol_";
Otro caracter comodín es [] reemplaza cualquier carácter contenido en el conjunto especificado dentro de
los corchetes.
Para seleccionar los libros cuya editorial comienza con las letras entre la "P" y la "S" usamos la siguiente
sintaxis:
select titulo,autor,editorial
from libros
where editorial like '[P-S]%';
Ejemplos:
... like '[a-cf-i]%': busca cadenas que comiencen con a,b,c,f,g,h o i;
... like '[-acfi]%': busca cadenas que comiencen con -,a,c,f o i;
... like 'A[_]9%': busca cadenas que comiencen con 'A_9';
... like 'A[nm]%': busca cadenas que comiencen con 'An' o 'Am'.
El cuarto caracter comodín es [^] reemplaza cualquier caracter NO presente en el conjunto especificado
dentro de los corchetes.
Para seleccionar los libros cuya editorial NO comienza con las letras "P" ni "N" tipeamos:
from libros
where editorial like '[^PN]%';
"like" se emplea con tipos de datos char, nchar, varchar, nvarchar o datetime. Si empleamos "like" con tipos
de datos que no son caracteres, SQL Server convierte (si es posible) el tipo de dato a caracter. Por ejemplo,
queremos buscar todos los libros cuyo precio se encuentre entre 10.00 y 19.99:
select titulo,precio from libros
where precio like '1_.%';
Queremos los libros que NO incluyen centavos en sus precios:
where precio like '%.00';
Para búsquedas de caracteres comodines como literales, debe incluirlo dentro de corchetes, por ejemplo, si
busca:
... like '%[%]%': busca cadenas que contengan el signo '%';
... like '%[_]%': busca cadenas que contengan el signo '_';
... like '%[[]%': busca cadenas que contengan el signo '[';
Problema:
23

drop table libros;
Creamos la tabla:
primary key(codigo)
);
insert into libros
insert into libros
values('Antología poética','J. L. Borges','Planeta',null);
insert into libros
values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);
insert into libros
values('Matematica estas ahi','Paenza','Siglo XXI',15);
insert into libros
values('Martin Fierro','Jose Hernandez',default,40);
insert into libros
values('Aprenda PHP','Mario Molina','Nuevo siglo',56.50);
Recuperamos todos los libros que contengan en el campo "autor" la cadena "Borges":
select *from libros
where autor like '%Borges%';
Seleccionamos los libros cuyos títulos comienzan con la letra "M":

select *from libros
where titulo like 'M%';
Seleccionamos todos los títulos que NO comienzan con "M":

select *from libros
where titulo not like 'M%';
Si queremos ver los libros de "Lewis Carroll" pero no recordamos si se escribe "Carroll" o "Carrolt", podemos
emplear el comodín "_" (guión bajo) y establecer la siguiente condición:
select *from libros
where autor like '%Carrol_';
Buscamos los libros cuya editorial comienza con las letras entre la "P" y la "S":
from libros
where editorial like '[P-S]%';
Seleccionamos los libros cuya editorial NO comienza con las letras "P" ni "N":
from libros
where editorial like '[^PN]%';
24
Recuperamos todos los libros cuyo precio se encuentra entre 10.00 y 19.99:
where precio like '1_.%';
Recuperamos los libros que NO incluyen centavos en sus precios:

where precio like '%.00';
Primer problema:
Una empresa almacena los datos de sus empleados en una tabla "empleados".
if object_id('empleados') is not null
2- Cree la tabla:
nombre varchar(30),
documento char(8),
domicilio varchar(30),
fechaingreso datetime,
seccion varchar(20),
);

values('Juan Perez','22333444','Colon 123','1990-10-08','Gerencia',900.50);
values('Ana Acosta','23444555','Caseros 987','1995-12-18','Secretaria',590.30);
values('Lucas Duarte','25666777','Sucre 235','2005-05-15','Sistemas',790);
values('Pamela Gonzalez','26777888','Sarmiento 873','1999-02-12','Secretaria',550);
values('Marcos Juarez','30000111','Rivadavia 801','2002-09-22','Contaduria',630.70);
values('Yolanda Perez','35111222','Colon 180','1990-10-08','Administracion',400);
values('Rodolfo Perez','35555888','Coronel Olmedo 588','1990-05-28','Sistemas',800);
25
4- Muestre todos los empleados con apellido "Perez" empleando el operador "like" (3 registros)
Inserte pantalla
5- Muestre todos los empleados cuyo domicilio comience con "Co" y tengan un "8" (2 registros)
Inserte pantalla
26
6- Seleccione todos los empleados cuyo documento finalice en 0,2,4,6 u 8 (4 registros)

Inserte pantalla
7- Seleccione todos los empleados cuyo documento NO comience con 1 ni 3 y cuyo nombre finalice en "ez"
(2 registros)
Inserte pantalla
27
8- Recupere todos los nombres que tengan una "y" o una "j" en su nombre o apellido (3 registros)
Inserte pantalla
9- Muestre los nombres y sección de los empleados que pertenecen a secciones que comiencen con "S" o
"G" y tengan 8 caracteres (3 registros)
Inserte pantalla
28
10- Muestre los nombres y sección de los empleados que pertenecen a secciones que NO comiencen con "S"
o "G" (2 registros)
Inserte pantalla
11- Muestre todos los nombres y sueldos de los empleados cuyos sueldos incluyen centavos (3 registros)
Inserte pantalla
29
12- Muestre los empleados que hayan ingresado en "1990" (3 registros)

Inserte pantalla
34 - Contar registros (count)

Existen en SQL Server funciones que nos permiten contar registros, calcular sumas, promedios, obtener
valores máximos y mínimos. Estas funciones se denominan funciones de agregado y operan sobre un
conjunto de valores (registros), no con datos individuales y devuelven un único valor.
Imaginemos que nuestra tabla "libros" contiene muchos registros. Para averiguar la cantidad sin necesidad
de contarlos manualmente usamos la función "count()":
select count(*)
from libros;
La función "count()" cuenta la cantidad de registros de una tabla, incluyendo los que tienen valor nulo.
También podemos utilizar esta función junto con la cláusula "where" para una consulta más específica.
Queremos saber la cantidad de libros de la editorial "Planeta":
select count(*)
from libros
where editorial='Planeta';
Para contar los registros que tienen precio (sin tener en cuenta los que tienen valor nulo), usamos la función
"count()" y en los paréntesis colocamos el nombre del campo que necesitamos contar:
select count(precio)
from libros;
Note que "count(*)" retorna la cantidad de registros de una tabla (incluyendo los que tienen valor "null")
mientras que "count(precio)" retorna la cantidad de registros en los cuales el campo "precio" no es nulo. No
es lo mismo. "count(*)" cuenta registros, si en lugar de un asterisco colocamos como argumento el nombre
de un campo, se contabilizan los registros cuyo valor en ese campo NO es nulo.
30
Problema:


drop table libros;
Creamos la tabla:

primary key(codigo)
);
insert into libros

insert into libros
values('Antología poética','J. L. Borges','Planeta',null);
insert into libros
Carroll',null,19.90);
insert into libros
values('Matematica estas ahi','Paenza','Siglo XXI',15);
insert into libros
values('Martin Fierro','Jose Hernandez',default,40);
insert into libros
values('Aprenda PHP','Mario Molina','Nuevo siglo',null);
insert into libros
values('Uno','Richard Bach','Planeta',20);
Averiguemos la cantidad de libros usando la función "count()":
select count(*)
from libros;
Note que incluye todos los libros aunque tengan valor nulo en algún campo.
Contamos los libros de editorial "Planeta":
select count(*)
from libros
where editorial='Planeta';
Contamos los registros que tienen precio (sin tener en cuenta los que tienen valor nulo), usando la
función "count(precio)":
31
select count(precio)
from libros;
Primer problema:


nombre varchar(20),
cantidad tinyint,
fechavencimiento datetime not null,
numerolote int default null,
primary key(codigo)
);

values('Sertal','Roche',5.2,1,'2005-02-01',null);
values('Buscapina','Roche',4.10,3,'2006-03-01',null);
values('Amoxidal 500','Bayer',15.60,100,'2007-05-01',null);
values('Paracetamol 500','Bago',1.90,20,'2008-02-01',null);
values('Bayaspirina',null,2.10,null,'2009-12-01',null);
values('Amoxidal jarabe','Bayer',null,250,'2009-12-15',null);
32
4- Muestre la cantidad de registros empleando la función "count(*)" (6 registros)

inserte pantalla
5- Cuente la cantidad de medicamentos que tienen laboratorio conocido (5 registros)

inserte pantalla
33
6- Cuente la cantidad de medicamentos que tienen precio distinto a "null" y que tienen
cantidad distinto a "null", disponer alias para las columnas.
inserte pantalla
7- Cuente la cantidad de remedios con precio conocido, cuyo laboratorio comience con
"B" (2 registros)
inserte pantalla
34
8- Cuente la cantidad de medicamentos con número de lote distitno de "null" (0

registros)
inserte pantalla
36 - Funciones de agrupamiento (count - sum - min - max - avg)
Hemos visto que SQL Server tiene funciones que nos permiten contar registros, calcular
sumas, promedios, obtener valores máximos y mínimos, las funciones de agregado.
Ya hemos aprendido una de ellas, "count()", veamos otras.
Se pueden usar en una instrucción "select" y combinarlas con la cláusula "group by".
Todas estas funciones retornan "null" si ningún registro cumple con la condición del
"where", excepto "count" que en tal caso retorna cero.
El tipo de dato del campo determina las funciones que se pueden emplear con ellas.
Las relaciones entre las funciones de agrupamiento y los tipos de datos es la siguiente:
- count: se puede emplear con cualquier tipo de dato.
- min y max: con cualquier tipo de dato.
- sum y avg: sólo en campos de tipo numérico.
La función "sum()" retorna la suma de los valores que contiene el campo especificado. Si
queremos saber la cantidad total de libros que tenemos disponibles para la venta,
debemos sumar todos los valores del campo "cantidad":
35
select sum(cantidad)
from libros;
Para averiguar el valor máximo o mínimo de un campo usamos las funciones "max()" y
"min()" respectivamente.
Queremos saber cuál es el mayor precio de todos los libros:
select max(precio)
from libros;
Entonces, dentro del paréntesis de la función colocamos el nombre del campo del cuál
queremos el máximo valor.
La función "avg()" retorna el valor promedio de los valores del campo especificado.
Queremos saber el promedio del precio de los libros referentes a "PHP":
select avg(precio)
from libros
where titulo like '%PHP%';
Ahora podemos entender porque estas funciones se denominan "funciones de

agrupamiento", porque operan sobre conjuntos de registros, no con datos individuales.
Tratamiento de los valores nulos:
Si realiza una consulta con la función "count" de un campo que contiene 18 registros, 2 de
los cuales contienen valor nulo, el resultado devuelve un total de 16 filas porque no
considera aquellos con valor nulo.
Todas las funciones de agregado, excepto "count(*)", excluye los valores nulos de los
campos. "count(*)" cuenta todos los registros, incluidos los que contienen "null".
Primer problema:
Una empresa almacena los datos de sus empleados en una tabla "empleados".
if object_id('empleados') is not null
2- Cree la tabla:
nombre varchar(30),
documento char(8),
seccion varchar(20),
cantidadhijos tinyint,
36
);

values('Juan Perez','22333444','Colon 123','Gerencia',5000,2);
values('Ana Acosta','23444555','Caseros 987','Secretaria',2000,0);
values('Lucas Duarte','25666777','Sucre 235','Sistemas',4000,1);
values('Pamela Gonzalez','26777888','Sarmiento 873','Secretaria',2200,3);
values('Marcos Juarez','30000111','Rivadavia 801','Contaduria',3000,0);
values('Yolanda Perez','35111222','Colon 180','Administracion',3200,1);
values('Rodolfo Perez','35555888','Coronel Olmedo 588','Sistemas',4000,3);
values('Martina Rodriguez','30141414','Sarmiento 1234','Administracion',3800,4);
values('Andres Costa','28444555',default,'Secretaria',null,null);
4- Muestre la cantidad de empleados usando "count" (9 empleados)

Inserte pantalla
37
5- Muestre la cantidad de empleados con sueldo no nulo de la sección "Secretaria" (2

empleados)
Inserte pantalla
6- Muestre el sueldo más alto y el más bajo colocando un alias (5000 y 2000)
Inserte pantalla
38
7- Muestre el valor mayor de "cantidadhijos" de los empleados "Perez" (3 hijos)

Inserte pantalla
8- Muestre el promedio de sueldos de todo los empleados (3400. Note que hay un
sueldo nulo y no es tenido en cuenta)
Inserte pantalla
39
9- Muestre el promedio de sueldos de los empleados de la sección "Secretaría" (2100)

Inserte pantalla
10- Muestre el promedio de hijos de todos los empleados de "Sistemas" (2)

Inserte pantalla
38 - Seleccionar grupos (having)
Así como la cláusula "where" permite seleccionar (o rechazar) registros individuales; la

cláusula "having" permite seleccionar (o rechazar) un grupo de registros.
40
Si queremos saber la cantidad de libros agrupados por editorial usamos la siguiente

instrucción ya aprendida:
select editorial, count(*)

from libros
group by editorial;
Si queremos saber la cantidad de libros agrupados por editorial pero considerando sólo
algunos grupos, por ejemplo, los que devuelvan un valor mayor a 2, usamos la siguiente
instrucción:
select editorial, count(*) from libros

group by editorial
having count(*)>2;
Se utiliza "having", seguido de la condición de búsqueda, para seleccionar ciertas filas

retornadas por la cláusula "group by".
Veamos otros ejemplos. Queremos el promedio de los precios de los libros agrupados por
editorial, pero solamente de aquellos grupos cuyo promedio supere los 25 pesos:
select editorial, avg(precio) from libros

group by editorial
having avg(precio)>25;
En algunos casos es posible confundir las cláusulas "where" y "having". Queremos contar
los registros agrupados por editorial sin tener en cuenta a la editorial "Planeta".
Analicemos las siguientes sentencias:

where editorial<>'Planeta'
group by editorial;
group by editorial
having editorial<>'Planeta';
Ambas devuelven el mismo resultado, pero son diferentes. La primera, selecciona todos los
registros rechazando los de editorial "Planeta" y luego los agrupa para contarlos. La segunda,
selecciona todos los registros, los agrupa para contarlos y finalmente rechaza fila con la cuenta
correspondiente a la editorial "Planeta".
No debemos confundir la cláusula "where" con la cláusula "having"; la primera establece

condiciones para la selección de registros de un "select"; la segunda establece condiciones para la
selección de registros de una salida "group by".
Veamos otros ejemplos combinando "where" y "having". Queremos la cantidad de libros, sin
considerar los que tienen precio nulo, agrupados por editorial, sin considerar la editorial "Planeta":
41

where precio is not null
group by editorial
Aquí, selecciona los registros rechazando los que no cumplan con la condición dada en "where",
luego los agrupa por "editorial" y finalmente rechaza los grupos que no cumplan con la condición
dada en el "having".
Se emplea la cláusula "having" con funciones de agrupamiento, esto no puede hacerlo la cláusula
"where". Por ejemplo queremos el promedio de los precios agrupados por editorial, de aquellas
editoriales que tienen más de 2 libros:

group by editorial
having count(*) > 2;
En una cláusula "having" puede haber hasta 128 condiciones. Cuando utilice varias condiciones,
tiene que combinarlas con operadores lógicos (and, or, not).
Podemos encontrar el mayor valor de los libros agrupados y ordenados por editorial y seleccionar
las filas que tengan un valor menor a 100 y mayor a 30:
select editorial, max(precio) as 'mayor'

from libros
group by editorial
having min(precio)<100 and
min(precio)>30
order by editorial;
Entonces, usamos la claúsula "having" para restringir las filas que devuelve una salida "group by".
Va siempre después de la cláusula "group by" y antes de la cláusula "order by" si la hubiere.
Problema:

Eliminamos la tabla, si existe:
if object_id('libros') is not null

drop table libros;
Creamos la tabla:

titulo varchar(40),
autor varchar(30),
42
cantidad tinyint,
primary key(codigo)
);
insert into libros

values('El aleph','Borges','Planeta',35,null);
insert into libros
values('Martin Fierro','Jose Hernandez','Emece',22.20,200);
insert into libros
values('Martin Fierro','Jose Hernandez','Planeta',40,200);
insert into libros
values('Antologia poetica','J.L. Borges','Planeta',null,150);
insert into libros
values('Aprenda PHP','Mario Molina','Emece',18,null);
insert into libros
values('Manual de PHP', 'J.C. Paez', 'Siglo XXI',56,120);
insert into libros
values('Cervantes y el quijote','Bioy Casares- J.L.
Borges','Paidos',null,100);
insert into libros
values('Harry Potter y la piedra filosofal','J.K.
Rowling',default,45.00,90);
insert into libros
values('Harry Potter y la camara secreta','J.K.
Rowling','Emece',null,100);
insert into libros
Carroll','Paidos',42,80);
insert into libros
values('PHP de la A a la Z',null,null,110,0);
insert into libros
values('Uno','Richard Bach','Planeta',25,null);
Queremos saber la cantidad de libros agrupados por editorial pero considerando sólo algunos
grupos, por ejemplo, los que devuelvan un valor mayor a 2, usamos la siguiente instrucción:

group by editorial
having count(*)>2;
Queremos el promedio de los precios de los libros agrupados por editorial, pero solamente de
aquellos grupos cuyo promedio supere los 25 pesos:

group by editorial
having avg(precio)>25;
Queremos la cantidad de libros, sin considerar los que tienen precio nulo (where), agrupados por
editorial (group by), sin considerar la editorial "Planeta" (having):

where precio is not null
43
group by editorial
Necesitamos el promedio de los precios agrupados por editorial, de aquellas editoriales que tienen
más de 2 libros:

group by editorial
having count(*) > 2;
Buscamos el mayor valor de los libros agrupados y ordenados por editorial y seleccionamos las
filas que tienen un valor menor a 100 y mayor a 30:
select editorial, max(precio) as 'mayor'

from libros
group by editorial
having max(precio)<100 and
max(precio)>30
order by editorial;
Primer problema:
Una empresa tiene registrados sus clientes en una tabla llamada "clientes".
1- Elimine la tabla "clientes", si existe:
if object_id('clientes') is not null
drop table clientes;

create table clientes (
nombre varchar(30) not null,
ciudad varchar(20),
provincia varchar (20),
telefono varchar(11),
primary key(codigo)
);

insert into clientes
values ('Lopez Marcos','Colon 111','Cordoba','Cordoba','null');
values ('Perez Ana','San Martin 222','Cruz del Eje','Cordoba','4578585');
values ('Garcia Juan','Rivadavia 333','Villa del Rosario','Cordoba','4578445');
values ('Perez Luis','Sarmiento 444','Rosario','Santa Fe',null);
values ('Pereyra Lucas','San Martin 555','Cruz del Eje','Cordoba','4253685');
values ('Gomez Ines','San Martin 666','Santa Fe','Santa Fe','0345252525');
44
values ('Torres Fabiola','Alem 777','Villa del Rosario','Cordoba','4554455');

values ('Lopez Carlos',null,'Cruz del Eje','Cordoba',null);
values ('Ramos Betina','San Martin 999','Cordoba','Cordoba','4223366');
values ('Lopez Lucas','San Martin 1010','Posadas','Misiones','0457858745');
4- Obtenga el total de los registros agrupados por ciudad y provincia (6 filas)

inserte pantalla
45
5- Obtenga el total de los registros agrupados por ciudad y provincia sin considerar los
que tienen menos de 2 clientes (3 filas)
inserte pantalla
6- Obtenga el total de los clientes que viven en calle "San Martin" (where), agrupados
por provincia (group by), teniendo en cuenta todos los valores (all), de aquellas
ciudades que tengan menos de 2 clientes (having) y omitiendo la fila correspondiente a
la ciudad de "Cordoba" (having) (4 filas devueltas)
inserte pantalla
Segundo problema:
46
Un comercio que tiene un stand en una feria registra en una tabla llamada "visitantes"
algunos datos de las personas que visitan o compran en su stand para luego enviarle
publicidad de sus productos.
1- Elimine la tabla "visitantes", si existe:
if object_id('visitantes') is not null
drop table visitantes;

create table visitantes(
nombre varchar(30),
edad tinyint,
sexo char(1),
ciudad varchar(20),
telefono varchar(11),
montocompra decimal(6,2) not null
);

insert into visitantes
values ('Susana Molina',28,'f',null,'Cordoba',null,45.50);
values ('Marcela Mercado',36,'f','Avellaneda 345','Cordoba','4545454',22.40);
values ('Alberto Garcia',35,'m','Gral. Paz 123','Alta Gracia','03547123456',25);
values ('Teresa Garcia',33,'f',default,'Alta Gracia','03547123456',120);
values ('Roberto Perez',45,'m','Urquiza 335','Cordoba','4123456',33.20);
values ('Marina Torres',22,'f','Colon 222','Villa Dolores','03544112233',95);
values ('Julieta Gomez',24,'f','San Martin 333','Alta Gracia',null,53.50);
values ('Roxana Lopez',20,'f','null','Alta Gracia',null,240);
values ('Liliana Garcia',50,'f','Paso 999','Cordoba','4588778',48);
values ('Juan Torres',43,'m','Sarmiento 876','Cordoba',null,15.30);
47
4- Obtenga el total de las compras agrupados por ciudad y sexo de aquellas filas que
devuelvan un valor superior a 50 (3 filas)
inserte pantalla
5- Obtenga el total de las compras agrupados por ciudad y sexo (group by), teniendo
en cuenta todos los valores (all), considerando sólo los montos de compra superiores a
50 (where), los visitantes con teléfono (where), sin considerar la ciudad de "Cordoba"
(having), ordenados por ciudad (order by) (3 filas)
inserte pantalla
48
6- Muestre el monto mayor de compra agrupado por ciudad, siempre que dicho valor
supere los 50 pesos (having), considerando sólo los visitantes de sexo femenino y
domicilio conocido (where) (2 filas)
inserte pantalla
7- Agrupe por ciudad y sexo, muestre para cada grupo el total de visitantes, la suma
de sus compras y el promedio de compras, ordenado por la suma total y considerando
las filas con promedio superior a 30 (3 filas)
inserte pantalla
49

Manual de Sql-Server Parte II

Cargado por

Copyright:

Formatos disponibles

Manual de Sql-Server Parte II

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Sql-Server Parte II

Cargado por

Copyright:

Formatos disponibles

MANUAL DE SQL-SERVER PARTE II

Las funciones matemáticas realizan operaciones con expresiones numéricas y retornan un

if object_id ('libros') is not null

create table libros(

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

retorna "1980/11/05", agrega 3 días.

create table libros(

insert into libros values('El

Mostramos el título del libro y el año de edición:

Mostramos el título del libro y el nombre del mes de edición:

Mostramos el título del libro y los años que tienen de editados:

4- Muestre nombre y apellido concatenados, con el apellido en letras

5- Muestre el documento y el sueldo redondeado hacia arriba y precedido

6- Muestre los nombres y apellidos de los empleados que cumplen años en

7- Muestre los nombres y apellidos de los empleados que ingresaron en un

29 - Operadores lógicos ( and - or - not)

Hasta el momento, hemos aprendido a establecer una condición con "where"

Los registros recuperados en una sentencia que une 2 condiciones con el

select *from libros

En la sentencia anterior usamos el operador "or"; indicamos que recupere

valor del campo "editorial" sea "Planeta", es decir, seleccionará los

select *from libros

El operador "not" invierte el resultado de la condición a la cual

select *from libros

Si bien los paréntesis no son obligatorios en todos los casos, se

Trabajamos con la tabla "libros" de una librería.

Ingresamos algunos registros:

select *from libros

Trabaje con la tabla llamada "medicamentos" de una farmacia.

2- Cree la tabla con la siguiente estructura:

3- Ingrese algunos registros:

4- Recupere los códigos y nombres de los medicamentos cuyo laboratorio

5- Recupere los medicamentos cuyo laboratorio sea 'Roche' o cuyo precio

6- Muestre todos los medicamentos cuyo laboratorio NO sea "Bayer" y cuya

7- Muestre todos los medicamentos cuyo laboratorio sea "Bayer" y cuya

Analice estas 2 últimas sentencias. El operador "not" afecta a la

8- Elimine todos los registros cuyo laboratorio sea igual a "Bayer" y su

9- Cambie la cantidad por 200, a todos los medicamentos de "Roche" cuyo

Trabajamos con la tabla "peliculas" de un video club que alquila

2- Créela con la siguiente estructura:

3- Ingrese algunos registros:

insert into peliculas

Otros operadores relacionales (between)

Podemos usar "between" y así simplificar la consulta:

values('Aprenda PHP','Mario Molina',56.50);

select *from libros

Note que si el campo tiene el valor "null", no aparece en la selección.

select *from libros

2- Créela con la siguiente estructura:

3- Ingrese algunos registros:

4- Seleccione los usuarios que visitaron la página entre el '2006-09-12' y '2006-10-11' (5

5- Recupere las visitas cuyo número se encuentra entre 2 y 5 (4 registros)

32 - Otros operadores relacionales (in)

Trabaje con la tabla llamada "medicamentos" de una farmacia.

2- Cree la tabla con la siguiente estructura:

3- Ingrese algunos registros:

Note que es más conveniente emplear, en este caso, el operador ""between".

33 - Búsqueda de patrones (like - not like)

where autor like "%Borges%";