Bases del lenguaje MySQL.

Tipo de datos, consultas, sentencias, cláusulas y operadores más comunes.

Tipos de Datos:

Se subrayan los más usados

Cadenas de texto

Tipo de campo	Tamaño de Almacenamiento
CHAR(n)	longitud fija. n bytes entre 0, 255, 1 de manera predeterminada
VARCHAR(n)	longitud variable. n +1 bytes entre 0, 65535, 1 de manera predeterminada
TINYBLOB, TINYTEXT	Longitud variable +1 bytes hasta 255 caracteres. Equivale a un varchar (255)
BLOB, TEXT	Longitud +2 bytes texto con un máximo de 65535 caracteres. Tipo BLOB se utiliza para guardar ficheros en datos binarios como Imágenes.
MEDIUMBLOB, MEDIUMTEXT	Longitud +3 bytes. Texto con un máximo de 16.777.215 caracteres.
LONGBLOB, LONGTEXT	Longitud +4 bytes Texto con un máximo de caracteres 4.294.967.295
ENUM(‘value1′,’value2’,…)	Acepta hasta 65.535 valores distintos de una lista. Permite definir listas estáticas de valores alfanuméricos. Por ejemplo; seleccionar los días de la semana
SET(‘value1′,’value2’,…)	Acepta hasta 64 valores distintos de una lista incluyendo el cero, uno.

Numéricos

Tipo de Campo	Tamaño de Almacenamiento
TINYINT	1 byte. Entre -128 a 127. Sin signo, el rango de valores es de 0 a 255
SMALLINT [unsigned]	2 bytes. -32768 a 32767. Sin signo, el rango de valores es de 0 a 65535
MEDIUMINT [unsigned]	3 bytes. -8.388.608 a 8.388.607. Sin signo el rango va desde 0 a 16777215.
INTEGER [unsigned]	4 bytes. -2147483648 a 2147483647. Sin signo el rango va desde 0 a 429.4967.295
BIGINT [unsigned]	8 bytes. -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807. Sin signo el rango va desde 0 a 18.446.744.073.709.551.615.
FLOAT(n, d) [unsigned]	4 ú 8 bytes. Número de coma flotante de precisión simple. Los valores válidos van desde -3.402823466E+38 a -1.175494351E-38, 0 y desde 1.175494351E-38 a 3.402823466E+38.
FLOAT(p)	Número de coma flotante entre 0 y 24
DOUBLE (n,d) [unsigned]	8 bytes Número de coma flotante de precisión doble. Los valores permitidos van desde -1.7976931348623157E+308 a -2.2250738585072014E-308, 0 y desde 2.2250738585072014E-308 a 1.7976931348623157E+308
DOUBLE (p)	Número de coma flotante entre 25 y 53
DECIMAL(n,d) [unsigned]	n 10 de manera predeterminada y 65 como máximo. d 0 de manera predeterminada y 30 como máximo Número en coma flotante desempaquetado y se almacena como una cadena

INTEGER es equivalente a INT DEC, NUMERIC Y FIXED son equivalentes a DECIMAL

[unsigned] Si se especifica este parámetro, los números negativos no estarán permitidos
Funciones de número:

last_insert_id(): Devuelve el ID AUTO_INCREMENT de la última fila que se ha insertado o actualizado en una tabla:

Booleano

Tipo de Campo	Tamaño de Almacenamiento
BOOL, BOOLEAN	Equivalente a TINYINT (1) 0 es considerado como falso;cualquier otro valor es considerado como verdadero

Fecha y Hora

Tipo de Campo	Tamaño de Almacenamiento
DATE	3 bytes. El rango de valores va desde el 1 de enero del 1001 al 31 de diciembre de 9999. El formato de almacenamiento es de año-mes-dia
DATETIME	8 bytes. El rango de valores va desde el 1 de enero del 1001 a las 0 horas, 0 minutos y 0 segundos al 31 de diciembre del 9999 a las 23 horas, 59 minutos y 59 segundos. El formato de almacenamiento es de año-mes-dia horas:minutos:segundos
TIMESTAMP	4 bytes. El rango va desde el 1 de enero de 1970 al año 2037. El formato de almacenamiento depende del tamaño del campo:
TIME	3 bytes. El rango de horas va desde -838 horas, 59 minutos y 59 segundos a 838, 59 minutos y 59 segundos. El formato de almacenamiento es de ‘HH:MM:SS’
YEAR	1 byte. El rango de valores permitidos va desde el año 1901 al año 2155. El campo puede tener tamaño dos o tamaño 4 dependiendo de si queremos almacenar el año con dos o cuatro dígitos.

Funciones de tiempo:

CURDATE() es equivalente a CURRENT_DATE y CURRENT_DATE(). Devuelve la fecha actual como un valor en el formato ‘AAAA-MM-DD’ o AAAAMMDD, dependiendo de si la función se usa en un contexto de cadena o numérico.

insert into promocion
(descripcion,fecha_inicio,fecha_fin,est_activo)
values
/*Para fecha_inicio devuelve la fecha actual - 2020-11-06 
para fecha_fin devolverá la fecha actual mas 10 días - 2020-11-06
*/
('-5% en este libro',CURDATE(),ADDDATE(CURDATE(),10),true),
('Gastos de envío gratis para este libro',null,null,false),
('Un supermarcapágina de regalo',null,null,false)
;

