INGENIERÍA EN SISTEMAS COMPUTACIONALES

INSTITUTO TECNOLÓGICO DE NUEVO LAREDO

“Con la Ciencia por la Humanidad”

TALLER DE BASES DE DATOS.

PORTAFOLIO DE EVIDENCIAS: REPORTE 2

Docente: Ludwing Daniel Oliva Perea

Integrantes del equipo:

- 18100742 Juan Julio Barrón Jiménez
- 18100191 Luis Francisco Hernández Yépez
- 18100496 José Guadalupe Santos Sánchez

Nuevo Laredo, Tamaulipas Fecha de entrega: 01/04/2023

 Índice

INTRODUCCION..................................................................................................... 5
OBJETIVOS .............................................................................................................. 6
Practica y desarrollo ............................................................................................. 7
MYSQL .................................................................................................................... 7
Proyección simple. ............................................................................................ 7
Comodín (todos los campos): ...................................................................... 7
Campos específicos: ..................................................................................... 7
Renombrar columnas proyectadas: ............................................................ 7
Proyectar valores distintos: ............................................................................ 8
Proyectar los primeros registros: .................................................................... 8
Conversión de tipos de datos en la proyección: .............................................. 8
CAST & CONVERT............................................................................................... 8
Ordenamiento del conjunto de resultados: ...................................................... 9
ASCENDENTE Y DESCENDENTE .......................................................................... 9
Funciones de cadena: ......................................................................................... 9
Funciones de fecha y hora: ................................................................................. 9
Funciones numéricas: ......................................................................................... 10
Decisión del valor proyectado: ......................................................................... 10
CASE simple: ..................................................................................................... 10
CASE compuesto: ............................................................................................ 11
Funciones de agregación ................................................................................. 11
COUNT .............................................................................................................. 11
SUM.................................................................................................................... 11
AVG ................................................................................................................... 12
MAX ................................................................................................................... 12
MIN .................................................................................................................... 12
Unión de consultas.............................................................................................. 13

2
 Criterio de búsqueda .......................................... 14
Operadores relacionales especiales ................. 14
HAVING ................................................................................................................ 15
SUBCONSULTAS .................................................................................................... 16
Reunión de tablas ............................................................................................... 17
JOIN Y LEFT JOIN .................................................................................................. 18
VISTAS ................................................................................................................... 19
SQL SERVER .......................................................................................................... 20
Proyección simple. .............................................................................................. 20
Comodín (todos los campos). ........................................................................ 20
Campos específicos. ....................................................................................... 20
Renombrar columnas proyectadas. ............................................................. 21
Proyectar valores distintos .............................................................................. 21
Proyectar los primeros registros. ..................................................................... 22
Conversión de tipos de datos en la proyección. ............................................ 23
CAST. ................................................................................................................. 23
CONVERT. ......................................................................................................... 23
Ordenamiento del conjunto de resultados. .................................................... 24
Ascendente...................................................................................................... 24
Descendente. .................................................................................................. 24
Funciones de cadena. ....................................................................................... 24
Funciones de fecha y hora. ............................................................................... 27
Funciones numéricas. ......................................................................................... 28
Decisión del valor proyectado. ......................................................................... 29
CASE simple. ..................................................................................................... 29
CASE compuesto. ............................................................................................ 30
Funciones de agregación.................................................................................. 31
COUNT. ............................................................................................................. 31
SUM.................................................................................................................... 31
AVG. .................................................................................................................. 32
MAX. .................................................................................................................. 32
MIN. ................................................................................................................... 33
3
 Agrupación de subconjuntos. ............................ 33
