sql >> Base de Datos >  >> RDS >> Mysql

Comando de inserción de MySQL frente a la sintaxis de consulta de T-SQL con ejemplos

Los desarrolladores son estudiantes de por vida. Obtener nuevos conocimientos tan rápido como podamos es siempre nuestro trabajo. Si viene del campo de T-SQL, ¿cuál es la forma más rápida de aprender MySQL? A menudo desea comparar sintaxis. La última vez aprendiste a crear una tabla en MySQL. Nuestra publicación de hoy lo llevará un paso más allá. Insertaremos registros con MySQL INSERT.

¿Qué tan fácil puede ser? Ambas plataformas de bases de datos usan SQL, pero sabemos que estos dos productos de bases de datos tienen algunas adiciones a la sintaxis SQL estándar. MySQL INSERT no es una excepción.

Por lo tanto, si estás cansado de comparar referencias de MySQL y SQL Server, hoy es tu día de suerte. He curado la sintaxis e hice la comparación por usted. Además, tendremos ejemplos para comprobar. Finalmente, tendremos otra hoja de trucos gratis.

Ahora, antes de sumergirnos, también puede obtener una hoja de trucos en PDF GRATUITA sobre este artículo completando el formulario de suscripción a continuación.

[ID de formulario de envío de pulso =”12097″]

¿Listo? ¡Genial!

Sintaxis de consulta MySQL INSERT INTO (constructores de valores de tabla)

Pero antes de profundizar en los detalles, aclaremos algunas cosas:

  • La versión de MySQL que estoy usando aquí es la 8.0.23, con el motor de almacenamiento InnoDB.
  • La versión de SQL Server es 2019.

Primero, intentemos insertar un registro en una tabla. La sintaxis básica es similar a la de SQL Server. Sin embargo, lo es si no incluye la base de datos y el nombre del esquema y no encierra los nombres de las columnas con acentos graves.

CREATE TABLE testdatabase.people
(`ID` int NOT NULL PRIMARY KEY,
 `Lastname` varchar(50) NOT NULL,
 `FirstName` varchar(50) NOT NULL,
 `MiddleName` varchar(50) NULL DEFAULT '',
 `Rank` varchar(20) NOT NULL,
 `Ship` varchar(50) NOT NULL,
 `ShipRegistry` varchar(20) NOT NULL,
 `ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP());
  
INSERT INTO people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

Especificar la ubicación real de la mesa será ligeramente diferente. Como he indicado en este post, una base de datos es sinónimo de un esquema en MySQL. Consulte la muestra modificada a continuación:

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

¿Has notado la ausencia del nombre del esquema anterior?

Mientras tanto, la cláusula VALUES anterior forma un constructor de valores de tabla. Del mismo modo, SQL Server también tiene esa función.

Insertar varias filas en tablas en MySQL

Intentemos insertar varias filas.

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName, Rank, Ship, ShipRegistry)
VALUES (4,'Janeway','Kathryn','', Captain','USS Voyager', 'NCC-74656'), 
       (5, 'Sisko','Benjamin','','Captain','USS Defiant','NX-74205');

El código anterior insertará dos registros usando dos constructores de valores de tabla. También puede usar expresiones en lugar de valores literales. El siguiente ejemplo utiliza una subconsulta para cada columna:

CREATE TABLE testdatabase.people2 LIKE people;

INSERT INTO testdatabase.people2
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (4,'Janeway','Kathryn','','Captain','USS Voyager', 'NCC-74656'), 
       (5, (SELECT Lastname FROM people WHERE ID=5), 
           (SELECT Firstname FROM people WHERE ID=5), 
           (SELECT MiddleName FROM people WHERE ID=5),
           (SELECT `Rank` FROM people WHERE ID=5),
           (SELECT Ship FROM people WHERE ID=5),
           (SELECT ShipRegistry FROM people WHERE ID=5));

Las subconsultas parecen redundantes en la consulta anterior. Pero esto generará un error:

INSERT INTO testdatabase.people2
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (4,'Janeway','Kathryn','','Captain','USS Voyager', 'NCC-74656'), 
       (SELECT `ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, 
        `Ship`, `ShipRegistry` FROM people);    -- ERROR!

El constructor de valores de tabla espera un literal o una expresión para cada campo en la lista de columnas. Además, las subconsultas del ejemplo anterior devuelven una sola fila con un valor, y eso es válido. Sin embargo, la declaración SELECT anterior generará un error porque devuelve varias filas y columnas.