insert into promocion

(descripcion,fecha_inicio,fecha_fin,est_activo)

values

/*Para fecha_inicio devuelve la fecha actual - 2020-11-06

para fecha_fin devolverá la fecha actual mas 10 días - 2020-11-06

('-5% en este libro',CURDATE(),ADDDATE(CURDATE(),10),true),

('Gastos de envío gratis para este libro',null,null,false),

('Un supermarcapágina de regalo',null,null,false)

;

Valores literales
- Cadena: Las cadenas están delimitadas por dos apóstrofos. ‘esto es una cadena’
 Se pueden usar ciertas secuencias de caracteres precedidas por el signo de escape (La antibarra \)
 \’ Apóstrofe
 \» Comillas
 \n nueva línea
 \r Retorno de carro
 \t Tabulación
 \\ Antibarra
 Para incluir un apóstrofe dentro de una cadena existen dos opciones:
 Doblar el apóstrofe: ‘C»est la vie’
 anteponer la antibarra al apóstrofe: ‘C/’est la vie’
- Número: se pueden escribir sin los delimitadores de los apóstrofes. El separador decimal es el punto (.). Se pueden utilizar la notación exponecial.
 123
 -10
 1.23
 1.2e3
- Fecha, hora, fecha/hora: Puede escribirse como una cadena en el formato ‘YYYY-MM-DD’ o bien como un número YYYYMMDD y lo mismo con las horas ‘HH:MM:SS’ o HHMMSS e igualmente para sus combinaciones de fecha/hora. ‘YYYY-MM-DD-HH:MM:SS’ o YYYYMMDDHHMMSS
- Booleano: <Verdadero> y <falso> pueden ser representados por consstantes TREU (valor 1) o FALSE (valor 0)
Expresión:

Una expresión puede utilizar valores literales, nombres de columnas, variables, operadores aritméticos habituales (+, -, *, /) paréntesis y fuciones.
Ejemplo: precio_sin_iva * (1 + tipo_iva/100)
UPPER(titulo)
Valor NULL

El valor NULL significa la ausencia de valor. NULL es diferente que 0 y diferente de una cadena vacía. Una expresión con una valor NULL da siempre un resultado NULL (10 + Null=Null)
Los valores NULL son a menudo una fuente de problemas
Variable
- Variables de usuario: se utilizan bajo la sintásis @nombre_variable y pueden contener valores alfanuméricos, _, $ y .
  Las variables se pueden usar en expresiones.
  Para asignar una variable se puede utilizar el comando SET
  SET @nombre_variable = Expresión
  Ejemplo:
  
  Ejemplo Asignación de variable
  MySQL
  
  SET @tipo_iva=10 SELECT ROUND (100 * (1 + @tipo_iva/100),2)
  
  1
  2
  
  SET @tipo_iva=10
  SELECT ROUND (100 * (1 + @tipo_iva/100),2)
  
  Resultado = 110.00
- Variables del sistema: MySQL ofrece un gran número de variables que pueden ser modificadas por el usuario utilizando el comando SET
  
  Cambio de variable global
  MySQL
  
  SET @@lc_time_names=es_ES
  
  1
  
  SET @@lc_time_names=es_ES
  
  Se puede usar la siguiente sentencia para ver las variables del sistema
  
  Mostrar variable del sistema
  MySQL
  
  show variables
  
  1
  
  show variables
  
  Y añadir la cláusula LIKE para buscar una en específico.
  
  Buscar variable globales
  MySQL
  
  show variables LIKE 'have%'
  
  1
  
  show variables LIKE 'have%'
Comentarios

Comentar codigo
MySQL

#comentario hasta el final de la linea --comentario hasta el final de la linea /*Se puede añadir comentarios con varias lineas*/

1
2
3
4
5

#comentario hasta el final de la linea
--comentario hasta el final de la linea
/*Se puede añadir
comentarios con
varias lineas*/
Restricciones
- UNIQUE: se utiliza para garantizar que no se inserten valores duplicados en una columna específica o combinación de columnas que participen en la restricción UNIQUE y no formen parte de la CLAVE PRIMARIA. Si utilizamos la sentencia UNIQUE(columna1,columna2) quiere decir que en su conjunto no se puede repetir.
- NOT NULL: sirve para evitar insertar valores NULL en la columna especificada. Esto significa que debe proporcionar un valor válido SQL NOT NULL a esa columna en las instrucciones INSERT o UPDATE, ya que la columna siempre contendrá datos.
- DEFAULT: se utiliza para proporcionar un valor predeterminado para una columna. El valor predeterminado se agregará a todos los registros nuevos SI no se especifica ningún otro valor.

Consultas SQL simples.

#Esta consulta no devuelve datos
SELECT columna_1 FROM nombre_tabla WHERE columna__con_fecha = '2020-01-01'
# En cambio si cambiamos el tipo de columna a date sí

SELECT columna_1 FROM nombre_tabla WHERE DATE(columna_con_fecha) = '2020-01-01'

# Buscar entre fechas

SELECT columna_1 FROM nombre_tabal WHERE columna_con_fecha BETWEEN
'2020-01-01 00:00:00' and '2020-12-31 00:00:00'

#Esta consulta no devuelve datos