Unión de consultas. ............................................. 34
Criterio de búsqueda (WHERE). ......................................................................... 34
Operadores relacionales especiales. ............................................................ 34
HAVING. ............................................................................................................... 35
Reunión de tablas ........................................................................................ 36
JOIN. .................................................................................................................. 36
LEFT JOIN. .......................................................................................................... 37
Vistas..................................................................................................................... 37
De acuerdo con el informe de la propuesta del proyecto final ................... 39
Tabla antes de la inserción ............................................................................. 39
Actualización de registro a una tabla........................................................... 40
Eliminación de registro de una tabla. ........................................................... 40
Creación de un usuario para la base de datos. .......................................... 41
Creación de 2 roles para la base de datos. ................................................ 42
CONCLUSIONES................................................................................................... 43

4
 -

INTRODUCCION

El lenguaje de manipulación de datos (DML, por sus siglas en

inglés) en SQL Server y MySQL es un conjunto de comandos que
permite a los usuarios interactuar con los datos almacenados en
las bases de datos. Estos comandos se utilizan para realizar
operaciones CRUD (Create, Read, Update, Delete) en las tablas
de la base de datos. El lenguaje de manipulación de datos es
esencial para cualquier aplicación o sistema que dependa de
la gestión de datos, ya que permite al usuario interactuar con
los datos almacenados en la base de datos y realizar
operaciones como la inserción, modificación y eliminación de
datos.

5
 OBJETIVOS

El objetivo del lenguaje de manipulación de datos en SQL Server

y MySQL es permitir a los usuarios realizar operaciones CRUD
(Create, Read, Update, Delete) en las bases de datos. Esto
significa que el lenguaje de manipulación de datos permite a
los usuarios crear nuevas tablas y bases de datos, insertar datos
en las tablas, recuperar datos de las tablas, actualizar datos
existentes y eliminar datos de las tablas. En otras palabras, el
lenguaje de manipulación de datos permite al usuario
interactuar con los datos almacenados en las bases de datos, lo
que puede ser esencial para cualquier aplicación o sistema que
dependa de la gestión de datos.

6
 Practica y desarrollo

MYSQL
Proyección simple.

Esta consulta selecciona todos los campos de la tabla especificada y los

muestra en la salida.
Comodín (todos los campos):

En esta consulta, se seleccionan todas las columnas especificadas en la

cláusula SELECT de la tabla especificada y se muestran en la salida.

Campos específicos:

En esta consulta, se seleccionan solo las columnas especificadas en la

cláusula SELECT de la tabla especificada y se muestran en la salida.

Renombrar columnas proyectadas:

En esta consulta, se seleccionan las columnas especificadas en la cláusula

SELECT de la tabla especificada y se renombran utilizando la sintaxis "AS
nuevo_nombre".

7
Proyectar valores distintos:

En esta consulta, se seleccionan todos los valores distintos de la columna

especificada en la cláusula SELECT de la tabla especificada y se muestran
en la salida.
Proyectar los primeros registros:

En esta consulta, se seleccionan los primeros 10 registros de la tabla

especificada y se muestran en la salida.

Conversión de tipos de datos en la proyección:

CAST & CONVERT

Estas consultas convierten la columna especificada en la cláusula SELECT

de la tabla especificada en el tipo de datos especificado en la consulta
utilizando la sintaxis "CAST(columna AS tipo_dato)" o "CONVERT(columna,
tipo_dato)".

8
Ordenamiento del conjunto de resultados:
ASCENDENTE Y DESCENDENTE

Estas consultas ordenan el conjunto de resultados de la consulta según la

columna especificada en la cláusula ORDER BY de la tabla especificada
en orden ascendente o descendente utilizando la sintaxis "ASC" o "DESC".

Funciones de cadena:

Estas consultas utilizan funciones de cadena para concatenar valores,

convertir valores a mayúsculas o minúsculas, respectivamente.

Funciones de fecha y hora:

Estas consultas utilizan funciones de fecha y hora para obtener la fecha y hora
actuales o extraer componentes específicos de una columna de fecha en la
tabla especificada.

9
Funciones numéricas:

Estas consultas utilizan funciones numéricas para calcular el promedio, el

valor máximo o el valor mínimo de la columna especificada en la tabla.

Decisión del valor proyectado:

En esta consulta, se utiliza la sintaxis "CASE WHEN" para tomar una decisión
en función del valor de la columna especificada en la tabla. Si el valor es
mayor que 10, se muestra 'Mayor que 10' en la columna de decisión; de lo
contrario, se muestra 'Menor o igual que 10'.

CASE simple:

En esta consulta, se utiliza la sintaxis "CASE" para hacer una comparación

simple de la columna especificada en la tabla. Si el valor de la columna es

10
 1, se muestra 'Uno' en la columna de decisión; si
el valor es 2, se muestra 'Dos'; de lo contrario, se muestra 'Otro'.

CASE compuesto:

En esta consulta, se utiliza la sintaxis "CASE WHEN" para tomar una decisión
compuesta en función de los valores de dos columnas especificadas en la
tabla. Hay cuatro condiciones diferentes y la columna de decisión
mostrará 'A', 'B', 'C' o 'D' en función de las condiciones que se cumplan.

Funciones de agregación
COUNT
SELECT COUNT(*) AS TotalClientes
FROM customers;
Contar el número de clientes en la tabla "customers".

SUM
SELECT SUM(UnitPrice*Quantity*(1-Discount)) AS TotalVentas
FROM order_details;
Sumar el valor total de ventas para todos los pedidos.

11
AVG
SELECT AVG(Quantity) AS CantidadPromedio
FROM order_details;
Calcular la cantidad promedio de productos vendidos por pedido.

MAX
SELECT MAX(UnitPrice) AS PrecioMaximo
FROM products;
Encontrar el precio máximo de un producto en la tabla "products".

MIN
SELECT MIN(UnitPrice) AS PrecioMinimo
FROM products;
Encontrar el precio mínimo de un producto en la tabla "products" .

Agrupación de subconjuntos
En el siguiente ejemplo queremos encontrar la cantidad total de productos
vendidos por categoría de producto. Para ello, podemos utilizar la tabla
"order_details" para obtener la cantidad de productos vendidos en cada
pedido, y la tabla "products" para obtener la categoría de cada producto.
Luego, podemos utilizar la cláusula GROUP BY para agrupar los resultados
por categoría de producto:
SELECT categories.CategoryName, SUM(order_details.Quantity) AS
CantidadTotal
FROM order_details
INNER JOIN products ON order_details.ProductID = products.ProductID
INNER JOIN categories ON products.CategoryID = categories.CategoryID

12
GROUP BY categories.CategoryName;
estamos utilizando INNER JOIN para unir las tablas "order_details", "products"
y "categories" en función de sus respectivas claves primarias y extrayendo
la columna "CategoryName" de la tabla "categories" y la columna
"Quantity" de la tabla "order_details". Luego, estamos utilizando la función
de agregación SUM para sumar la cantidad de productos vendidos en
cada pedido y agrupando los resultados por categoría de producto
mediante la cláusula GROUP BY.
Este comando nos devolverá una lista de todas las categorías de
productos en la tabla "products" junto con la cantidad total de productos
vendidos en cada una de ellas.

Unión de consultas
En el siguiente ejemplo queremos obtener una lista de todos los empleados
y clientes de la empresa, ordenados por orden alfabético. Para ello,
podemos utilizar dos consultas diferentes: una para obtener todos los
empleados y otra para obtener todos los clientes. Luego, podemos unir
estas dos consultas mediante la cláusula UNION:
SELECT CONCAT(FirstName, ' ', LastName) AS Nombre, 'Empleado' AS Tipo
FROM employees
UNION
SELECT CompanyName AS Nombre, 'Cliente' AS Tipo
FROM customers
ORDER BY Nombre;
En este ejemplo estamos utilizando la función CONCAT para unir las
columnas "FirstName" y "LastName" de la tabla "employees" en una sola
columna "Nombre". Luego, estamos utilizando la cláusula UNION para unir
esta consulta con otra que extrae la columna "CompanyName" de la tabla
"customers" y agrega la columna "Tipo" para identificar si se trata de un
empleado o un cliente. Finalmente, estamos ordenando los resultados por
orden alfabético de la columna "Nombre".

