APUNTES DE SQL SERVER (Sistemas UNI)

Primera

Almacenamiento de la data.

Creando una base de datos

 Tipos de de archivos :
 Mdf
 Ldf
 Ndf
 Creando una Base de Datos
 La sentencia Create Database
 La sentencia Alter Database
 La sentencia Drop Database
 El dialogo New Database

CREATE DATABASE

CREATE DATABASEsample
ON
PRIMARY ( NAME=sample_data, FILENAME='c:\sample.mdf',
SIZE=10MB,
MAXSIZE=15MB,
FILEGROWTH=20%)
LOG ON
( NAME=sample_log, FILENAME='c:\sample.ldf',
SIZE=3MB,
MAXSIZE=5MB,
FILEGROWTH=1MB)

ALTER DATABASE

ALTER DATABASE simple

MODIFY FILE ( NAME = 'sample_log',
SIZE = 10MB)

DROP DATABASE

Drop Database Prueba

Drop Database Prueba, Pubs

CREABDO TABLAS

 La sentencia Create Table

 La sentencia Alter Table
  La sentencia Drop Table

TIPOS DE DATOS

Binarios binary[(n)], varbinary[(n)]

Caracteres char[(n)], varchar[(n)]
Fecha y hora datetime, smalldatetime
Números exactos decimal [(p[,s])], numeric[(p[,s])]
Números aproximados float[(n)], real
Enteros Int, smallint, tinyint
Monetario money, smallmoney
Especial bit, timestamp, def. por usuario
Texto e imagen text, image

CREANDO NUEVOS TIPOS DE DATOS

 Creando

EXEC sp_addtype isbn, 'smallint’, 'NOT NULL'

EXEC sp_addtype zipcode, 'char(10)'
EXEC sp_addtype longstring, 'varchar(63)'

 Eliminando

EXEC sp_droptype isbn

VALORES NULOS

Después de definir el nombre y tipo de campo se puede indicar que este pueda aceptar o no
valores nulos.

Id_Alumnos Char(4) NOT NULL,

Teléfono Char(7) NULL

LA SENTENCIA DE DROP TABLE

Drop table Alumnos

 Elimina una tabla.

 Si se tienen tablas relacionadas.

Primero deben ser eliminadas las foráneas y luego la primaria

use master --Pone como activa la BD master

 select* from sys.sysdatabases

if exists (Select name from sysdatabases where name =

'Ventas')
drop database Ventas

go

CREATE DATABASE Ventas

ON
PRIMARY ( NAME=Ventas_data,
FILENAME='G:\Program Files\Microsoft SQL
Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\Ventas.mdf',
SIZE=10MB,
MAXSIZE=15MB,
FILEGROWTH=20%)
LOG ON
( NAME=Ventas_log,
FILENAME='G:\Program Files\Microsoft SQL
Server\MSSQL12.MSSQLSERVER\MSSQL\DATA\Ventas.ldf',
SIZE=3MB,
MAXSIZE=5MB,
FILEGROWTH=1MB)

--------------------
select* from sys.sysdatabases

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

IMPLEMENTANDO INTEGRIDAD DE DATOS

Tipos de integridad de datos

¿Qué tipo de constraint usar ?

Definiendo Constraints: DEFAULT , CHECK,PRIMARY KEY ,UNIQUE Y FOREIGN

Concepto de Integridad

 Las reglas de integridad permiten que los datos conserven consistencia, complicación y
corrección.
 La integridad de datos evita la acumulación de datos innecesarios o repetidos.
 La integridad de datos da seguridad a la edición de la información.
TIPOS DE INTEGRIDAD DE DATOS

¿Qué TIPO DE CONSTRAINT USAR?

DEFINIENDO CONSTRAINTS

Los constraint se pueden definir con las sentencias CREATE TABLE o ALTER TABLE .

Constraints DEFAULT

 Se aplica en la sentencia INSERT

 Solo un DEFAULT por columna
 No puede ser usado con IDENTITY

Constraint CHECK

 Aplicado en INSERT y UDPATE

 Puede referenciar a otra columna de la misma tabla
 No se puede usar con IDENTITY
Constraint PRIMARY KEY

 Un PRIMARY KEY por tabla.

 Valores deben ser únicos.
 Valores null no son permitidos.
 Crea un índice único.