SELECT columna_1 FROM nombre_tabla WHERE columna__con_fecha = '2020-01-01'

# En cambio si cambiamos el tipo de columna a date sí

SELECT columna_1 FROM nombre_tabla WHERE DATE(columna_con_fecha) = '2020-01-01'

# Buscar entre fechas

SELECT columna_1 FROM nombre_tabal WHERE columna_con_fecha BETWEEN

'2020-01-01 00:00:00' and '2020-12-31 00:00:00'

Mostrar datos

#Ver lista de las bases de datos gestionadas por el servidor
show databases; # o
show schemas

#Asignar una base de datos
use nombre_base_de_datos;

#Mostras las tablas de la bases de datos
show table;

#Muestar las características de la tabla
show columns from nombre_tabla;

#Ver los errores en la consola
show warnings; # o
show errors;

#Ver lista de las bases de datos gestionadas por el servidor

show databases; # o

show schemas

#Asignar una base de datos

use nombre_base_de_datos;

#Mostras las tablas de la bases de datos

show table;

#Muestar las características de la tabla

show columns from nombre_tabla;

#Ver los errores en la consola

show warnings; # o

show errors;

Leer Datos
La sentencia SELECT permite leer datos, esta debe contener la clausula FROM para indicar la tabla. Entre el SELECT y el FROM se pueden indicar unas series de expresiones separadas con comas que pueden ser el nombre de una column de una tabla, un * para indicar todas un valor literal o una expresión de cálculo.

#Muestra todas las columnas de una tabla
SELECT * FROM nombre_tabla;

#MUestra dos columna de una tabla
SELECT columna_1,columna_2 FROM nombre_tabla;

#Usando una expresión de calculo
SELECT columna_1, columna_2+ROUND(columna_3*5.5/100,2)
#ROUND es una expresión de calculo sobre una columna

/* Usando el modificador DISTINCT podemos obtener un solo resultado de cada conjunto
de fila duplicado*/
SELECT DISTINCT columna_1 FROM nombre_tabla;

#Muestra todas las columnas de una tabla

SELECT * FROM nombre_tabla;

#MUestra dos columna de una tabla

SELECT columna_1,columna_2 FROM nombre_tabla;

#Usando una expresión de calculo

SELECT columna_1, columna_2+ROUND(columna_3*5.5/100,2)

#ROUND es una expresión de calculo sobre una columna

/* Usando el modificador DISTINCT podemos obtener un solo resultado de cada conjunto

de fila duplicado*/

SELECT DISTINCT columna_1 FROM nombre_tabla;

La sentencia SELECT también puede utilizarse para leer expresiones de cálculo, o variables sin referirse a una tabla

#Calculo sencillo
select 1+2+3
#resultado 6

# Para permitir compatibilidad con los servidores de bases de datos que no lo permitan
#se usa la cláusula FROM seguida de dual como nombre de tabla
select 1+2+3 from dual
#resultado 6

#Calculo sencillo

select 1+2+3

#resultado 6

# Para permitir compatibilidad con los servidores de bases de datos que no lo permitan

#se usa la cláusula FROM seguida de dual como nombre de tabla

select 1+2+3 from dual

#resultado 6

Una expresión después de la sentencia SELECT puede estar seguida de un ALIAS que implicara el cambio del nombre de la columna SÓLO en la consulta y no en la tabla.

SELECT columna_1 AS alias FROM nombre_tabla;
#la pala AS es opcional
SELECT columna_1 alias FROM nombre_tabla;

/*si el alias necesita tener espacios o cualquier carácter especial se debe
introducirse entre comillas*/
SELECT columna_1 'alias con espacios' FROM nombre_tabla;

SELECT columna_1 AS alias FROM nombre_tabla;

#la pala AS es opcional

SELECT columna_1 alias FROM nombre_tabla;

/*si el alias necesita tener espacios o cualquier carácter especial se debe

introducirse entre comillas*/

SELECT columna_1 'alias con espacios' FROM nombre_tabla;

Asimismo, la cláusula FROM un nombre de tabla puede ir seguido de un alias. Un alias de tabla puede utilizarse en lugar del nombre de la tabla como prefijo de una columna para indicar que pertenece a esa tabla

SELECT col.columna_1 FROM nombre_tabla AS col;
#recordar que podemos omitir la palabra AS
SELECT col.columna_1 FROM nombre_tabla col;

SELECT col.columna_1 FROM nombre_tabla AS col;

#recordar que podemos omitir la palabra AS

SELECT col.columna_1 FROM nombre_tabla col;

La asignación de este tipo de alias es obligatorio cuando se realizan consultas que implican a más de tabla y es recomendable anteponer al nombre de la columna el nombre de la tabla o el alias, como vimos en el ejemplo anterior.

SELECT nombre_tabla_1.columna_1, nombre_tabla_2.columna_1 FROM nombre_tabla_1,nombre_tabla_2
# Esto es lo mismo que
SELECTO t1.columna_1,t2.columan_1 FROM nombre_tabla_1 t1, nombre_tabla_2 t2

SELECT nombre_tabla_1.columna_1, nombre_tabla_2.columna_1 FROM nombre_tabla_1,nombre_tabla_2

# Esto es lo mismo que

