20 DE NOVIEMBRE DE 2021

CONSTRUCCIÓN DE UN DATA
WAREHOUSE
ARQUITECTURA DE DATOS

WENDY PAOLA FLÓREZ PÉREZ.

UCOMPENSAR
Facultad de ingeniería
 MANUAL DATA WAREHOUSE

Construcción del Data Warehouse

Transformar los datos en conocimiento es un proceso complejo. Este proceso de transformación e

integración de los datos puede sintetizarse a través de las etapas representativas de un método
industrial ilustrado por los siguientes pasos:

• Ensamblar las materias primas (los datos de las diferentes fuentes)

• Según instrucciones específicas (el metamodelo)
• Para realizar un proceso determinado (los datos analíticos)
• Almacenado en un almacén de datos (el Data Warehouse)
• Para su disponibilidad fácil de cara a los clientes (los usuarios finales)

Un Data Warehouse no se hace en una sola iteración. Cada asunto tratado se descompone en un
grupo de iniciativas (las aplicaciones). perímetro de cada aplicación debería estar precisamente
determinado (actores afectados, frecuencia y periodicidad de los estudios, fines y naturaleza de
las vueltas conceder resultados «tangibles» en un plazo de menos de 6 meses, que
descomposición en aplicaciones aporta varias ventajas, empero crea problemas sobre ciertos
temas, como los involucrados con la infraestructura técnica y organizativa que requieren que se
imagine una perspectiva más universal. aplicación puede además ser un programa de elección.

¿Cómo crear un Data Warehouse en SQL server?

• Previamente se debe instalar una versión de SQL EXPRESS, esta se encuentra en la

siguiente URL: https://www.microsoft.com/es-es/sql-server/sql-server-downloads

• Contar con el IDE para la administración SQL EXPRESS, este se puede instalar a través del
siguiente enlace: https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-
management-studio-ssms?view=sql-server-ver15

• Como primer paso abriremos SQL Management Studio donde nos conectaremos
Localhost y nuestra instancia SQL Express
• Luego de conectarmos, proceremos a crear el Data Warehouse, en este caso lo
llamaremos DW_Planta
• A continuación, generaremos una nueva tabla llamada: D_PRODUCTOS
Esta tabla tendrá un id de producto; de tipo nvarchar, nombre del producto; de tipo nvarchar,
y la categoría a la cual pertenece; también de tipo nvarchar. Además, pondremos id_producto
como nuestra llave primaria.

CREATE TABLE D_PRODUCTO ( id_producto nvarchar(50), nombre_producto nvarchar(50)

NULL, familia_producto nvarchar(50) NULL, CONSTRAINT PK_D_PRODUCTO PRIMARY KEY
(id_producto) );
 • Seguido a esto agregaremos la tabla D_SUCURSAL.

Esta tabla tendrá un id de sucursal; de tipo entero, un nombre de sucursal; de tipo nvarchar,
un nombre región; de tipo nvarchar, un nombre comuna; de tipo nvarchar y por último un
nombre ciudad; de tipo nvarchar. Además, pondremos id_sucursal como nuestra llave
primaria

CREATE TABLE D_SUCURSAL ( id_sucursal int, nombre_sucursal nvarchar(50) NULL,

nombre_region nvarchar(50) NULL, nombre_comuna nvarchar(50) NULL, nombre_ciudad
nvarchar(50) NULL, CONSTRAINT PK_D_SUCURSAL PRIMARY KEY (id_sucursal) );
 • Procedemos a crear una tabla de clientes D_CLIENTE

Esta tabla tendrá un id de cliente; de tipo nvarchar, un nombre de cliente; de tipo nvarchar,
una edad; de tipo entero y un estado civil; de tipo nvarchar. Además, pondremos id_cliente
como nuestra llave primaria

CREATE TABLE D_CLIENTE ( id_cliente nvarchar(50), nombre_cliente nvarchar(50) NULL, edad

int NULL, estado_civil nvarchar(50) NULL, CONSTRAINT PK_D_CLIENTE PRIMARY KEY
(id_cliente) );

• A continuación, crearemos una nueva tabla de vendedores D_VENDEDOR

Esta tabla tendrá un id de vendedor; de tipo entero, un nombre de vendedor; de tipo
nvarchar, un tipo de capacitación; de tipo nvarchar y una hora capacitación; de tipo entero.
Además, pondremos id_vendedor como nuestra llave primaria

CREATE TABLE D_VENDEDOR ( id_vendedor int, nombre_vendedor nvarchar(50) NULL,

tipo_capacitacion nvarchar(50) NULL, hora_capacitacion int NULL, CONSTRAINT
PK_D_VENDEDOR PRIMARY KEY (id_vendedor) );

• Ahora, vamos a crear la tabla de tiempo D_TIEMPO

Esta tabla tendrá un id de tiempo; de tipo nvarchar, un mes; de tipo entero y un año; de tipo
entero. Además, pondremos id_tiempo como nuestra llave primaria.
CREATE TABLE D_TIEMPO ( id_tiempo nvarchar(50), mes int NULL, anio int NULL, CONSTRAINT
PK_D_TIEMPO PRIMARY KEY (id_tiempo) );

• Luego de generar nuestras 5 tablas, vamos a crear la tabla principal; entidad de

hechos.

Para nuestro primer campo id_venta, iremos a las propiedades y seleccionamos la opción:
identify specification y en el campo Is identify lo cambiamos por sí.
Esto hace que nuestra id_venta sea una variable incremental.

• Posteriormente selecciones las otras entidades con los campos id_producto; de

tipo nvarchar, id_sucursal de tipo entero, id_cliente; de tipo nvarchar,
id_vendedor; de tipo entero, id_tiempo; de tipo nvarchar, cantidad_venta; de tipo
entero y monto_venta; de tipo entero. Además, pondremos id_venta como
nuestra llave primaria.

• Luego de esto, crearemos las relaciones entre tablas. Para este, nos dirigimos a la
tabla de hechos y creamos todas las llaves foráneas para hacer relación a otras
entidades o tablas.
Ahí se desplegará un menú donde se relacionarán las tablas.
 • Seleccionamos cada una de las llaves correspondientes a las tablas

En el siguiente botón, se van agregando una a una las llaves foráneas.

CREATE TABLE H_VENTAS ( id_venta int IDENTITY(1,1), id_producto nvarchar(50) NULL,
id_sucursal int NULL, id_cliente nvarchar(50) NULL, id_vendedor int NULL, id_tiempo
nvarchar(50) NULL, cantidad_venta int NULL, monto_venta int NULL, CONSTRAINT
PK_H_VENTAS PRIMARY KEY (id_venta), CONSTRAINT FK_H_VENTAS_D_PRODUCTO FOREIGN
KEY (id_producto) REFERENCES D_PRODUCTO(id_producto), CONSTRAINT
FK_H_VENTAS_D_SUCURSAL FOREIGN KEY (id_sucursal) REFERENCES
D_SUCURSAL(id_sucursal), CONSTRAINT FK_H_VENTAS_D_CLIENTE FOREIGN KEY (id_cliente)
REFERENCES D_CLIENTE(id_cliente), CONSTRAINT FK_H_VENTAS_D_VENDEDOR FOREIGN KEY
(id_vendedor) REFERENCES D_VENDEDOR(id_vendedor), CONSTRAINT
FK_H_VENTAS_D_TIEMPO FOREIGN KEY (id_tiempo) REFERENCES D_TIEMPO(id_tiempo) );

• Construcción del modelo estrella

• Para crear el modelo estrella de la base de datos, se debe consultar el Data

Warehouse y seleccionar la opción Database Diagrams y posterior a esto New
Database Diagram.
• Seleccionamos cada una de las tablas y pulsamos el botón ADD
• Construcción del modelo Copo de Nieve (Snowflake)

Para la construcción de este modelo, normalizaremos la tabla D_VENDEDOR y

D_SUCURSAL, esto mediante llaves fóraneas, además agregaremos la tabla
D_FAMILIAPRODUCTO esto implica hacer la modificación de algunos campos.

ALTER TABLE D_SUCURSAL DROP COLUMN nombre_region;

ALTER TABLE D_SUCURSAL DROP COLUMN nombre_comuna;
ALTER TABLE D_SUCURSAL DROP COLUMN nombre_ciudad;
 • A continuación, se creará la tabla D_FAMILIAPRODUCTO

CREATE TABLE D_FAMILIAPRODUCTO (

id_familia int,
familia_producto nvarchar(50),
CONSTRAINT PK_D_FAMILIAPRODUCTO PRIMARY KEY (id_familia),
);

• A continuación, se creará la tabla D_REGION

Esta tabla almacenará los datos de las regiones

CREATE TABLE D_REGION ( id_region int, nombre_region nvarchar(50), CONSTRAINT

PK_D_REGION PRIMARY KEY (id_region) );

• Posteriormente, se creará la tabla D_CIUDAD

Esta tabla o entidad almacenará los datos de ciudades donde se encuentran ubicadas las comunas
 • Agregamos la tabla D_COMUNA

Esta tabla o entidad almacenará los datos de las comunas donde se encuentran ubicadas las
sucursales

• Agregamos la tabla D_TIPODECAPACITACION

• Por último, agregaremos las respectivas llaves foráneas:
• Por último, generamos el modelo copo de nieve, seleccionamos todas las tablas
que conforman la base de datos.
Se muestra el diagrama de manera exitosa, de esta forma se prevé la redundancia de información
en la base de datos.

• Poblar el Data Warehouse

Para poblar las tablas, ejecutamos los siguientes querys desde las bases de datos anteriormente
restaurada PlantAndHealth:
USE PlantAndHealth;
INSERT INTO DW_Planta.dbo.D_REGION
SELECT REGION_ID, REGION FROM REGION;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_CIUDAD

SELECT PROVINCIA_ID, PROVINCIA_NOMBRE, REGION_ID FROM PROVINCIA;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_COMUNA

SELECT COMUNA_ID, COMUNA_NOMBRE, PROVINCIA_ID FROM COMUNA;
Verificamos que los datos fueron insertados con éxito.
INSERT INTO DW_Planta.dbo.D_FAMILIAPRODUCTO
SELECT DISTINCT DENSE_RANK() OVER(ORDER BY FAMILIA), FAMILIA FROM ARTICULOS;

Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_SUCURSAL
SELECT SUCURSAL_ID, NOMBRE_SUCURSAL, COMUNA_ID FROM SUCURSAL;

Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_VENTAS.dbo.D_FAMILIAPRODUCTO SELECT DISTINCT DENSE_RANK() OVER(ORDER

BY FAMILIA), FAMILIA FROM ARTICULOS
INSERT INTO DW_Planta.dbo.D_CLIENTE
SELECT ID_CLIENTE, CONCAT(TRIM(NOMBRE),' ', TRIM(APELLIDO)), EDAD, ESTADO_CIVIL
FROM CLIENTES;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_TIPODECAPACITACION

SELECT DISTINCT DENSE_RANK() OVER(ORDER BY [TIPO_ CAPACITACION]), [TIPO_
CAPACITACION] FROM VENDEDORES;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_VENDEDOR

SELECT V.ID_VENDEDOR, CONCAT(TRIM(V.NOMBRE),' ', TRIM(V.APELLIDO)),
V.HORAS_CAPACITACION, TC.id_tipodecapacitacion FROM VENDEDORES V
LEFT JOIN DW_Planta.dbo.D_TIPODECAPACITACION TC ON TC.nombre_tipocapacitacion =
V.[TIPO_ CAPACITACION]
COLLATE Modern_Spanish_CI_AS;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_PRODUCTO

SELECT A.CODIGO_PRODUCTO, A.NOMBRE, F.id_familia FROM ARTICULOS A
LEFT JOIN DW_Planta.dbo.D_FAMILIAPRODUCTO F ON F.familia_producto = A.FAMILIA
COLLATE Modern_Spanish_CI_AS;
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.D_TIEMPO

SELECT DISTINCT DENSE_RANK() OVER(ORDER BY MONTH(FECHA)), MONTH(FECHA),
YEAR(FECHA) FROM VENTAS
ORDER BY MONTH(FECHA);
Verificamos que los datos fueron insertados con éxito.

INSERT INTO DW_Planta.dbo.H_VENTA

SELECT DV.CODIGO_PRODUCTO, V.SUCURSAL_ID, V.ID_CLIENTE, V.ID_VENDEDOR,
T.id_tiempo, DV.CANTIDAD, DV.TOTAL FROM VENTAS V
LEFT JOIN DETALLE_VENTA DV ON DV.DOCUMENTO = V.DOCUMENTO
LEFT JOIN DW_Planta.dbo.D_TIEMPO T ON T.anio = YEAR(V.FECHA) AND T.mes =
MONTH(V.FECHA)
ORDER BY V.DOCUMENTO;

Verificamos que los datos fueron insertados con éxito.

• Consultas con Join
El lenguaje SQL sigue siendo la “lingua franca” para acceder a todo tipo de datos. Hasta las bases de
datos NoSQL acaban siempre ofreciendo algún tipo de interfaz SQL (o como mínimo “SQL-like”) a
sus datos semiestructurados para intentar llegar a una audiencia más amplia. De hecho hasta
herramientas que ofrecen una visión unificada sobre un conjunto de bases de datos diversos
(ej. Apache Drill) o herramientas dedicadas al streaming data van a lo seguro y ofrecen una interfaz
SQL “apta para todos los públicos”.

• Left Join

SELECT id_venta, nombre_sucursal, nombre_producto, cantidad_venta, monto_venta

FROM H_VENTA V
LEFT JOIN D_SUCURSAL S ON S.id_sucursal = V.id_sucursal
LEFT JOIN D_PRODUCTO P ON P.id_producto = V.id_producto;

Este Query nos trae como resultado un reporte de las ventas con sus respectivas sucursales,
incluyendo qué producto se está vendiendo, la cantidad de productos vendidos y el monto total de
la venta. Las tablas que se relacionan son H_Venta, D_Sucursal, D_producto
 • Right Join

SELECT VD.nombre_vendedor, TC.id_tipodecapacitacion, VD.hora_capacitacion

FROM D_TIPODECAPACITACION TC
RIGHT JOIN D_VENDEDOR VD ON VD.id_tipodecapacitacion = TC.id_tipodecapacitacion
ORDER BY VD.nombre_vendedor;

Este Query nos trae como resultado un reporte de los empleados junto a las capacitaciones que
tendrán. Las tablas que se relacionan son D_Vendedor y D_tipodecapacitacion

• Inner Join

SELECT C.id_ciudad, C.nombre_ciudad, O.nombre_comuna

FROM D_CIUDAD C
INNER JOIN D_COMUNA O ON O.id_ciudad= c.id_ciudad;

Este Query nos trae como resultado un reporte de ciudades y sus respectivas comunas. Las tablas
que se relacionan son D_ciudad y D_comuna
 • Full Join

SELECT id_venta, nombre_comuna, nombre_sucursal, nombre_producto, cantidad_venta,

monto_venta
FROM H_VENTA V
FULL JOIN D_SUCURSAL S ON S.id_sucursal = V.id_sucursal
FULL JOIN D_PRODUCTO P ON P.id_producto = V.id_producto
FULL JOIN D_COMUNA C ON C.id_comuna = S.id_comuna;

Este Query nos trae como resultado un reporte de las ventas realizadas en comunas, en sucursales,
con sus respectivos productos la cantidad vendida y por último su monto de venta. Las tablas que se
relacionan son H_Venta,D_sucursal, D_producto y D_comuna
 • Consulta vista materializada

Una VM no es más que una vista, con la diferencia de que además de almacenarse su definición se
almacenan los datos que retorna.

Esto es especialmente útil cuando la vista en cuestión se va a llamar constantemente y se necesita

una buena performance.

La contra es que salvo que se defina como actualizable al hacer commit en las tablas referenciadas
(poco común) una vez creada la VM los datos van a ser estáticos hasta su actualización, que puede
ser tanto manual como automática.

¿Por qué usar una VM si no voy a tener el contenido actualizado?

Hay muchos casos en que no hace falta tener el contenido actualizado, por ejemplo cuando se
desean ver datos consolidados al día anterior (en algunos tipos de dashboard).
Es decir, el negocio y la aplicación definirá si nos sirve utilizar una VM, en cuyo caso se va a ganar
muchísimo a nivel performance.

Como alternativa esta utilizar una VM que se actualice a nivel datos con cada commit realizado a
las tablas referenciadas, hay que tener cuidado en este caso que no genere un inconveniente en la
operación cuando se dispara el refresh.

Referencias

https://es.stackoverflow.com/questions/36/cu%C3%A1l-es-la-diferencia-entre-un-inner-y-un-
outer-join

https://mode.com/sql-tutorial/sql-outer-joins/

https://www.youtube.com/watch?v=WAOs7E0xXZk