Constraints UNIQUE

 Evita datos repetidos

 Puede tener múltiples constraints UNIQUE en una Tabla.
 Definido con una o más columnas

Constraint FOREIGN KEY

 Debe referenciar a un constraint PRIMARY KEY o UNIQUE

 Puede tener varios en una tabla

Eliminando un CONSTRAINT
Scripts
use Datos

Create Table Personas( -- Cambia estructura de esta

tabla
id_Persona int Not NULL,
Nombre varchar(30),
Direccion varchar(30),
Telefono char(10),
Nacimiento DateTime
)

ALTER TABLE Personas --Modifica la estructura de esta tabla

ADD customer_name char(30) null

ALTER TABLE Personas --Modifica la estructura de esta tabla

DROP COLUMN customer_name

-----------------------Constraint DEFAULT ---------------------

----
Alter Table Personas
Add
Constraint dTelf DEFAULT '99999-9999' For Telefono
---------------------------------------------------------------
----

INSERT Personas(id_Persona, Nombre, Direccion, Nacimiento)

VALUES(1, 'Juan Pérez', 'Av. Arenales Nº 2255',
GetDate())

SELECT * FROM Personas

-----------------------Constraint CHECK -----------------------

----
Alter Table Personas
Add
Constraint cTelf CHECK
(Telefono like '9[0-9][0-9][0-9][0-9]-[0-9][0-9][0-
9][0-9]')
---------------------------------------------------------------
----