SELECTO t1.columna_1,t2.columan_1 FROM nombre_tabla_1 t1, nombre_tabla_2 t2

Restringir Resultados
Para restringir los resultados de una consulta usamos la cláusula WHERE. Esta debe ir precedida de expresiones y operadores, donde las expresiones son de tipo de las que pueden aparecer en la cláusula SELECT: columna, valor literal o expresión de calculo.
Una condición devuelve : TRUE, FALSE O NULL
Los operadores más utilizados en la cláusula WHERE son los siguientes:

Operador	Función
=	Igualdad
>	Mayor que. Estrictamente superior
>=	Mayor o igual que. Superior o igual
<	Menor que. Estrictamente inferior
<=	Menor o igual que. Inferior o igual
<> o !=	Diferente
BETWEEN min AND max	Superior o igual a min e inferior o igual a max
IN (valor1, valor2, …)	Igualdad con cualquier elemento de una tabla
IS NULL, IS NOT NULL	Comprueba si una expresión es NULL o no
LIKE	Correspondencia con relación a un modelo

# Igual que
select columna_1 FROM nombre_tabla where columna_1 = 1;

# Distinto que
select columna_1 FROM nombre_tabla where columna_1 = 1;

# Igual con cualquier elemento
select columna_1 FROM nombre_tabla where columna_1 IN (1,2,3);

# Entre dos elementos 
select columna_1 FROM nombre_tabla where columna_1 BETWEEN 1 and 3

#Búsqueda en un par de columnas
SELECT columna_1 FROM nombre_tabla
WHERE (columna_2,columna_3) = ('valor columna_2', valor columan_3)

# Igual que

select columna_1 FROM nombre_tabla where columna_1 = 1;

# Distinto que

select columna_1 FROM nombre_tabla where columna_1 = 1;

# Igual con cualquier elemento

select columna_1 FROM nombre_tabla where columna_1 IN (1,2,3);

# Entre dos elementos

select columna_1 FROM nombre_tabla where columna_1 BETWEEN 1 and 3

#Búsqueda en un par de columnas

SELECT columna_1 FROM nombre_tabla

WHERE (columna_2,columna_3) = ('valor columna_2', valor columan_3)

Las columnas de Tipo DATETIME o TIMESTAMP pueden almacenar un componente horario que puede plantear problemas para la búsqueda en la fecha. Una solución es emplear una búsqueda limitada y otra es aplicando la función DATE para eliminar el componente horario.

#Esta consulta no devuelve datos
SELECT columna_1 FROM nombre_tabla WHERE columna__con_fecha = '2020-01-01'
# En cambio si cambiamos el tipo de columna a date sí

SELECT columna_1 FROM nombre_tabla WHERE DATE(columna_con_fecha) = '2020-01-01'

# Buscar entre fechas

SELECT columna_1 FROM nombre_tabal WHERE columna_con_fecha BETWEEN
'2020-01-01 00:00:00' and '2020-12-31 00:00:00'

#Esta consulta no devuelve datos

SELECT columna_1 FROM nombre_tabla WHERE columna__con_fecha = '2020-01-01'

# En cambio si cambiamos el tipo de columna a date sí

SELECT columna_1 FROM nombre_tabla WHERE DATE(columna_con_fecha) = '2020-01-01'

# Buscar entre fechas

SELECT columna_1 FROM nombre_tabal WHERE columna_con_fecha BETWEEN

'2020-01-01 00:00:00' and '2020-12-31 00:00:00'

Para comprobar que una expresión es NULL o NOT NULL, debemos utilizar el operador IS NULL o IS NOT NULL para ver un resultado correcto. Aunque si utilizamos los operadores <> o != no da error este consulta no devolvería resultado

Con el operador LIKE es posible utilizar dos caracteres comodín:
% Sustituye un numero cualquiera de caracteres incluyendo ninguno
_ Sustituye exactamente un caracter

/*Consulta que busca registros que contengan la palabra 'registro_del_campo'*/
SELECT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%';

/*Consulta que busca registros que contengan la palabra 'registro_del_campo'y
queremos ver los registros agrupados. Añadimos el modificador DISTINCT*/
SELECT DISTINCT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%';

/*Igual que la consulta anterior pero buscando varios registros*/
SELECT DISTINCT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%otro_registro_del_campo%';

/*Consulta que busca registros que contengan la palabra 'registro_del_campo'*/

SELECT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%';

/*Consulta que busca registros que contengan la palabra 'registro_del_campo'y

queremos ver los registros agrupados. Añadimos el modificador DISTINCT*/

SELECT DISTINCT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%';

/*Igual que la consulta anterior pero buscando varios registros*/

SELECT DISTINCT columna_1 FROM nombre_tabla WHERE columan_1 LIKE 'registro_del_campo%otro_registro_del_campo%';

Varios condiciones simples se pueden combinar con los operador NOT, AND y OR en este orden predeterminado (del más prioritario al menos prioritario). Para evaluar en un orden diferente hay que utilizar paréntesis.

SELECT columna_1, columna_2 FROM nombre_tabla
WHERE (columan_1 = 'resgistro_1' OR columna_2 = 'resgistro_2')
      AND (columna_3 = 'otro_registro')

SELECT columna_1, columna_2 FROM nombre_tabla

WHERE (columan_1 = 'resgistro_1' OR columna_2 = 'resgistro_2')