13
 Este comando nos devolverá una lista de todos
los empleados y clientes de la empresa ordenados por orden alfabético de
su nombre, con la columna "Tipo" indicando si se trata de un empleado o
un cliente.

Criterio de búsqueda
En este ejemplo queremos obtener una lista de todos los productos que
tengan un precio unitario superior a 20 dólares. Para ello, podemos utilizar
la tabla "products" y establecer el criterio de búsqueda mediante la
cláusula WHERE:
SELECT ProductName, UnitPrice
FROM products
WHERE UnitPrice > 20;
En este ejemplo, estamos utilizando la tabla "products" para extraer las
columnas "ProductName" y "UnitPrice". Luego, estamos estableciendo el
criterio de búsqueda mediante la cláusula WHERE para seleccionar sólo
aquellos registros donde el valor de la columna "UnitPrice" sea superior a 20
dólares.
Este comando nos devolverá una lista de todos los productos de la tabla
"products" que tengan un precio unitario superior a 20 dólares, junto con su
nombre y precio unitario.

Operadores relacionales especiales

Operador IN:
En este ejemplo supongamos que queremos obtener una lista de todos los
productos cuyos identificadores de categoría sean 1, 2 o 3. En este caso,
podemos utilizar el operador IN en la cláusula WHERE:
SELECT ProductName, CategoryID
FROM products
WHERE CategoryID IN (1, 2, 3);
Este comando nos devolverá una lista de todos los productos de la tabla
"products" cuyos identificadores de categoría sean 1, 2 o 3, junto con su
nombre y su identificador de categoría.

14
 Operador BETWEEN:
Supongamos que queremos obtener una lista de todos los productos cuyo
precio unitario esté entre 15 y 20 dólares. En este caso, podemos utilizar el
operador BETWEEN en la cláusula WHERE:
SELECT ProductName, UnitPrice
FROM products
WHERE UnitPrice BETWEEN 15 AND 20;
Este comando nos devolverá una lista de todos los productos de la tabla
"products" cuyo precio unitario esté entre 15 y 20 dólares, junto con su
nombre y precio unitario.
Operador LIKE:
Supongamos que queremos obtener una lista de todos los productos cuyo
nombre contenga la palabra "chocolate". En este caso, podemos utilizar el
operador LIKE en la cláusula WHERE:
SELECT ProductName
FROM products
WHERE ProductName LIKE '%chocolate%';
Este comando nos devolverá una lista de todos los productos de la tabla
"products" cuyo nombre contenga la palabra "chocolate", junto con su
nombre. El símbolo "%" es un comodín que representa cualquier cantidad
de caracteres, por lo que la búsqueda será exitosa aunque la palabra
"chocolate" no esté en el inicio o final del nombre.

HAVING
Supongamos que queremos obtener una lista de las categorías de
productos cuyo precio unitario promedio sea superior a 30 dólares. Para
ello, podemos utilizar las tablas "products" y "categories" y establecer el
criterio de búsqueda mediante la cláusula HAVING:
SELECT CategoryName, AVG(UnitPrice) as AveragePrice
FROM products

15
 INNER JOIN categories ON products.CategoryID
= categories.CategoryID
GROUP BY CategoryName
HAVING AVG(UnitPrice) > 30;
En este ejemplo, estamos utilizando las tablas "products" y "categories" para
extraer las columnas "CategoryName" y "UnitPrice". Estamos haciendo una
unión entre ambas tablas utilizando el identificador de categoría. Luego,
estamos agrupando los resultados por "CategoryName" y calculando el
precio unitario promedio para cada categoría mediante la función AVG().
Finalmente, estamos estableciendo el criterio de búsqueda mediante la
cláusula HAVING para seleccionar sólo aquellas categorías donde el
precio unitario promedio sea superior a 30 dólares.

Este comando nos devolverá una lista de las categorías de productos de la