INSERT Personas
VALUES(2, 'Ana Ruiz', 'Av. Salaverry Nº 1122', '99962-
7944', GetDate())

SELECT * FROM Personas

INSERT Personas -- Este INSERT arroja error

VALUES(3, 'Jorge Risco', 'Av. Brasil Nº 1111', 'A9962-
7944', GetDate())

-----------------------Constraint UNIQUE ----------------------

----
ALTER TABLE Personas
ADD
CONSTRAINT nombre UNIQUE(Nombre)
 ---------------------------------------------------------------
----

INSERT Personas
VALUES(3, 'Jorge Risco', 'Av. Brasil Nº 1111', '99955-
7944', GetDate())

INSERT Personas -- Este INSERT arroja error

VALUES(4, 'Jorge Risco', 'Av. Rio Nº 2222', '99115-
7944', GetDate())

-----------------------Consulta de Constraints ----------------

----
SELECT name FROM sysobjects
where type='C' or -- CHECK
type='D' or -- DEFAULT
type='K' or -- UNIQUE
type='PK' or -- PRIMARY KEY
type='F' -- FOREIGN KEY
---------------------------------------------------------------
----
SELECT * FROM Personas
-----------------------Eliminando Constraints -----------------
----
Alter Table Personas
Drop dTelf

Alter Table Personas

Drop cTelf

Alter Table Personas

Drop nombre
---------------------------------------------------------------

MANTENIMIENTO DE DATOS

Sentencia INSERT

Desde otras tablas

Si no se especifica comunas, es porque se va ingresar datos a todas las columnas

Sentencia UPDATE

Desde otras tablas

Sentencia DELETE
Desde otras tablas
 SCRIPT
create database Datos

Use Datos

Create Table Alumnos

(
id_Alumno int Identity(1,1),
Nombre varchar(30) Not Null,
Direccion varchar(30),
Telefono char(8) Null,
Nacimiento datetime,
OtroDato varchar(200) Null
)

Alter Table Alumnos

Add
Constraint PKAlumnos Primary Key(id_Alumno)

--------------------------------------------Insertando
registros

Insert Alumnos(Nombre, Direccion, Telefono, Nacimiento,

OtroDato)
Values('Juan Perez', 'Av. Arequipa 3025', '348-8020',
GetDate(), 'Es Pintor')

SET DATEFORMAT MDY

Insert Alumnos
Values('Ana Malpartida', 'Av. San Luis 1212', '143-
8520', '01/16/1960', 'Es Karateca')

Insert Alumnos
Values('Jorge Risco', 'Av. Brasil 1010', Null,
'01/16/1960', Null)

Insert Alumnos(Telefono, Nombre, Nacimiento, Direccion)

Values('811-2132', 'Luis Avalos', '10/30/1955 04:10PM',
'Av. Primavera 1111')

Insert Into Alumnos(Nombre, Direccion, Telefono, Nacimiento)

Values('Mary Godenzi', 'Av. Conquistadores 2222', NULL,
'12/25/1975 10:30AM')

Select * From Alumnos

SELECT Nombre, Telefono from Alumnos

-- Insertando registros desde otra tabla

Create Table NombreTelefono

(
Nombre varchar(30) Not Null,
Telefono char(8) Null,
)
Insert NombreTelefono -- No específica columnas porque se
ingresa a todas
Select Nombre, Telefono From Alumnos

Select * From NombreTelefono

--------------------------------------------Actualizando
registros

Update Alumnos
Set
OtroDato= 'Probando actualización'

-----
Select * From Alumnos

-----

Update Alumnos
Set
Telefono = '000-0000',
OtroDato = OtroDato + ' y Segunda actualización'
Where Telefono is NULL

-----
Select * From Alumnos

-- Modificando desde otra tabla

Update NombreTelefono
Set Telefono=
(Select Telefono From Alumnos
Where Nombre like 'Jorge Risco')
Where Telefono is null

Select * From NombreTelefono

--------------------------------------------Eliminado Filas

Delete Alumnos Where Telefono='000-0000'

Select * From Alumnos

Delete Alumnos -- Elimina todos los registros

-- Elimina mas rapido en eliminar

truncate table Alumnos

-- Eliminando desde otra tabla

Insert Alumnos
Values('Jorge Risco', 'Av. Brasil 1010', '000-0000',
'01/16/1960', Null)

Select * From Alumnos

Select * From NombreTelefono

Delete NombreTelefono
Where Telefono = (Select Telefono From Alumnos
Where Nombre like 'Jorge Risco')

-----------------------------------------------------
--Consulara
-----------------------------------------------------

select * from Alumnos

Select Nombre ,Direccion from Alumnos

Select Nombre,Telefono,otroDato from Alumnos

SCRIPT CONSULTAS 1
create database Datos
-- Crear tabla Alumnos
Create Table Alumnos(
Nombre varchar(30),
Nota1 int,
Nota2 int,
Nota3 int)

-- Insertar los siguientes registros

Insert Alumnos Values('Juan', 11, 12, 13)
Go
Insert Alumnos Values('Ana', 15, 16, 14)
Go
Insert Alumnos Values('Luis', 8, 9, 11)
Go
Insert Alumnos Values('Carlos', 11, 10, 9)
Go
Insert Alumnos Values('Jorge', 10, 11, 10)

--- Select con una tabla

-- [01] Mostrar todas las columnas de la tabla Alumnos

Select * From Alumnos

Order by Nombre DESC

-- [02] Mostrar todos las columnas de la tabla Alumnos

ordenados alfabéticamente

Select * From Alumnos Order By Nombre

-- [03] Mostrar Nombre y promedio de la tabla Alumnos en orden

de mérito

Select Nombre, (Nota1+Nota2+Nota3)/3 As Promedio From Alumnos

Order By 2 Desc

Select Nombre, (Nota1+Nota2+Nota3)/3 As Promedio From Alumnos

Order By Promedio Desc
-- [04] Mostrar todos las columnas más el promedio en orden de
mérito

select Nombre,Nota1,Nota2,Nota3,(Nota1+Nota2+Nota3)/3 As
Promedio from Alumnos Order By 5 Desc

-- [05] Muestra Nombre más Promedio de los aprobados en orden

alfabético

Select Nombre, (Nota1+Nota2+Nota3)/3 As Promedio

From Alumnos
Where (Nota1+Nota2+Nota3)/3 > 10
Order By Nombre

-- [06] Muestra todos las columnas donde la Nota3 este entre

[12, 15] y en orden alfabético

select * from Alumnos where Nota3>12 and Nota3<15 order by

Nombre desc

select * from Alumnos Where Nota3 Between 12 and 15 order by

Nombre

-- [07] Muestra todos las columnas donde la Nota3 es par y

aprobatoria y en orden alfabético

Select *
From Alumnos
Where Nota3 In(12,14,16,18,20)
Order By Nombre

Select *
From Alumnos
Where Nota3%2=0 and Nota3>10
Order By Nombre

-- [08] Muestra todos las columnas donde el nombre empieza con

J, y en orden alfabético

select * from Alumnos where Nombre like 'j%' order by Nombre

---------------------------------------------------------------
----
--COMODINES

--% 0, 1o varios caracteres cualquiera

-- 1 caracter cualquiera

--[aeiou] 1 caracter de sea vocal

--[^aeiou] 1 caracter que no es vocal
--[0-9] 1 caracter entre 0 y 9
---------------------------------------------------------------
------
-- [09] Muestra todos las columnas donde el nombre tiene una
letra u, y en orden alfabético

Select *
From Alumnos
Where Nombre Like '%u%'
Order By Nombre

-- [10] Muestra todos las columnas donde la segunda letra de

Nombre es vocal, y en orden alfabético

select * from Alumnos where Nombre like '_[aeiou]%' order by

Nombre

-- [11] Muestra todos las columnas donde la segunda letra de

Nombre no es vocal, y en orden alfabético

Select *
From Alumnos
Where Nombre Like '_[^aeiou]%'
Order By Nombre

-- [12] Muestra todos las columnas donde Nombre empieza con J y

termina con cualquier letra entre [m, p]

select * from Alumnos where Nombre LIKE 'J%[m-p]'

-- Eliminar tabla Alumnos

Drop Table Alumnos

Script CONSULTAS 2
create database Datos
------------------------------- Select con dos tablas
relacionadas

-- Creando las tablas Alumnos y Notas

Create Table Alumnos(
id_Alumno int Identity(1,1),
Nombre varchar(30),

Constraint PK_id_Alumno Primary Key(id_Alumno)

)

Create Table Notas(

id_Alumno int Not NULL,
 Nota int,

Constraint FK_id_Alumno Foreign Key(id_Alumno)

References Alumnos
)

-- Insertando registros en la tabla Alumnos

Insert Alumnos Values('Juan')
Insert Alumnos Values('Ana')
Insert Alumnos Values('Luis')
Insert Alumnos Values('Jorge')
Insert Alumnos Values('Carmen')

Select * From Alumnos

-- Insertando registros en la tabla Notas

-- Ejecutar estas 5 líneas marcándolas

Declare @id int
Select @id= (Select id_Alumno From Alumnos Where Nombre like
'Juan')
Insert Notas Values(@id, 12)
Insert Notas Values(@id, 13)
Insert Notas Values(@id, 11)

Select @id= (Select id_Alumno From Alumnos Where Nombre like

'Ana')
Insert Notas Values(@id, 11)
Insert Notas Values(@id, 15)
Insert Notas Values(@id, 12)

Select @id= (Select id_Alumno From Alumnos Where Nombre like

'Luis')
Insert Notas Values(@id, 6)
Insert Notas Values(@id, 12)

Select @id= (Select id_Alumno From Alumnos Where Nombre like

'Jorge')
Insert Notas Values(@id, 11)
Insert Notas Values(@id, 10)

Select @id= (Select id_Alumno From Alumnos Where Nombre like

'Carmen')
Insert Notas Values(5, 11)

-- Verificar
Select * From Alumnos
Select * From Notas

-- Select con 2 tablas (las 3 primeras y las impares son mias)

SELECT top (3)a.id_Alumno , a.Nombre ,n.Nota
FROM Alumnos a inner join Notas n on a.id_Alumno=n.id_Alumno
where n.Nota%2 <> 0
order by n.Nota desc

-- [01] Mostrar Nombre de alumnos con sus respectivas Notas

Select Nombre, Nota

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
-- Otro modo

Select A.Nombre, B.Nota

From Alumnos As A, Notas As B
Where A.id_Alumno=B.id_Alumno

-- Otro modo

Select Nombre, Nota

From Alumnos, Notas
Where Alumnos.id_Alumno=Notas.id_Alumno

-- [02] Mostrar Nombre de alumnos con sus respectivas notas en

Orden alfabético

Select Nombre, Nota

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Order By Nombre

-- [03] Mostrar Nombre de alumno y cuántas notas tiene cada uno

Select Nombre, Count(Nota) As [Cantidad de Notas]

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Group By Nombre
Order By Nombre

-- [04] Mostrar Nombre de alumno y su respectivo promedio en

orden de mérito

select avg(n.Nota) Promedio,a.Nombre from Alumnos a inner join

Notas n on a.id_Alumno= n.id_Alumno
group by a.Nombre
order by Promedio desc

-- [05] Nombre de alumnos aprobados y su respectivo promedio en

orden alfabético

Select Nombre, Avg(Nota) As Promedio

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Group By Nombre
Having Avg(Nota)>10
Order By Nombre

-- Otro modo

Select A.Nombre, Avg(B.Nota) As Promedio

From Alumnos As A,Notas As B
Where A.id_Alumno=B.id_Alumno
Group By A.Nombre
Having Avg(B.Nota)>10
Order By A.Nombre

-- [06] Seleccione Nombre de alumnos con más de 2 notas

-- y con su respectivo promedio en orden de mérito

select a.Nombre,avg(n.Nota) Promedio, COUNT(n.Nota) [numero de

notas ]
from Alumnos a inner join Notas n on a.id_Alumno=n.id_Alumno
group by a.Nombre
having COUNT(n.Nota)>2
order by Promedio

-- [07] Seleccione alumnos que tienen como

-- nota un 11 o un 12

Select Nombre, Nota

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Where Notas.Nota=11 Or Notas.Nota=12
Order By Nombre

-- Otro modo

Select A.Nombre, B.Nota

From Alumnos As A, Notas As B
Where (A.id_Alumno=B.id_Alumno)
And (B.Nota=11 Or B.Nota=12)
Order By A.Nombre

-- [08] Seleccione alumnos que tienen las

-- notas 11 y 12

Select Nombre ,n.Nota from Alumnos a inner join Notas n on

a.id_Alumno=n.id_Alumno
where n.Nota in(11,12)

-- [09] Nombre de alumnos que tienen notas

-- desaprobadas y cuántas notas desaprobadas tiene

Select Nombre, Count(Nota) As [Núm. Notas Desaprobadas]

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Where Notas.Nota<11
Group By Nombre
Order By Nombre

-- Otro modo

Select A.Nombre, Count(B.Nota) As [Núm. Notas Desaprobadas]

From Alumnos As A, Notas As B
Where (A.id_Alumno=B.id_Alumno) And (B.Nota<11)
Group By A.Nombre
Order By A.Nombre

-- [10] ¿Quién fue el mejor alumno?

select * from Alumnos

Select * from Notas

select top 1 a.Nombre , avg(n.Nota) promedios from Alumnos a

, Notas n where a.id_Alumno=n.id_Alumno
group by a.Nombre
order by 2 desc

-- [11] ¿Quién fue el peor alumno?

Select top 1 Nombre, Avg(Nota) As Promedio

From Alumnos INNER JOIN Notas
On Alumnos.id_Alumno=Notas.id_Alumno
Group By Nombre
Order By 2

-- [12] Alumnos del tercio estudiantil

-- Eliminar tablas Notas y Alumnos (No puede ser primero

Alumnos por la Integridad Referencial)
Drop Table Notas
Drop Table Alumnos

Script CONSULTAS 3
------- Select con tres tablas relacionadas
use Datos
Create Table Personas(
id_Persona int Identity(1,1),
Nombre varchar(30)
)

Create Table Cursos(

id_Curso int Identity(1,1),
Descripcion varchar(30)
)

Create Table PersonaCurso(

id_Persona int Not NULL,
id_Curso int Not NULL
)

----------------------------------------Relacionando
GO

Alter Table Personas

Add
Constraint PK_Persona Primary Key(id_Persona)

Alter Table Cursos

Add
Constraint PK_Curso Primary Key(id_Curso)

Alter Table PersonaCurso

Add
Constraint FK_ConPersona Foreign Key(id_Persona) References
Personas(id_Persona),
Constraint FK_ConCurso Foreign Key(id_Curso) References
Cursos(id_Curso)

GO

-- Insertando registros en la tabla Personas

Insert Personas Values('Adriana Vallejo')
Insert Personas Values('Ana Gómez')
Insert Personas Values('Daniel Pérez')

-- Insertando registros en la tabla Cursos

Insert Cursos Values('WIN FORMS')
Insert Cursos Values('ADO .NET')
Insert Cursos Values('SQL Server')
GO

-- Insertando registros en la tabla PersonaCurso

Declare @idP int
Declare @idC int
Select @idP= (Select id_Persona From Personas Where Nombre
like 'Adriana Vallejo')
Select @idC= (Select id_Curso From Cursos Where
Descripcion like 'WIN FORMS')
Insert PersonaCurso Values(@idP, @idC)

Select @idP= (Select id_Persona From Personas Where Nombre

like 'Adriana Vallejo')
Select @idC= (Select id_Curso From Cursos Where
Descripcion like 'ADO .NET')
Insert PersonaCurso Values(@idP, @idC)

Select @idP= (Select id_Persona From Personas Where Nombre

like 'Ana Gómez')
Select @idC= (Select id_Curso From Cursos Where
Descripcion like 'WIN FORMS')
Insert PersonaCurso Values(@idP, @idC)

GO

-- Verificar
Select * From Personas
Select * From Cursos
Select * From PersonaCurso

--[01] Mostrar Nombres de alumnos que llevan Cursos

Select Nombre
From Personas
Where id_persona
IN (Select id_Persona from PersonaCurso)

--[02] Mostrar Nombres de alumnos que no llevan Cursos

Select Nombre
From Personas
Where id_persona
NOT IN (Select id_Persona from PersonaCurso)

--[03] Mostrar Nombres de alumnos y la descripción del curso

que lleva

Select Nombre, Descripcion --INNER JOIN o JOIN es lo

mismo
From Personas JOIN
(Cursos JOIN PersonaCurso On
Cursos.id_Curso=PersonaCurso.id_Curso)
On Personas.id_Persona=PersonaCurso.id_Persona --
Junto 3 tablas en una

--[04] Mostrar Nombres de alumnos y la descripción del curso

que lleva
-- ordenado alfabéticamente
 SELECT TOP (100) PERCENT dbo.Personas.Nombre,
dbo.Cursos.Descripcion
FROM dbo.Cursos INNER JOIN
dbo.PersonaCurso ON
dbo.Cursos.id_Curso = dbo.PersonaCurso.id_Curso INNER JOIN
dbo.Personas ON
dbo.PersonaCurso.id_Persona = dbo.Personas.id_Persona
ORDER BY dbo.Personas.Nombre

--[05] Mostrar el Nombre de alumno y la cantidad de cursos

-- que lleva, ordenado alfabéticamente.

Select Nombre, Count(id_Curso) as [Cantidad de Cursos]

From Personas JOIN PersonaCurso
On Personas.id_Persona=PersonaCurso.id_Persona
Group By Nombre
order by Nombre

--
select p.Nombre ,Cant_cursos =(select count(pc.id_Curso)from
PersonaCurso pc where pc.id_Persona=p.id_Persona)
from Personas p
order by P.Nombre

--Otro modo (LEFT JOIN obliga que salga los de la tabla

izquierda)

Select Nombre, Count(id_Curso) as [Cantidad de Cursos]

From Personas LEFT JOIN PersonaCurso
On Personas.id_Persona=PersonaCurso.id_Persona
Group By Nombre

--[06] Mostrar la cantidad de personas por curso

SELECT dbo.Cursos.Descripcion,
COUNT(dbo.PersonaCurso.id_Persona) AS [cantidad persona]
FROM dbo.Cursos LEFT OUTER JOIN
dbo.PersonaCurso ON
dbo.Cursos.id_Curso = dbo.PersonaCurso.id_Curso
GROUP BY dbo.Cursos.Descripcion

select c.Descripcion ,[Cantide Persona]=(select

count(pc.id_Persona) from PersonaCurso pc where
pc.id_Curso=c.id_Curso)
from Cursos c

--[07] Mostrar los cursos que lleva Adriana Vallejo

Select Descripcion
From Personas Join
(Cursos Join PersonaCurso
On Cursos.id_Curso = PersonaCurso.id_Curso)
On Personas.id_Persona=PersonaCurso.id_Persona
Where Nombre='Adriana Vallejo'

--[08] Mostrar los alumnos ordenados alfabéticamente

-- que estén matriculados en WIN FORMS

Select p.Nombre from Personas p inner join PersonaCurso pc on

p.id_Persona= pc.id_Persona
inner join Cursos c on pc.id_Curso=c.id_Curso where
c.Descripcion='WIN FORMS'

ORDER BY P.Nombre

--[09] Mostrar la cantidad de personas que llevan

-- cursos (Considerar que si un alumno está en varios
-- cursos, sólo se debe considerar como uno solo)

Select Count(*) as [Personas estudiando]

From Personas
where id_Persona in (Select distinct id_Persona From
PersonaCurso)

SELECT count(distinct id_Persona) as 'Persona estudiando' from

PersonaCurso

--[10] Mostrar la cantidad de cursos con alumnos

select count (distinct id_Curso) as 'Curso con matriculados'

from PersonaCurso

Drop table PersonaCurso

Drop table Personas
Drop table Cursos