AND (columna_3 = 'otro_registro')

Ordenar el resultado: Cláusula ORDER BY

La ordenación puede ser creciente ASC (Por defecto) o decreciente DESC y pueden contener varias expresiones de orden separadas con una coma.

#Se pueden ordenar Por:
#Una columna
SELECT * FROM nombre_tabla ORDER BY nombre_columna DESC

#Una expresión basada en columnas
SELECT columna_1, columna_2+ROUND(columna_3*5.5/100,2) ORDER BY columna_2+ROUND(columna_3*5.5/100,2) DESC

#Un alias de columna
SELECT columna_1 alias FROM nombre_tabla ORDER BY alias DESC

#un número correspondiente a la posición de una expresión de la cláusula SELECT
SELECT columa_1,columna_2 FROM nombre_tabla ORDER BY columa_1,columna_2 DESC;

#Se pueden ordenar Por:

#Una columna

SELECT * FROM nombre_tabla ORDER BY nombre_columna DESC

#Una expresión basada en columnas

SELECT columna_1, columna_2+ROUND(columna_3*5.5/100,2) ORDER BY columna_2+ROUND(columna_3*5.5/100,2) DESC

#Un alias de columna

SELECT columna_1 alias FROM nombre_tabla ORDER BY alias DESC

#un número correspondiente a la posición de una expresión de la cláusula SELECT

SELECT columa_1,columna_2 FROM nombre_tabla ORDER BY columa_1,columna_2 DESC;

Si la consulta incluye la cláusula WHERE, la cláusula ORDER BY debe ir después.

Limitar el número de filas: cláusula LIMIT
Sirve para limitar el número de fila devueltas. Es la típica consulta para sacar un TOP X «Palmares»

#mostrar los 10 mejores resultados de una consulta
SELECT columna_1, columna_2
FROM nombre_tabla
ORDER BY columna_3 DESC
LIMIT 10;

# Ahora queremos mostrar los 5 siguientes
SELECT columna_1, columna_2
FROM nombre_tabla
ORDER BY columna_3 DESC
LIMIT 10,5;

#mostrar los 10 mejores resultados de una consulta

SELECT columna_1, columna_2

FROM nombre_tabla

ORDER BY columna_3 DESC

LIMIT 10;

# Ahora queremos mostrar los 5 siguientes

SELECT columna_1, columna_2

FROM nombre_tabla

ORDER BY columna_3 DESC

LIMIT 10,5;

Si la consulta incluye la cláusula WHERE y/o la cláusula ORDER BY, la cláusula LIMIT debe ir después.

Leer en Varias tablas: Combinación. INNER JOIN
MySQL presenta varias sintaxis para combinar.
Es muy recomendable definir alias de las tablas y pre fijarlos para en el nombre de las columnas

###COMBINACIONES INTERNAS###
En una combinación interna solo se devuelve las filas que se correspondan en las dos tablas. Si una fila de la primera tabla no tiene correspondencia en la segunda tabla, no se devuelven (y recíprocamente). Por ejemplo cuando ese resultado es NULL

##Combianciones Simples
#Nº 1 Escribimos la condición de la unión en la cláusula WHERE. 
/*NO es una sintaxis de la norma ANSI*/
SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2  -- nombre de las columnas con su alias correspondiente
FROM nombre_tabla_1 aliast1,nombre_tabla_2 aliast2
WHERE aliast1.nombre_columna = aliast2.nombre_columna --se pueden concatenar con los operadores NOT, AND y OR

#Nº2 y Nº3 la combinación de unión se hace en la cláusula FROM mediante la cláusula INNER JOIN
/*SE ajustan a la norma ANSI*/
#Nº2
SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2 
FROM nombre_tabla_1 aliast1 INNER JOIN nombre_tabla_2 aliast2 ON (aliast1.nombre_columna = aliast2.nombre_columna)
WHERE una_condicion
/*Con la cláusula ON la condición de unión está escrita explícitamente. 
como en la clausula WHERE de la Nº1*/

#Nº3
SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2 
FROM nombre_tabla_1 aliast1 INNER JOIN nombre_tabla_2 aliast2 
USING (nombre_columna) --es equivalente a ON (aliast1.nombre_columna = aliast2.nombre_columna) de la Nº2
/*Con la cláusula USING la condición de unión está escrita implícitamente en las columnas mencionadas
que deben llevar EL MISMO NOMBRE en las 2 tablas.*/

##Combianciones Simples

#Nº 1 Escribimos la condición de la unión en la cláusula WHERE.

/*NO es una sintaxis de la norma ANSI*/

SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2 -- nombre de las columnas con su alias correspondiente

FROM nombre_tabla_1 aliast1,nombre_tabla_2 aliast2

WHERE aliast1.nombre_columna = aliast2.nombre_columna --se pueden concatenar con los operadores NOT, AND y OR

#Nº2 y Nº3 la combinación de unión se hace en la cláusula FROM mediante la cláusula INNER JOIN

/*SE ajustan a la norma ANSI*/

#Nº2

SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2

FROM nombre_tabla_1 aliast1 INNER JOIN nombre_tabla_2 aliast2 ON (aliast1.nombre_columna = aliast2.nombre_columna)

WHERE una_condicion