tabla "categories" que cumplen con el criterio establecido, junto con su
nombre y su precio unitario promedio.

SUBCONSULTAS
Supongamos que queremos obtener una lista de todos los pedidos que
contengan productos de la categoría "Bebidas alcohólicas". Para ello,
podemos utilizar una subconsulta dentro de la cláusula WHERE:
SELECT OrderID, CustomerID, OrderDate
FROM orders
WHERE OrderID IN (SELECT OrderID
FROM order_details
INNER JOIN products ON order_details.ProductID =
products.ProductID
WHERE products.CategoryID = 1);
En este ejemplo, estamos utilizando las tablas "orders", "order_details" y
"products" para extraer las columnas "OrderID", "CustomerID" y "OrderDate".
Estamos haciendo una unión entre las tablas "order_details" y "products"
para obtener los identificadores de los productos que pertenecen a la

16
 categoría "Bebidas alcohólicas". Luego,
estamos utilizando una subconsulta dentro de la
cláusula WHERE para seleccionar sólo aquellos pedidos que contengan
productos de esa categoría.
Este comando nos devolverá una lista de todos los pedidos de la tabla
"orders" que contienen productos de la categoría "Bebidas alcohólicas",
junto con su identificador, el identificador del cliente y la fecha del pedido.

Reunión de tablas
Supongamos que queremos obtener una lista de todos los productos junto
con su categoría y proveedor. Para ello, podemos utilizar una operación
de unión entre las tablas "products", "categories" y "suppliers":
SELECT products.ProductName, categories.CategoryName,
suppliers.CompanyName
FROM products
INNER JOIN categories ON products.CategoryID = categories.CategoryID
INNER JOIN suppliers ON products.SupplierID = suppliers.SupplierID;
En este ejemplo, estamos utilizando las tablas "products", "categories" y
"suppliers" para extraer las columnas "ProductName", "CategoryName" y
"CompanyName". Estamos haciendo una unión entre las tablas "products",
"categories" y "suppliers" utilizando los identificadores de categoría y
proveedor para relacionar las tablas.
Este comando nos devolverá una lista de todos los productos de la tabla
"products" junto con su categoría y proveedor correspondiente.

17
JOIN Y LEFT JOIN
INNER JOIN se utiliza para combinar dos o más tablas en una consulta,
devolviendo sólo aquellas filas que coinciden en ambas tablas. Por otro
lado, LEFT JOIN se utiliza para combinar dos o más tablas en una consulta,
devolviendo todas las filas de la tabla de la izquierda y sólo aquellas filas
de la tabla de la derecha que coinciden.
Supongamos que queremos obtener una lista de todos los clientes junto
con el nombre de su ciudad correspondiente. Para ello, podemos utilizar
INNER JOIN entre las tablas "customers" y "cities":
SELECT customers.CustomerID, customers.CompanyName, cities.City
FROM customers
INNER JOIN cities ON customers.City = cities.CityID;
En este ejemplo, estamos utilizando las tablas "customers" y "cities" para
extraer las columnas "CustomerID", "CompanyName" y "City". Estamos
haciendo una unión entre las tablas "customers" y "cities" utilizando los
identificadores de ciudad para relacionar las tablas.
Este comando nos devolverá una lista de todos los clientes de la tabla
"customers" junto con el nombre de su ciudad correspondiente.
Ahora, supongamos que queremos obtener una lista de todos los
productos junto con su proveedor correspondiente, incluyendo aquellos
productos que no tienen proveedor. Para ello, podemos utilizar LEFT JOIN
entre las tablas "products" y "suppliers":
SELECT products.ProductID, products.ProductName,
suppliers.CompanyName
FROM products
LEFT JOIN suppliers ON products.SupplierID = suppliers.SupplierID;
En este ejemplo, estamos utilizando las tablas "products" y "suppliers" para
extraer las columnas "ProductID", "ProductName" y "CompanyName".
Estamos haciendo una unión entre las tablas "products" y "suppliers"
utilizando el identificador de proveedor para relacionar las tablas.