Otra opción es especificar la palabra clave ROW como en el siguiente ejemplo:

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName, Rank, Ship, ShipRegistry)
VALUES ROW(4,'Janeway','Kathryn','', Captain','USS Voyager', 'NCC-74656'), 
       ROW(5, 'Sisko','Benjamin','','Captain','USS Defiant','NX-74205');

Pero la palabra clave ROW en la instrucción INSERT no se admite en SQL Server.

MySQL INSERT INTO con SELECT de otra tabla

Puede agregar registros a una tabla usando la declaración SELECT:

INSERT INTO people2
(ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry)
SELECT ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry FROM people;

Como puede ver, es lo mismo con T-SQL sin el nombre de la base de datos, el nombre del esquema y el carácter de acento grave. Rango es una palabra reservada, por cierto.

Por lo tanto, los caracteres de acento grave que encierran la palabra Rango son obligatorios.

Puede expresarlo sin la lista de columnas. Simplemente especifique los nombres de las columnas en la misma secuencia que la disposición de las columnas de la tabla de destino.

TRUNCATE TABLE testdatabase.people2;

INSERT INTO testdatabase.people2
SELECT ID, Lastname, FirstName, MiddleName, `Rank`, Ship, ShipRegistry, ModifiedDate 
FROM people;

SELECT * FROM testdatabase.people2

Vea el resultado a continuación de dbForge Studio para MySQL:

¿Suena bien? Ampliemos más el tema del manejo de valores de columna.

INSERT y valores de columna de tablas

Esta sección profundizará en los valores de columna al usar MySQL INSERT. Hay cuatro de ellos:

  • Valores Unicode.
  • Valores predeterminados.
  • Usando autoincremento.
  • Valores de las variables definidas por el usuario.

Insertar cadena Unicode

En T-SQL, está familiarizado con preceder un valor de cadena con N . Al usar eso, SQL Server asume que el valor es un valor Unicode. En MySQL, no necesitas eso.

Mira el siguiente ejemplo:

CREATE TABLE IF NOT EXISTS UnicodeNames
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 FullName varchar(50) NOT NULL);

INSERT INTO UnicodeNames
(FullName)
VALUES ('김지수'),('김제니'),('박채영'),('ลลิษา มโนบาล');

SELECT * FROM UnicodeNames

Hay algunos puntos a tener en cuenta:

  1. Usar NVARCHAR para crear una tabla en MySQL 8 cambiará automáticamente a VARCHAR.
  2. No es necesario anteponer N al valor Unicode. , como N'김지수'.
  3. Debe editar un poco el código anterior para que se ejecute correctamente en SQL Server.

Compruebe el resultado a continuación:

Aquí está el código equivalente en T-SQL:

CREATE TABLE UnicodeNames
(ID int NOT NULL IDENTITY PRIMARY KEY,
 FullName nvarchar(50) NOT NULL);

INSERT INTO UnicodeNames
(FullName)
VALUES (N'김지수'),(N'김제니'),(N'박채영'),(N'ลลิษา มโนบาล');

SELECT * FROM UnicodeNames

Intente eliminar la 'N' de uno de los valores Unicode anteriores. El código funcionará bien, pero verifique el resultado a continuación en SQL Server Management Studio:

Cómo insertar un valor predeterminado en MySQL

Los valores predeterminados de la columna actúan cuando inserta un registro sin especificar un valor. Lo usamos en el primer ejemplo anterior. Aquí está la definición de la columna de nuevo:


`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

La columna ModifiedDate por defecto a la fecha y hora actual en el servidor. Es por eso que cuando hicimos esto:

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`)
VALUES (3,'Archer','Jonathan','','Captain','Enterprise','NX-01');

El resultado es este:

Muy ordenado y ahorro en pulsaciones de teclas. Este mismo comportamiento también ocurre en SQL Server.