/*Con la cláusula ON la condición de unión está escrita explícitamente.

como en la clausula WHERE de la Nº1*/

#Nº3

SELECT aliast1.nombre_columna_1,aliast2.nombre_columna_2

FROM nombre_tabla_1 aliast1 INNER JOIN nombre_tabla_2 aliast2

USING (nombre_columna) --es equivalente a ON (aliast1.nombre_columna = aliast2.nombre_columna) de la Nº2

/*Con la cláusula USING la condición de unión está escrita implícitamente en las columnas mencionadas

que deben llevar EL MISMO NOMBRE en las 2 tablas.*/

Una combinación se realiza mediante la unión por equivalencia (igualdad) entre una columna de la primera tabla y una columna de la segunda. Existen otros tipos de combinaciones no basadas en la igualdad.
*INNER es opcional
Ejemplo con tres tablas

# con la cláusula JOIN SINTAXIS

SELECT
t1.nombre_columan_1,
t1.nombre_columan_2,
t2.nombre_columan_1
FROM
nombre_tabla_1 t1
    JOIN
nombre_tabla_3 t3
    ON (t1.nombre_columan_1 = t3.nombre_columan_1)
    JOIN
nombre_tabal_2 t2
    ON (t3.nombre_columna_2 = t2.nombre_columna_2)
WHERE una_condicion
ORDER BY t1.nombre_columna_2 DESC

#Ejemplo con tabla curso
select
t1.id,
t1.titulo,
t2.nombre
from
libro t1
	join
    autor_libro t3
    on (t1.id = t3.id_libro)
    join
    autor t2
    on(t3.id_autor = t2.id)
where
	t1.anio_publicacion=2006
order by
	t1.titulo;

# con la cláusula JOIN SINTAXIS

SELECT

t1.nombre_columan_1,

t1.nombre_columan_2,

t2.nombre_columan_1

FROM

nombre_tabla_1 t1

JOIN

nombre_tabla_3 t3

ON (t1.nombre_columan_1 = t3.nombre_columan_1)

JOIN

nombre_tabal_2 t2

ON (t3.nombre_columna_2 = t2.nombre_columna_2)

WHERE una_condicion

ORDER BY t1.nombre_columna_2 DESC

#Ejemplo con tabla curso

select

t1.id,

t1.titulo,

t2.nombre

from

libro t1

join

autor_libro t3

on (t1.id = t3.id_libro)

join

autor t2

on(t3.id_autor = t2.id)

where

t1.anio_publicacion=2006

order by

t1.titulo;

###COMBINACIONES EXTERNAS###

Con una combinación externa, la consulta devuelves todos los valores NULL (que no tengan correspondencia)
Comandos Utilizados para combinaciones externas
LEFT JOIN devuelve las filas de la tabla de la izquierda aunque no tengan correspondencia con la otra tabla

#Sintaxis clausula LEFT JOIN
SELECT t1.nombre_columna_1, t2.nombre_columna_1
FROM nombre_tabla_1 t1
LEFT JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1
ORDER BY t1.nombre_columna_

#Sintaxis clausula LEFT JOIN

SELECT t1.nombre_columna_1, t2.nombre_columna_1

FROM nombre_tabla_1 t1

LEFT JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1

ORDER BY t1.nombre_columna_

RIGHT JOIN devuelve las filas de la tabla de la derecha aunque no tengan correspondencia con la otra tabla

#Sintaxis clausula RIGHT JOIN
SELECT t1.nombre_columna_1, t2.nombre_columna_1
FROM nombre_tabla_1 t1
RIGHT JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1
ORDER BY t1.nombre_columna_

#Sintaxis clausula RIGHT JOIN

SELECT t1.nombre_columna_1, t2.nombre_columna_1

FROM nombre_tabla_1 t1

RIGHT JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1

ORDER BY t1.nombre_columna_

FULL OUTER JOIN devuelve todas las filas donde se encuentren resultados en ambas tablas

#Sintaxis clausula FULL OUTER JOIN
SELECT t1.nombre_columna_1, t2.nombre_columna_1
FROM nombre_tabla_1 t1
FULL OUTER JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1
ORDER BY t1.nombre_columna_

#Sintaxis clausula FULL OUTER JOIN

SELECT t1.nombre_columna_1, t2.nombre_columna_1

FROM nombre_tabla_1 t1

FULL OUTER JOIN nombre_tabla_2 t2 ON t1.nombre_columna = t2.nombre_columna_1

ORDER BY t1.nombre_columna_

Autocombinación
Es posible unir tabla consigo misma para implementar una estructura jerárquica. Pa ello, la tabla debe estar 2 veces en la cláusula FROM, con alias distintos y escribir la combinación en la cláusula WHERE

#Ejemplo de autocombinación

SELECT t1.nombre_columan_1 aliast1, t2.nombre_columan_1 aliast2
FROM
nombre_tabal_1 t1,
nombre_tabla_2 t2
WHERE
t1.nombre_columna = t2nombre_columna;

#Ejemplo de autocombinación

SELECT t1.nombre_columan_1 aliast1, t2.nombre_columan_1 aliast2

FROM

nombre_tabal_1 t1,

nombre_tabla_2 t2

WHERE

t1.nombre_columna = t2nombre_columna;

Insertar Datos en una fila: La sentencia INSERT INTO

