Agrego doc sobre vistas funciones y procedimientos

Vistas/vistas.md

@@ -0,0 +1,46 @@
+# Vistas
+
+Una vista es una tabla virtual generada a partir de la ejecución de varias consultas sobre una o más tablas. Una vista tiene la misma estructura de filas y columnas que cualquier otra tabla MySQL, se almacenan del mismo modo y no es posible que existan dos con el mismo nombre.
+
+*Sintaxis*
+```
+CREATE [OR REPLACE] VIEW nombre_vista [lista_columnas]
+AS consulta
+```
+
+Si observas la sintaxis verás varios apartados:
+
+- nombre_vista: Representa el nombre de la tabla virtual que tendrá la vista.
+- lista_columnas: Es el listado de columnas que creará la vista.
+- consulta: Se trata de una consulta SELECT que nos devolvuelven los datos que forman de la vista.
+
+También podemos ver el modificador opcional OR REPLACE. Cuando se crea una vista con OR REPLACE, se creará la vista si no existe una con el mismo nombre y, si existe, se reemplazará por ésta.
+
+## Ventajas de usar una vista
+
+La mayor ventaja de utilizar vistas se obtiene en forma de rendimiento, ya que no estaremos generando constantemente una vista si ésta ya existe. Cuanto más complejas sean las consultas que se deben ejecutar para obtener la vista, mayor será la ganancia de rendimiento. Por otro lado, también puede suponer una ventaja en términos de seguridad si no queremos que los usuarios puedan obtener datos de las tablas originales sobre las que se crea la vista.
+
+También podemos limitar los permisos de acceso a una vista a ciertos usuarios. Una vista, en general, puede ayudarte a construir una interfaz simplificada y abstracta a una base de datos compleja.
+
+## Implementación
+
+*Sintaxis*
+```
+CREATE VIEW vistaProductosBarato AS SELECT id, nombre, precio FROM productos WHERE precio < 10.00;
+```
+
+## Como se utiliza
+
+Cuando crees una vista, podrás ejecutar consultas sobre ella como si de una tabla más se tratase. Por ejemplo, vamos a seleccionar todos los datos de la vista vistaProductosBaratos de nuestro ejemplo:
+
+*Sintaxis*
+```
+SELECT * FROM vistaProductosBarato;
+```
+
+## Borrar una vista
+
+*Sintaxis*
+```
+DROP VIEW vistaProductosBarato;
+```

funciones/funciones.md

@@ -0,0 +1,44 @@
+# Funciones almacenadas
+
+Las funciones almacenadas de MySQL nos permiten procesar y manipular datos de forma procedural de un modo muy eficiente. Podrás usarlas en las sentencias SQL independientemente del lenguaje de programación del servidor sobre el que se ejecuten las consultas.
+
+*Sintaxis*
+```
+CREATE FUNCTION nombre_funcion(param1, param2,…)
+RETURNS datatype
+[NOT] DETERMINISTIC
+sentencias_sql
+```
+
+## Implementación
+
+Crearemos una función que permitira saber cuanta ganancia tenemos en la venta de un producto.
+
+*Sintaxis*
+```
+DROP FUNCTION IF EXISTS puntodeventa.calcularGanancia;
+
+DELIMITER $$
+$$
+CREATE FUNCTION calcularGanancia(precio float, preciocompra float)
+RETURNS float
+begin
+	DECLARE ganancia FLOAT(9,2);
+    SET ganancia = preciocompra - precio;
+    RETURN ganancia;
+END$$
+DELIMITER ;
+```
+
+### Borrar Si existe
+
+*Sintaxis*
+```
+DROP FUNCTION IF EXISTS calcularGanancia;
+```
+
+### Uso de la funcion creada
+*Sintaxis*
+```
+select nombre, precio, preciocompra, calcularGanancia(precio, preciocompra) as ganancia from productos;
+```

procedimientos/procedimientos.md

@@ -0,0 +1,75 @@
+# Procedimientos almacenados
+
+Un procedimiento almacenado MySQL no es más que una porción de código que puedes guardar y reutilizar. Es útil cuando repites la misma tarea repetidas veces, siendo un buen método para encapsular el código. Al igual que ocurre con las funciones, también puede aceptar datos como parámetros, de modo que actúa en base a éstos.
+
+### Ventajas
+
+- Al reducir la carga en las capas superiores de al aplicación, se reduce el tráfico de red y, si el uso de los procedimientos almacenados es el correcto, puede mejorar el rendimiento.
+
+- Al encapsular las operaciones en el propio código SQL, nos aseguramos de que el acceso a los datos es consistente entre todas las aplicaciones que hagan uso de ellos.
+
+- En cuanto a seguridad, es posible limitar los permisos de acceso de usuario a los procedimientos almacenados y no a las tablas directamente. Des este modo evitamos problemas derivados de una aplicación mal programada que haga un mal uso de las tablas.
+
+### Desventajas
+
+- Al igual que ocurre con toda tecnología, tenemos que formarnos para aprender a crear procedimientos, por lo que existe cierta curva de aprendizaje.
+
+- Otro posible problema puede ocurrir con las migraciones. No todos los sistemas gestores de bases de datos usan los procedimientos del mismo modo, por lo que se reduce la portabilidad del código.
+
+- Al hacer cambios en las estructuras de datos habra que hacer modificaciones al codigo de los procedimientos.
+
+*Sintaxis*
+```
+CREATE PROCEDURE nombre_procedimiento
+AS
+sentencias_sql
+GO;
+```
+
+## Parametros de entrada
+
+En los procedimientos almacenados podemos tener tres tipos de parámetros:
+
+- Entrada: Se indican poniendo la palabra reservada IN delante del nombre del parámetro. Estos parámetros no pueden cambiar su valor dentro del procedimiento, es decir, cuando el procedimiento finalice estos parámetros tendrán el mismo valor que tenían cuando se hizo la llamada al procedimiento. En programación sería equivalente al paso por valor de un parámetro.
+- Salida: Se indican poniendo la palabra reservada OUT delante del nombre del parametro. Estos parámetros cambian su valor dentro del procedimiento. Cuando se hace la llamada al procedimiento empiezan con un valor inicial y cuando finaliza la ejecución del procedimiento pueden terminar con otro valor diferente. En programación sería equivalente al paso por referencia de un parámetro.
+- Entrada/Salida: Es una combinación de los tipos IN y OUT. Estos parámetros se indican poniendo la palabra reservada IN/OUT delante del nombre del parámetro.
+
+## Implementación
+
+Crearemos un procedimiento que retornara el stock de un producto.
+
+*Sintaxis*
+```
+DROP PROCEDURE IF EXISTS puntodeventa.calcularStock;
+
+DELIMITER $$
+$$
+CREATE PROCEDURE puntodeventa.calcularStock(in id_producto int, out stock float)
+begin	
+	select sum(cantidad) into @altas
+	from puntodeventa.movimientos 
+	where producto_id = id_producto and tipo = 1;
+	select sum(cantidad) into @bajas
+	from puntodeventa.movimientos 
+	where producto_id = id_producto and tipo != 1;
+	set stock = @altas - @bajas;
+END$$
+DELIMITER ;
+
+```
+
+## LLamar a un procedimiento almacenado
+
+*Sintaxis*
+```
+set @stock=0;
+CALL calcularStock(18, @stock);
+select @stock as stock;
+```
+
+## Borrar un procedimiento ya creado
+
+*Sintaxis*
+```
+DROP PROCEDURE calcularStock;
+```