Mientras tanto, si desea hacerlo explícito, simplemente especifique el nombre de la columna con un valor DEFAULT:

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`, `ModifiedDate`)
VALUES (6, 'Pyke','Christopher','','Captain','USS Enterprise','NCC 1701', DEFAULT);

También funciona en SQL Server con una ligera modificación.

Hay otro ahorro de tiempo y pulsaciones de teclas. Tiene un valor de columna de incremento automático.

INSERTAR en Columna AUTO_INCREMENT

En lugar de obtener el último valor entero de una tabla y sumar 1, es mejor definir una columna de incremento automático. es bueno para claves primarias. Hicimos eso en el ejemplo de la tabla Unicode.

Aquí hay una parte de él nuevamente:

CREATE TABLE IF NOT EXISTS UnicodeNames
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 FullName varchar(50) NOT NULL);

Mientras tanto, en SQL Server usamos la palabra clave IDENTITY en lugar de AUTO_INCREMENT.

La figura 2 revela el resultado de definir una columna de autoincremento. Los valores enteros se generaron sin especificarlo en la sentencia INSERT.

Uso de variables definidas por el usuario para establecer valores de columna

Otro caso común para insertar registros en T-SQL es aplicar variables definidas por el usuario para establecer valores de columna. Es útil para crear scripts ad-hoc y procedimientos almacenados.

Pero primero, la definición de variables en MySQL se puede hacer usando SET. A diferencia de SQL Server, usa DECLARE. Echa un vistazo al ejemplo:

SET @stringValue = 'string value';
SET @numericValue = 1287;
SET @booleanValue = TRUE;
SET @dateValue = CURRENT_DATE();

CREATE TABLE IF NOT EXISTS TableDataTypeValues
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 stringValue varchar(50) NOT NULL,
 numericValue int NOT NULL,
 BooleanValue bit not NULL DEFAULT FALSE,
 dateValue date NULL);

INSERT INTO TableDataTypeValues
(stringValue, numericValue, BooleanValue, dateValue)
VALUES (@stringValue, @numericValue, @booleanValue, @dateValue);

Como puede ver arriba, las variables actúan como expresiones para llenar los valores de la columna en la cláusula VALUES.

Insertar en tabla temporal en MySQL

Aquí, revisamos el uso de MySQL INSERT en tablas temporales. Los desarrolladores de T-SQL están familiarizados con el '# ‘símbolo que precede al nombre de una tabla temporal. En MySQL, las tablas temporales se crean usando CREATE TEMPORARY TABLE table_name . No tiene el '# ' símbolo. Por lo tanto, entre las líneas de su secuencia de comandos, el nombre de una tabla temporal puede tener el mismo aspecto que los nombres de tablas normales:

CREATE TEMPORARY TABLE tmpkpopgroup
(ID int NOT NULL PRIMARY KEY AUTO_INCREMENT,
 GroupName varchar(50) NOT NULL,
 ModifiedDate datetime DEFAULT CURRENT_TIMESTAMP());

INSERT INTO tmpkpopgroup
(GroupName)
VALUES ('BTS'),('SEVENTEEN'),('TWICE'),('MOMOLAND'),('GIRLS GENERATION'),('BLACKPINK'),('OH MY GIRL'),('RED VELVET');

SELECT * FROM tmpkpopgroup
ORDER BY GroupName;

En otras palabras, la inserción de registros en tablas temporales tiene el mismo aspecto que las tablas normales.

Aquí está el resultado:

INSERCIÓN de MySQL… EN ACTUALIZACIÓN DE CLAVE DUPLICADA:sintaxis no admitida en T-SQL

Finalmente, MySQL INSERT tiene casos de sintaxis no admitidos en T-SQL. Uno de ellos es INSERTAR… EN ACTUALIZACIÓN DE CLAVE DUPLICADA. ¿Qué puede hacer?

Cuando una tabla tiene una clave única y usted inserta un valor que causará un duplicado, INSERTAR fallará. Sin embargo, cuando usa INSERTAR… EN LA ACTUALIZACIÓN DE CLAVE DUPLICADA, se producirá una actualización de la fila existente en su lugar. El error no ocurrirá.

Digamos que tenemos estos registros en personas tabla:

Fíjese en el valor del registro del barco en el recuadro rojo y en toda esa línea. El caso es que vamos a insertar el mismo registro con ON DUPLICATE KEY UPDATE.

Ahora, activemos la siguiente declaración:

INSERT INTO testdatabase.people
(`ID`, `LastName`, `FirstName`, `MiddleName`, `Rank`, `Ship`, `ShipRegistry`, `ModifiedDate`)
VALUES (5, 'Sisko','Benjamin','','Captain','USS Defiant','NCC-75633', DEFAULT)
ON DUPLICATE KEY UPDATE ShipRegistry = 'NCC-75633';

SELECT * FROM testdatabase.people;

¿Hay un error? ¡Vamos a comprobarlo!

Genial, ¿no?

El mismo efecto ocurre cuando haces esto:

UPDATE people 
SET ShipRegistry = 'NCC-75633'
WHERE ID = 5

Mientras tanto, puede expresar la intención en T-SQL así:

IF EXISTS(SELECT id FROM people WHERE id = 5)
	UPDATE people 
	SET ShipRegistry = 'NCC-75633'
	WHERE ID = 5
ELSE
	INSERT INTO people
	(ID, LastName, FirstName, MiddleName, [Rank], Ship, ShipRegistry, ModifiedDate)
	VALUES (5, 'Sisko','Benjamin','','Captain','USS Defiant','NCC-75633', DEFAULT);

Ocurrirá el mismo resultado.

Conclusión

Benjamin Franklin dijo una vez:“Una inversión en conocimiento siempre paga el mejor interés”. Espero que este artículo te resulte útil con el tiempo.

Hagamos un resumen:

  1. La sintaxis básica de MySQL INSERT es casi la misma en T-SQL excepto por la ausencia del nombre del esquema y el uso de acentos graves.
  2. Insertar registros en MySQL desde otra tabla es casi lo mismo que en T-SQL.
  3. Los valores de columna se manejan de manera diferente en MySQL INSERT. Los valores Unicode son los más notables. Además, la sintaxis es diferente en el uso de AUTO_INCREMENT.
  4. Insertar registros en una tabla temporal en MySQL tiene una pequeña diferencia en T-SQL con el '# ' símbolo.
  5. INSERT…ON DUPLICATE KEY UPDATE se ve bien al acortar la sintaxis para evitar errores duplicados.

Espero que el artículo te haya resultado útil mientras aprendes MySQL. Si te gusta esta publicación, ¡compártela en tus plataformas de redes sociales favoritas!