18
 Este comando nos devolverá una lista de todos
los productos de la tabla "products" junto con su proveedor
correspondiente, incluyendo aquellos productos que no tienen proveedor
(en este caso, el valor de "CompanyName" será NULL para esos
productos).

VISTAS
es una tabla virtual que se basa en los resultados de una consulta. La
ventaja de utilizar vistas es que nos permiten simplificar y abstraer la
complejidad de las consultas y, al mismo tiempo, nos permiten reutilizar las
consultas en diferentes partes de nuestro código.
Supongamos que queremos crear una vista que nos permita obtener una
lista de todos los productos de la tabla "products" junto con el nombre de
su proveedor correspondiente. Para ello, podemos utilizar la siguiente
consulta:
CREATE VIEW product_supplier AS
SELECT products.ProductID, products.ProductName,
suppliers.CompanyName
FROM products
LEFT JOIN suppliers ON products.SupplierID = suppliers.SupplierID;
En este ejemplo, estamos creando una vista llamada "product_supplier"
que se basa en la consulta que ya vimos anteriormente (que utiliza LEFT
JOIN entre las tablas "products" y "suppliers").
Una vez que hemos creado la vista, podemos utilizarla como si fuera una
tabla normal en cualquier consulta. Por ejemplo, podemos utilizar la
siguiente consulta para obtener una lista de todos los productos junto con
el nombre de su proveedor correspondiente:
SELECT * FROM product_supplier;
Este comando nos devolverá una lista de todos los productos de la tabla
"products" junto con su proveedor correspondiente, tal como lo hicimos
anteriormente utilizando LEFT JOIN.

19
 SQL SERVER

Proyección simple.
Comodín (todos los campos).
El comodín de todos los campos se trata de un * hace qe se muestren
todos los campos de la tabla

Mostrara algo así

Campos específicos.
Se seleccionan los campos que se quieren mostrar

Arrojara algo así

20
Renombrar columnas proyectadas.
Se selecciona el nombre de la columna seguido de la sentencia as y el
nuevo nombre del campo

Arrojara el nuevo nombre de la columna

Proyectar valores distintos

Para esto se ocupa la sentencia distinct

21
Muestra algo así

Proyectar los primeros registros.

Para esta función se puede usar de dos formas en cantidad o porcentaje

Mostrará algo así

22
Conversión de tipos de datos en la proyección.
CAST.
CONVERT.

Resultado

23
Ordenamiento del conjunto de resultados.
Ascendente.
Descendente.

Resultado

Funciones de cadena.

24
Resultado

25
26
 Funciones de fecha y hora.

Resultado

27
Funciones numéricas.

28
Decisión del valor proyectado.
CASE simple.

29
CASE compuesto.

30
Funciones de agregación.
COUNT.

SUM.

31
AVG.

MAX.

32
MIN.

Agrupación de subconjuntos.

33
Unión de consultas.

Criterio de búsqueda (WHERE).

Operadores relacionales especiales.

34
HAVING.

• Subconsultas.

35
 • Reunión de tablas.
JOIN.

36
LEFT JOIN.

Vistas.

37
38
De acuerdo con el informe de la propuesta del proyecto final, realizar
los siguientes puntos.
Inserción de registro a una tabla.

Tabla antes de la inserción

Ya insertado el dato

39
Actualización de registro a una tabla.

Eliminación de registro de una tabla.