##Sintaxis más comunes
#insertando valores en columnas específicas
<span class="sqlkeywordcolor">INSERT</span> <span class="sqlkeywordcolor">INTO</span> <em>nombre_tabla</em> (<em>columna1</em>,<em> columna2</em>,<em> columna3</em>, ...)
<span class="sqlkeywordcolor">VALUES</span> (<em>valor1</em>,<em> valor2</em>,<em> valor3</em>, ...);

#Si vamos a introducir todos los valores de la tabla no necesitamos decir el nombre de las columnas
<span class="sqlkeywordcolor">INSERT</span> <span class="sqlkeywordcolor">INTO</span> <em>nombre_tabla</em>
<span class="sqlkeywordcolor">VALUES</span> (<em>valor1</em>,<em> valor2</em>,<em> valor3</em>, ...);

##También se puede utilizar una sintaxis con la cláusula SET
#es útil para insertar valores en la creación de procedures o fórmulas
INSERT INTO nombre_tabla
SET columna1 = 'valor cadena', columna2 = valor_no_cadena, columna... = valor...

##Sintaxis más comunes

#insertando valores en columnas específicas

INSERT INTO nombre_tabla (columna1, columna2, columna3, ...)

VALUES (valor1, valor2, valor3, ...);

#Si vamos a introducir todos los valores de la tabla no necesitamos decir el nombre de las columnas

INSERT INTO nombre_tabla

VALUES (valor1, valor2, valor3, ...);

##También se puede utilizar una sintaxis con la cláusula SET

#es útil para insertar valores en la creación de procedures o fórmulas

INSERT INTO nombre_tabla

SET columna1 = 'valor cadena', columna2 = valor_no_cadena, columna... = valor...

Si en la inserción de los valores no se menciona algunos de estos valores en las columnas, estas se pueden completar automáticamente según como esté creado ese campo en la base de datos. Si el campo tiene el valor AUTO_INCREMET, permite NULLs y/o tiene un valor DEFAUL, estos valores se insertarán de forma automática a no ser que se asigne un valor. Si no es así dará un error si el modo SQL «estricto» esta activo, de lo contario insertará el 0 para un número, cadena vacía para una cadena, fecha «cero» para una fecha mostrándonos Warnings.

Para forzar la inserción de datos se pueden usar las clausulas IGNORE y/o ON DUPLICATE KEY UPDATE.

Modificar filas de una tabla: La sentencia UPDATE
Actualización en una Tabla

#Sintaxis
UPDATE nombre_tabla
SET nombre_columna = 'valor_que_queremos_modofciar'
WHERE [condición si es necesario]
ORDER BY [orden si es necesario]
LIMIT [limite si es necesario]
##Ejemplos:
#insertando un campo
UPDATE autor 
SET 
    mail = 'oliver.heurtel@gmail.com'
WHERE
    apellidos = 'HEURTEL'
        AND nombre = 'Oliver';
#insertando más de un campo, columnas separadas por comas
UPDATE autor 
SET 
    mail = 'oliver.heurtel@gmail.com',
    tel_oficina = 667667667
WHERE
    apellidos = 'HEURTEL'
        AND nombre = 'Oliver';
#Aplicando cálculo a una expresión 
UPDATE coleccion 
SET 
    gastos_siniva = ROUND(precio_siniva * 1.015, 2)
WHERE
    gastos_siniva IS NULL;

#Sintaxis

UPDATE nombre_tabla

SET nombre_columna = 'valor_que_queremos_modofciar'

WHERE [condición si es necesario]

ORDER BY [orden si es necesario]

LIMIT [limite si es necesario]

##Ejemplos:

#insertando un campo

UPDATE autor

SET

mail = 'oliver.heurtel@gmail.com'

WHERE

apellidos = 'HEURTEL'

AND nombre = 'Oliver';

#insertando más de un campo, columnas separadas por comas

UPDATE autor

SET

mail = 'oliver.heurtel@gmail.com',

tel_oficina = 667667667

WHERE

apellidos = 'HEURTEL'

AND nombre = 'Oliver';

#Aplicando cálculo a una expresión

UPDATE coleccion

SET

gastos_siniva = ROUND(precio_siniva * 1.015, 2)

WHERE

gastos_siniva IS NULL;

Actualización en varias tablas

#Sintaxis
UPDATE nombre_tabla_1 t1
        JOIN
    nombre_tabla_2 t2 ON (t1.colimna1 = t2.columna1) 
SET 
    t2.columna = t2.columna + 0.5,
    t1.columna = 2
WHERE
    t2.columna = 'valor'
        AND t1.columna = 'a otro valor'

#Ejemplo
UPDATE libro t1
        JOIN
    coleccion t2 ON (t1.id_coleccion = t2.id) 
SET 
    t2.precio_siniva = t2.precio_siniva + 0.5,
    t1.id_promocion = 2
WHERE
    t2.nombre = 'TechNote'
        AND t1.id_promocion IS NULL;

#Sintaxis

UPDATE nombre_tabla_1 t1

JOIN

nombre_tabla_2 t2 ON (t1.colimna1 = t2.columna1)

SET

t2.columna = t2.columna + 0.5,

t1.columna = 2

WHERE

t2.columna = 'valor'

AND t1.columna = 'a otro valor'

