Comandos Mysql by damian santirachi

Vista previa del material en texto

CONSULTAS
SHOW DATABASES (me muestra todas las bases de datos que hay creadas por ej: sakila, empresa, mysql, sys, world, performance_schema, information_schema, etc)
SHOW TABLES (me muestra todos los nombres de las tablas creadas dentro de una base de datos que haya seleccionado previamente mediante USE, por ej: actor, actors_info, address, etc)
SHOW COLUMNS FROM nombre_tabla 
muestra información acerca de las columnas en una tabla dada, como puede ser:
Field: nombre de la columna (actor_id).
Type: tipo de dato de la columna (smallint (5) unsigned).
Null: si es NOT NULL o no.
Key: indica si la columna esta indexada (si es clave primaria o no).
Extra: cualquier información adicional diponible (autoincrementable).
SELECT * FROM table_name; 
(Muestra todos los registros de la tabla elegida)
SELECT column_list FROM table_name;
(Muestra todos los registros y atributos de la tabla y columna/s elegida)
Ej. SELECT actor_id, first_name FROM actor;	
SELECT DISTINCT column_list FROM table_name;
(Muestra todos los registros y atributos de la tabla y columna/s elegida, si hay registros duplicados solo lo mostrara una sola ves, de eso se encarga distinct)
SELECT * FROM table_name LIMIT 3,7;	
(Muestra los primeros 7 registros de la tabla elegida empezando desde el registro numero 4, ya que MYSQL empieza a contar desde el cero) 
SELECT table_name.column FROM table_name;
(Muestra todos los registros y atributos de la tabla y columna/s elegida, usar el table_name.column es lo mismo que directamente usar el nombre de la columna)
SELECT * FROM table_name ORDER BY column_name;
(Muestra todos los registros de la tabla elegida ordenadas alfabéticamente o numéricamente por el nombre de la columna de forma ascendente (ASC) por default(, si se le agrega DESC al final se ordenara de forma descendente)
SELECT * FROM table_name ORDER BY 2 DESC;
(Otra alternativa es usar un numero para elegir cual es la columna seleccionada con la que quiero ordenar los registros, ORDER BY numero, esto hace que ordene a partir de la columna numero 2 de forma descendente)
SELECT * FROM actor ORDER BY column_1 DESC, column_2 ASC;
(Tambien es posible ordenar a través de 2 columnas, la que tendrá mas prioridad será la column_1 y luego la 2, 3 y asi sucesivamente, hay que tener en cuenta que si hay una columna numérica auto incrementable entonces el ordenamiento se hará con solo esa columna y las columnas siguientes se ignoraran)
SELECT column_list FROM table_name WHERE condition;
(Mostrara todos los registros que cumplan con la condición) Ej. 
WHERE Id=5
WHERE Id>=1 && Id !=6
WHERE Id BETWEEN 3 and 7 && Id<>5
WHERE name IS NULL
WHERE Id <> 3,4,5
WHERE NOT IN (3,4,5)	
WHERE IN (3,4,5)
WHERE name=’value_1’	
WHERE name IN (‘value_1’,’value_2’,’value_3’…)
WHERE Id=1 || Id=2
WHERE name=’value_1’ AND (last_name=’value_2’ OR last_name=’value_3’)
WHERE column_name > (SELECT AVG (column_name) FROM table_name)	
SELECT CONCAT (last_name,' ',first_name) FROM actor
(Crea una columna nueva en donde cada registro está compuesto por las columnas, y/o texto encerrado entre los paréntesis del CONCAT)
SELECT CONCAT (last_name,' ',first_name) AS ‘New Column’ FROM actor
(Tambien se le puede asignar un nuevo nombre a la columna con el comando AS)
SELECT column_name AS 'New Column Name' FROM actor;
(Muestra la columna elegida con un nuevo nombre o alias elegido mediante AS)
SELECT column_name+500 AS ‘New_Salario’ FROM table_name;
(Le suma 500 a la columna elegida (no cambia el resultado en la base de datos y debe ser una columna numérica) y da un resultado con un nuevo alias en la columna)
SELECT LOWER (column_1) AS new_column_name_1, UPPER (column_2) AS new_column_name_2 FROM table_name;
(LOWER convierte todas las letras en la cadena de texto especificada a minúsculas, y UPPER las convierte a mayúsculas, se usa AS para crear un nuevo alias a la columna)
SELECT SQRT (column_name) FROM table_name
(SQRT retorna la raíz cuadrada de un valor dado como argumento)
SELECT AVG (column_name) FROM table_name	
(AVG retorna el valor promedio de toda una columna numérica)
SELECT SUM (column_name) FROM table_name
(SUM retorna la suma total de todos los registros de la columna indicada)
SELECT MIN (column_name) FROM table_name
(MIN retorna el valor mínimo de todos los registros de la columna indicada)
SELECT MAX (column_name) FROM table_name
(MAX retorna el valor máximo de todos los registros de la columna indicada)
Otros:
COUNT = cuenta cuantas apariciones hay sobre una consulta en particular, normalmente se usa con GROUP BY para contar cuantas apariciones hay en un grupo en particular.
YEAR = Desgloza un campo TIMESTAMP y solo mostrara el año en una consulta.
MONTH = Dezgloza un campo TIMESTAMP y solo mostrara el mes en una consulta
DAY = Desgloza un campo TIMESTAMP y solo mostrara el dia en una consulta.
SELECT * FROM table_name WHERE column_name > (SELECT AVG (column_name) FROM table_name) ORDER BY column_name DESC LIMIT 5;
(Muestra todos los registros donde sea mayor al promedio de todos los registros de column_name y se ordena el resultado en forma descendente mostrando los primeros 5 registros)
SELECT column_list FROM table_name WHERE column_name LIKE custom_name
(Mostrara todos los registros que en la columna ‘column_name’ se halla encontrado la cadena ‘custom_name’)
SELECT column_list FROM table_name WHERE column_name LIKE ‘DAM%’
(Mostrara todos los registros que en la columna ‘column_name’ empiezen con ‘dam’)
SELECT column_list FROM table_name WHERE column_name LIKE ‘%S’
(Mostrara todos los registros que en la columna ‘column_name’ terminen con la letra S)
SELECT * FROM table_name WHERE column_name LIKE ‘%b%’ OR column_name LIKE ‘%a’
(Mostrara todos los registros que en la columna ‘column_name’ contenga la letra “b” o termina con la letra “a”)
SELECT table_1.column_1, table_1.column_2, table_2.column_1, table_2.column_2 FROM table_1, table_2 WHERE table_1.column_1=table_2.column_1 ORDER BY table_1.column_1
(Se combina la columna 1 y 2 de la tabla 1, y la columna 1 y 2 de la tabla 2 en una tabla nueva temporal, solo si en donde la columna 1 de la tabla 1 sea igual a la columna 1 de la tabla 2, se ordena de forma ascendente)(El where se usa para unir los campos clave de ambas tablas y asi sabes que a cada registro de la tabla 1 le corresponde su correspondiente registro de la tabla 2)
SELECT t1.column_1, t2.column_2, t1.column_1, t2.column_2 FROM table_1 AS t1, table_2 AS t2 WHERE t1.column_1=t2.column_1
(lo mismo que el anterior pero se usa AS para cambiar el alias al nombre de la tabla 1 y 2 por t1 y t2 y asi acortar código, también es posible omitir el AS y funcionara igualmente)
SELECT * FROM t1 INNER JOIN t2 ON t1.column_name = t2.column_name
(Se combina la tabla 1 y la tabla 2 solo si se cumple la condición después del ON)
SELECT * FROM t1, t2 WHERE t1.column_name = t2.column_name
(Se combina la tabla 1 y la tabla 2 solo si se cumple la condición después del WHERE)
SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.column_name = t2.column_name
(Se combina la tabla 1 y la tabla 2, retorna todos los registros de la tabla izquierda, asi no haya coincidencias en la tabla derecha, esto quiere decir que si no hay coincidencias para la clausula ON en la tabla derecha, aun así la combinacion retornará los registros de la primera tabla en el resultado, además la palabra OUTER es opcional, puede ser omitida)
SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.column_name = t2.column_name
(Se combina la tabla 1 y la tabla 2, retorna todos los registros de la tabla derecha, asi no haya coincidencias en la tabla izquierda, esto quiere decir que si no hay coincidencias para la clausula ON en la tabla izquierda, aun así la combinacion retornará los registros de la segunda tabla en el resultado, además la palabra OUTER es opcional, puede ser omitida)
SELECT Id, FirstName, LastName, City FROM table_1 UNION SELECT Id, FirstName, LastName, City FROM table_2
(UNION es utilizado para combinar dos o más resultados SELECT en una tabla, los registros duplicados sonignorados y no se incluyen en el resultado final, si queremos que se incluyan los regitros repetidos podemos utilizar ‘UNION ALL’. Todas las declaraciones SELECT deben tener el “mismo numero de columnas” y “el mismo tipo de datos en cada columna” y “las columnas con sus distintos tipos de datos deben estar en el mismo orden”)
Si tus columnas no coinciden exactamente en todas las consultas, puedes utilizar un valor NULL (o cualquier otro) por ej:
SELECT Id, FirstName, LastName, City FROM table_1 UNION SELECT Id, FirstName, NULL, NULL FROM table_2
(desconozco el resultado final de esto)
Ej 1: 
SELECT SalesOrderID, SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail
GROUP BY SalesOrderID
HAVING SUM(LineTotal) > 100000.00
ORDER BY SalesOrderID ;
Ej 2:
SELECT titles.pub_id, AVG(titles.price) 
FROM titles INNER JOIN publishers 
 ON titles.pub_id = publishers.pub_id 
WHERE publishers.state = 'CA' 
GROUP BY titles.pub_id 
HAVING AVG(price) > 10 
Ej 3:
SELECT titles.pub_id, AVG(titles.price) 
FROM titles INNER JOIN publishers 
 ON titles.pub_id = publishers.pub_id 
GROUP BY titles.pub_id 
HAVING publishers.state = 'CA' 
Ej 4:
SELECT titles.pub_id, AVG(titles.price) 
FROM titles INNER JOIN publishers 
 ON titles.pub_id = publishers.pub_id 
WHERE publishers.state = 'CA' 
GROUP BY titles.pub_id 
Group By se utiliza para agrupar columnas que tengan algo en común, como un nombre o id, pero tengan también diferentes valores en toras columnas como un precio, puedo tener muchas columnas con id 1, pero cada columna puede tener un precio diferente, con group by puedo decir: “A todas las columnas que tengan id 1 les aplico una SUMA (SUM) al campo de precio, y creo un nuevo grupo en donde el id 1 en ves de tener precios separados tengan un solo precio llamado total.Puedo tener varios GROUP BY en una sola consulta como por ejemplo:
mysql> SELECT year, country, product, SUM(profit) AS profit
 FROM sales
 GROUP BY year ASC, country ASC, product ASC;
+------+---------+------------+--------+
| year | country | product | profit |
+------+---------+------------+--------+
| 2000 | Finland | Computer | 1500 |
| 2000 | Finland | Phone | 100 |
| 2000 | India | Calculator | 150 |
| 2000 | India | Computer | 1200 |
| 2000 | USA | Calculator | 75 |
| 2000 | USA | Computer | 1500 |
| 2001 | Finland | Phone | 10 |
| 2001 | USA | Calculator | 50 |
| 2001 | USA | Computer | 2700 |
| 2001 | USA | TV | 250 |
+------+---------+------------+--------+
Aca se agruparan todos las filas que tengan el mismo año, el mismo país, y sea el mismo producto, todas las filas que cumplan esas 3 condiciones se les aplicara una suma de profit y mostrara el total, si hubiera hecho solo un group by al año, entonces esas 6 filas que tienen el año 2000 se hubieran agrupado en una sola fila y se les hubiera aplicado la suma de esos 6, pero los otros datos como país y producto se solaparían asique solo mostrarían la primera aparición, en este caso solo mostrarían Finland y computer.
SELECT ciudad FROM tiempo WHERE baja_temp = max(baja_temp);	
(El ejemplo mostrado anteriormente es una mala formulación de una clausula WHERE porque contiene una función de agregación y esto no es permitido)
La reformulación de esta cláusula seria la siguiente:
SELECT ciudad FROM tiempo WHERE baja_temp = (SELECT max(baja_temp) FROM tiempo);
La consulta de arriba nos trae como resultado la ciudad con la mayor temperatura baja registrada.
SELECT ciudad, max(baja_temp) FROM tiempo GROUP BY ciudad;
(La consulta anterior da como resultado la maxima temperatura baja por ciudad)
SELECT ciudad, max(baja_temp) FROM tiempo GROUP BY ciudad HAVING max(baja_temp) < 40;
(La consulta anterior da como resultado la maxima temperatura por ciudad siempre y cuando el valor de la maxima temperatura baja sea menor a 40)
SELECT ciudad, max(baja_temp) FROM tiempo WHERE ciudad LIKE ‘S%’ GROUP BY ciudad HAVING max(baja_temp) < 40;
(La consulta anterior da como resultado la maxima temperatura por ciudad siempre y cuando el valor de la maxima temperatura baja sea menor a 40 y el nombre de la ciudad empieze por la letra S)
CREACION
CREATE DATABASE Empresa; (Crea una nueva base de datos llamada empresa)
USE Empresa; (Le digo al compilador que a partir de ahora usare la base Empresa)
CREATE TABLE empleados(
	Id_Empleado INT NOT NULL AUTO_INCREMENT,
	Nombre_Empleado VARCHAR(45) NOT NULL,
	PRIMARY KEY (Id_Empleado)
);
Crea una tabla llamada empleados con atributos id y nombre de empleado, y clave primaria el ID del empleado que va a ser auto incrementable.
INSERT INTO table_name VALUES (‘value1’, ‘value2’, ‘valueN’) ;
(Ingreso datos en la tabla ‘table_name’ en sus respectivas columnas, debo llenar todas las columnas que no tengan un valor por defecto o sea NOT NULL)
INSERT INTO table_name (column_1, column_2, column_N) VALUES ('value1','value2','valueN'), ('value1','value2','valueN'); 
(Ingreso datos en la tabla ‘table_name’ en sus respectivas columnas, los valores VARCHAR se ponen entre comillas simples, los numéricos se ponen sin comillas)
INSERT INTO `empresa`.`administradores` (`IdAdministrador`, `NombreAdministrador`, `AreaAdministrador`, `Titulo`) VALUES ('1', 'Damian', 'Magnus', 'Lic En Necchi');
(Inserto datos en una sola línea, base de datos empresa, tabla administradores)
UPDATE table_name SET Nombre_Producto='Pepsi' WHERE Tipo_Producto='REFRESCO';
(Modificar un campo o varios campos de una tabla)
DELETE FROM productos WHERE Tipo_Producto='REFRESCO';
(Eliminar un registro o varios registros de una tabla)
DROP DATABASE empresa;
(Eliminar la base de datos completa incluyendo tablas y sus respectivos atributos)
ALTER TABLE table_name AUTO_INCREMENT = 1;
(Las columnas auto incrementables comienzan desde el ultimo numero asignado, si borro un registro o todos, el valor de autoincremento no se reseteará, para eso uso este comando, reseteo el valor de auto_increment al valor deseado)
TRUNCATE TABLE table_name;
(Elimino todos los registros de la tabla y resetea los valores auto incrementables)
DECLARE variable_name integer;
(Declaro una variable tipo integer)
Tipos de varaibles:
Int (4 bytes), integer (4 bytes), char (1 byte), character (1 byte)
PROCEDIMIENTOS Y FUNCIONES
DROP PROCEDURE procedure_name;
(Elimina un procedimiento anteriormente creado en una base de datos)
CALL procedure_name (parameter1, parameter2);
(Llama a un procedimiento creado anteriormente)
Ej:
CALL stp_actualizar_alumnos(13090333, 'Damian', 'Sant', 'Ger','aguilar');
SELECT function_name (parameter1, parameter2) AS custom_name;
Ej:
SELECT area_triangulos (8,4) AS Area;
PROCEDIMIENTO ALTA:
DELIMITER $$
CREATE PROCEDURE procedure_name (in parameter1 int, in parameter2 varchar (50))
BEGIN
INSERT INTO table_name (column_1, column_2) VALUES (parameter1, parameter2);
END $$
Ej:
delimiter $$
create procedure stp_alta_alumnos (in pmatricula int, in pnombre varchar (50), in pape_pat varchar (50), in pape_mat varchar(50), in pdireccion varchar (50))
begin
insert into prueba.tbl_alumnos (matricula, nombre, ape_pat, ape_mat, direccion) values (pmatricula, pnombre, pape_pat, pape_mat, pdireccion);
end $$
PROCEDIMIENTO ACTUALIZAR:
DELIMITER $$
CREATE PROCEDURE procedure_name (in parameter1 int, in parameter2 varchar (50))
BEGIN
UPDATE table_name SET column_2 = parameter2 WHERE column_1 = parameter1;
END $$
Ej:
delimiter $$
create procedure stp_actualizar_alumnos (in pmatricula int, in pnombre varchar (50), in pape_pat varchar (50), in pape_mat varchar(50), in pdireccion varchar (50))
begin
update tbl_alumnos set nombre = pnombre, ape_pat = pape_pat, ape_mat = pape_mat, direccion = pdireccion WHERE matricula = pmatricula;
end $$
PROCEDIMIENTO BAJA:
DELIMITER $$
CREATE PROCEDURE procedure_name (in parameter1 int)
BEGIN
DELETE FROM table_name WHERE column_1 = parameter1;
END $$
Ej:
DELIMITER $$
CREATE PROCEDURE stp_baja_alumnos (in pmatricula int)
BEGIN
DELETE FROM tbl_alumnos WHERE pmatricula= matricula;
END $$
PROCEDIMIENTO CONSULTA:
DELIMITER $$
CREATE PROCEDURE procedure_name (in parameter1 int)
BEGIN
SELECT column_1, column_2 FROM table_name;
END $$
Ej:
delimiter $$
create procedure consulta_alumnos()
begin
SELECT matricula, nombre, ape_mat FROM tbl_alumnos;
end $$
FUNCION CALCULAR AREA TRIANGULO:
DELIMITER $$
CREATE FUNCTION `area_triangulos` (base INT, altura INT) 
RETURNS CHAR(100)
BEGIN
 DECLARE area INT;
 DECLARE salida CHARACTER(20);
 SET area = (base * altura) / 2;
 SET salida = concat ("Area: ", area);
RETURN salida;
END $$
ESTRUCTURAS CONDICIONALES Y BUCLES
SENTENCIA IF:
DECLARE n int;
SET n = 3;
IF n < 2 THEN
INSERT INTO table_name VALUES('No disponible');
ELSEIF n = 2 THEN
INSERT INTO table_name VALUES('droga');
ELSE
SET n = 4
END IF
SENTENCIA WHILE:
WHILE i <= SQRT(n) DO
IF (n % i) = 0 THEN
 		SET droga = 0;
 END IF;
 SET i = i +1;
END WHILE;
SENTENCIA SWITCH CASE:
CASE var
 WHEN 5 then INSERT INTO prueba VALUES('Suficientes');
 WHEN 4 then INSERT INTO prueba VALUES('Reserva');
 ELSE INSERT INTO prueba VALUES ('Insuficientes);
END CASE;
SENTENCIA DO WHILE:
REPEAT
 INSERT INTO table_name VALUES (i);
 SET i = i + 1;
UNTIL i <= 5;
END REPEAT;
SENTENCIA FOR:
DECLARE a INT Default 0;
loop_name: LOOP
SET a=a+1;
IF a=5 THEN
LEAVE loop_name;
END IF;
END LOOP loop_name;
TRIGGERS
Se requiere construir un TRIGGER que inserte en la segunda tabla un registro gemelo cada vez que se inserte un alumno nuevo en la tabla original. Pero esto solo debe ocurrir si el alumno pertenece a la carrera = 4. Se requiere guardar la fecha de inserción del registro en dicha segunda tabla.
CREATE TABLE ALUMNO (idAlumno int, idCarrera int, Nombre varchar, Apellido varchar, Sexo char, FechaNacimiento datetime)
CREATE TABLE ALUMNO_LOG (idAlumno int, idCarrera int, Nombre varchar, Apellido varchar, Sexo char, FechaNacimiento datetime, FechaInsercion)
CREATE TRIGGER logear_cambio AFTER INSERT ON alumno 
FOR EACH ROW
BEGIN
	IF new.idCarrera = 4 then
		INSERT INTO alumno_log 
		VALUES(new.idAlumno, 
			new.idCarrera, 
			new.nombre, 
			new.apellido, 
			new.sexo, 
			new.fechaNacimiento, 
			now())
	END IF;
END