40
Creación de un usuario para la base de datos.
Abra SQL Server Management Studio y conecte al servidor en el que desea
crear el usuario.
Expanda el servidor y haga clic en la carpeta "Seguridad".
Haga clic derecho en la carpeta "Usuarios" y seleccione "Nuevo usuario".
En la ventana emergente, ingrese el nombre del usuario y seleccione el
tipo de autenticación que desea usar. Puede elegir entre autenticación de
Windows o autenticación de SQL Server.
Si selecciona autenticación de SQL Server, ingrese la contraseña para el
usuario y confírmela en la sección de "Contraseña". Si selecciona la
autenticación de Windows, seleccione la cuenta de Windows que desea
utilizar para autenticar el usuario.
Asigne los permisos necesarios al usuario en la sección "Permisos de
usuario". Puede elegir los permisos predefinidos o asignar permisos
específicos de acuerdo con sus necesidades.
Haga clic en "Aceptar" para crear el usuario. El usuario ahora se mostrará
en la carpeta "Usuarios" de la sección "Seguridad".

41
Creación de 2 roles para la base de datos.
Abra SQL Server Management Studio y conecte al servidor en el que desea
crear los roles.
Expanda el servidor y haga clic en la carpeta "Seguridad".
Haga clic derecho en la carpeta "Roles" y seleccione "Nuevo rol".
En la ventana emergente, ingrese el nombre del primer rol y una
descripción opcional.
En la sección "Membresía de roles", agregue los usuarios o roles que desea
asignar al nuevo rol.
En la sección "Permisos de roles", seleccione los permisos que desea otorgar
al rol. Puede elegir permisos predefinidos o asignar permisos específicos de
acuerdo con sus necesidades.
Haga clic en "Aceptar" para crear el primer rol. El rol ahora se mostrará en
la carpeta "Roles" de la sección "Seguridad".
Repita los pasos 3-7 para crear el segundo rol.

42
 CONCLUSIONES

Conclusión de: Luis Francisco Hernández Yépez – 18100191

En conclusión, el uso de funciones de agregación, agrupación de
subconjuntos, unión de consultas, criterios de búsqueda, operadores
relacionales especiales, HAVING, subconsultas, reunión de tablas, JOIN y
LEFT JOIN, y vistas en MySQL Workbench utilizando la base de datos
Northwind es esencial para la gestión eficiente de grandes conjuntos de
datos de una empresa. Estas herramientas permiten filtrar, ordenar y resumir
información para obtener información útil y relevante para la toma de
decisiones empresariales. Además, la implementación de estas técnicas
permite una mayor eficiencia en la gestión de inventarios y el análisis de la
información para mejorar la planificación y la toma de decisiones. En
resumen, el uso de estas herramientas de base de datos ayuda a la
empresa a tomar decisiones más informadas y a ser más efectiva en la
gestión de sus recursos.

Conclusión de: Juan Julio Barrón Jimenez – 18100742

En conclusión, de esta investigación, le permite al usuario obtener
información específica de una base de datos de manera efectiva y
eficiente. Las funciones de agregación son útiles para realizar cálculos
estadísticos en un conjunto de datos, mientras que la agrupación de
subconjuntos permite al usuario agrupar datos según ciertos criterios. La
unión de consultas es útil para combinar resultados de múltiples consultas,
lo que puede simplificar el proceso de obtención de información de varias
tablas en una base de datos. Los criterios de búsqueda y los operadores
relacionales especiales permiten al usuario filtrar y seleccionar datos
específicos según ciertos criterios, lo que puede ayudar a reducir el
tamaño del conjunto de datos que se está analizando. En general, estas
herramientas son fundamentales para cualquier persona que trabaje con
bases de datos en MySQL, ya que permiten al usuario obtener información
específica de manera efectiva y eficiente.

43
Conclusión de: José Guadalupe Santos Sánchez - 18100496
En esta práctica vimos muchas instrucciones de gran ayuda en la gestión
de la base de datos ya que al crear Query’s nos facilita mucho el trabajo y
conocer lo que se puede hacer es más fácil de manipular la base de
datos. Este proyecto fue muy útil para practicar las sentencias y la
manipulación de datos y registros de diferentes tablas y aprender un poco
más de dos gestores de base de datos y de los más conocidos en el
ámbito laboral. La manipulación de los datos de nuestra propuesta fue útil
ya que era necesario corregir unas especificaciones y la creación de
usuarios y roles fue bueno para dar acceso a algunos usuarios

44