#Ejemplo

UPDATE libro t1

JOIN

coleccion t2 ON (t1.id_coleccion = t2.id)

SET

t2.precio_siniva = t2.precio_siniva + 0.5,

t1.id_promocion = 2

WHERE

t2.nombre = 'TechNote'

AND t1.id_promocion IS NULL;

Eliminar filas de una tabla: Cláusila DELETE
Borra los registros de una tabla. Si añadimos la cláusula WHERE borrara los registro de la condición sino borrara toda la tabla.

##Sintaxis
#Borra todos los registro de una tabla
DELETE FROM nombre_tabla;

#Borrar los registros dentro de la condicion
DELETE FROM nombre_tabla WHERE condicion;

##Sintaxis

#Borra todos los registro de una tabla

DELETE FROM nombre_tabla;

#Borrar los registros dentro de la condicion

DELETE FROM nombre_tabla WHERE condicion;

La diferencia entre usar la cláusula DELETE o TRUNCATE son:

+----------------------------------------+----------------------------------------------+
|                Truncate                |                    Delete                    |
+----------------------------------------+----------------------------------------------+
| Es posible hacer rollback              | Es posible hacer rollback                    |
|                                        |                                              |
|                                        |                                              |
| Ejemplo:                               | Ejemplo:                                     |
| BEGIN TRAN                             | BEGIN TRAN                                   |
| TRUNCATE TABLE #columna                | DELETE FROM #columna                         |
| SELECT * FROM #columna                 | SELECT * FROM #columna                       |
| ROLLBACK                               | ROLLBACK                                     |
| SELECT * FROM #columna                 | SELECT * FROM #columna                       |
+----------------------------------------+----------------------------------------------+
| Truncate resetea el campo identity de  | Delete no resetea el campo identity de la    |
| la Tabla                               | Tabla                                        |
+----------------------------------------+----------------------------------------------+
| Bloquea la tabla completa              | Bloquea solo la fila a borrar                |
+----------------------------------------+----------------------------------------------+
| Es un comando DDL                      | Es un comando DML                            |
| (Data Definition Language)             |(Data Manipulation Language)                  |
+----------------------------------------+----------------------------------------------+
| No se puede usar WHERE                 | Se puede usar WHERE para filtrar las filas   |
+----------------------------------------+----------------------------------------------+
| El trigger de la tabla no se ejecuta   | El trigger de la tabla sí se ejecuta         |
+----------------------------------------+----------------------------------------------+
| Sintaxis:                              | Sintaxis:                                    |
| 1) TRUNCATE TABLE #Personas            | 1) DELETE FROM #Personas                     |
|                                        | 2) DELETE FROM #Personas  WHERE              |
|                                        |    Id IN (1,2,3)                             |
+----------------------------------------+----------------------------------------------+

+----------------------------------------+----------------------------------------------+

| Truncate | Delete |

+----------------------------------------+----------------------------------------------+

| Es posible hacer rollback | Es posible hacer rollback |

| | |

| Ejemplo: | Ejemplo: |

| BEGIN TRAN | BEGIN TRAN |

| TRUNCATE TABLE #columna | DELETE FROM #columna |

| SELECT * FROM #columna | SELECT * FROM #columna |

| ROLLBACK | ROLLBACK |

| SELECT * FROM #columna | SELECT * FROM #columna |

+----------------------------------------+----------------------------------------------+

| Truncate resetea el campo identity de | Delete no resetea el campo identity de la |

| la Tabla | Tabla |

+----------------------------------------+----------------------------------------------+

| Bloquea la tabla completa | Bloquea solo la fila a borrar |

+----------------------------------------+----------------------------------------------+

| Es un comando DDL | Es un comando DML |

| (Data Definition Language) |(Data Manipulation Language) |

+----------------------------------------+----------------------------------------------+

| No se puede usar WHERE | Se puede usar WHERE para filtrar las filas |

+----------------------------------------+----------------------------------------------+

| El trigger de la tabla no se ejecuta | El trigger de la tabla sí se ejecuta |

+----------------------------------------+----------------------------------------------+

| Sintaxis: | Sintaxis: |

| 1) TRUNCATE TABLE #Personas | 1) DELETE FROM #Personas |

| | 2) DELETE FROM #Personas WHERE |

| | Id IN (1,2,3) |

+----------------------------------------+----------------------------------------------+

Cursos recocmendados

https://www.youtube.com/playlist?list=PLRqt40xwaN4ZVjkPA8fvcIemLqJJb2v80

Bases del lenguaje MySQL.

Tipo de datos, consultas, sentencias, cláusulas y operadores más comunes.

Tipos de Datos:

Valores literales

Expresión:

Valor NULL

Variable

Comentarios

Restricciones

Consultas SQL simples.

###COMBINACIONES EXTERNAS###

Cursos recocmendados

Acerca de Joaquin

Deja un comentario Cancelar respuesta

Tipo de datos, consultas, sentencias, cláusulas y operadores más comunes.

Tipos de Datos:

Valores literales

Expresión:

Valor NULL

Variable

Comentarios

Restricciones

Consultas SQL simples.

###COMBINACIONES EXTERNAS###

Cursos recocmendados

Acerca de Joaquin

Interacciones del lector

Deja un comentario Cancelar respuesta