Comando de inserção do MySQL vs sintaxe de consulta T-SQL com exemplos

Os desenvolvedores são estudantes ao longo da vida. Ganhar novos conhecimentos o mais rápido que pudermos é sempre o nosso objetivo. Se você vem do campo T-SQL, qual é a maneira mais rápida de aprender MySQL? Muitas vezes você quer comparar sintaxes. Da última vez, você aprendeu sobre como criar uma tabela no MySQL. Nosso post de hoje vai te levar um passo adiante. Vamos inserir registros com MySQL INSERT.

Quão fácil pode ser? Ambas as plataformas de banco de dados usam SQL, mas sabemos que esses dois produtos de banco de dados têm suas poucas adições à sintaxe SQL padrão. MySQL INSERT não é exceção.

Assim, se você está cansado de comparar referências para MySQL e SQL Server, hoje é seu dia de sorte. Eu organizei a sintaxe e fiz a comparação para você. Além disso, teremos exemplos para conferir. Finalmente, teremos outra folha de dicas gratuita.

Agora, antes de mergulharmos, você também pode obter uma folha de dicas em PDF GRATUITA sobre este artigo, preenchendo o formulário de inscrição abaixo.

[id do formulário de envio=”12097″]

Preparar? Excelente!

MySQL INSERT INTO Sintaxe de consulta (construtores de valores de tabela)

Mas antes de entrarmos nos detalhes, vamos deixar algumas coisas claras:

A versão do MySQL que estou usando aqui é a 8.0.23, com o mecanismo de armazenamento InnoDB.
A versão do SQL Server é 2019.

Primeiro, vamos tentar inserir um registro em uma tabela. A sintaxe básica é semelhante à do SQL Server. No entanto, é se você não incluir o banco de dados e o nome do esquema e não incluir os nomes das colunas com 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 a localização real da tabela será um pouco diferente. Como indiquei neste post, um banco de dados é sinônimo de um esquema no MySQL. Confira a amostra modificada abaixo:

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

Você notou a ausência do nome do esquema acima?

Enquanto isso, a cláusula VALUES acima forma um construtor de valor de tabela. Da mesma forma, o SQL Server também possui esse recurso.

Inserir várias linhas em tabelas no MySQL

Vamos tentar inserir várias linhas.

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');

O código acima irá inserir dois registros usando dois construtores de valor de tabela. Você também pode usar expressões em vez de valores literais. O exemplo abaixo usa uma subconsulta para cada coluna:

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));

As subconsultas parecem redundantes na consulta acima. Mas isso irá gerar um erro:

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!

O construtor de valor de tabela espera um literal ou uma expressão para cada campo na lista de colunas. Além disso, as subconsultas no exemplo anterior retornam uma única linha com um valor, e isso é válido. No entanto, a instrução SELECT acima acionará um erro porque retorna várias linhas e colunas.

Outra opção é especificar a palavra-chave ROW como no exemplo abaixo:

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');

Mas a palavra-chave ROW na instrução INSERT não tem suporte no SQL Server.

MySQL INSERT INTO com SELECT de outra tabela

Você pode adicionar registros em uma tabela usando a instrução SELECT:

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

Como você pode ver, é o mesmo com o T-SQL sem o nome do banco de dados, o nome do esquema e o caractere de backtick. Rank é uma palavra reservada, a propósito.

Portanto, os caracteres backtick que envolvem a palavra Rank são obrigatórios.

Você pode expressá-lo sem a lista de colunas. Basta especificar os nomes das colunas na mesma sequência da disposição das colunas da tabela 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

Veja a saída abaixo do dbForge Studio para MySQL:

Soa bem? Vamos expandir mais sobre o tópico de manipulação de valores de coluna.

Valores das colunas INSERIR e tabelas

Esta seção aprofundará os valores das colunas ao usar o MySQL INSERT. Há quatro deles:

Valores Unicode.
Valores padrão.
Usando incremento automático.
Valores das variáveis definidas pelo usuário.

Inserir string Unicode

No T-SQL, você está familiarizado com a precedência de um valor de string com N . Ao usar isso, o SQL Server assume que o valor é um valor Unicode. No MySQL, você não precisa disso.

Confira o exemplo abaixo:

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

Existem alguns pontos a serem observados:

O uso de NVARCHAR na criação de uma tabela no MySQL 8 será alterado automaticamente para VARCHAR.
Não há necessidade de preceder o valor Unicode com N , como N'김지수'.
Você precisa editar um pouco o código acima para que ele seja executado com sucesso no SQL Server.

Confira o resultado abaixo:

Aqui está o código equivalente em 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

Tente remover o 'N' de um dos valores Unicode acima. O código funcionará bem, mas você verifica a saída abaixo no SQL Server Management Studio:

Como inserir valor padrão no MySQL

Os valores padrão da coluna atuam quando você insere um registro sem especificar um valor. Usamos isso no primeiro exemplo acima. Aqui está a definição da coluna novamente:


`ModifiedDate` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP()

A coluna ModifiedDate padrão para a data e hora atuais no servidor. É por isso que quando fizemos isso:

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

O resultado é este:

Muito limpo e economizando em pressionamentos de tecla. Esse mesmo comportamento também acontece no SQL Server.

Enquanto isso, se você quiser torná-lo explícito, basta especificar o nome da coluna com um valor DEFAULT:

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

Também funciona no SQL Server com uma pequena modificação.

Há outro protetor de tempo e pressionamento de tecla. Ele está tendo um valor de coluna de incremento automático.

INSERIR em Coluna AUTO_INCREMENT

Em vez de obter o último valor inteiro em uma tabela e adicionar 1, é melhor definir uma coluna de incremento automático. é bom para chaves primárias. Fizemos isso no exemplo da tabela Unicode.

Aqui está uma parte dele novamente:

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

Enquanto isso, no SQL Server, usamos a palavra-chave IDENTITY em vez de AUTO_INCREMENT.

A Figura 2 revela o resultado da definição de uma coluna de incremento automático. Os valores inteiros foram gerados sem especificá-los na instrução INSERT.

Usando variáveis definidas pelo usuário para definir valores de coluna

Outro caso comum para inserir registros no T-SQL é aplicar variáveis definidas pelo usuário para definir valores de coluna. É útil para criar scripts ad-hoc e procedimentos armazenados.

Mas primeiro, definir variáveis no MySQL pode ser feito usando SET. Ao contrário do SQL Server, você usa DECLARE. Dê uma olhada no exemplo:

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 você pode ver acima, as variáveis atuam como expressões para preencher os valores das colunas na cláusula VALUES.

Inserir na tabela temporária no MySQL

Aqui, revisamos o uso do MySQL INSERT em tabelas temporárias. Os desenvolvedores de T-SQL estão familiarizados com o '# ‘ símbolo que precede um nome de tabela temporária. No MySQL, as tabelas temporárias são criadas usando CREATE TEMPORARY TABLE table_name . Ele não tem o '# ‘símbolo. Portanto, entre as linhas do seu script, um nome de tabela temporária pode parecer o mesmo que nomes de tabelas regulares:

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;

Em outras palavras, a inserção de registros em tabelas temporárias tem a mesma aparência de tabelas regulares.

Aqui está o resultado:

MySQL INSERT…ON DUPLICATE KEY UPDATE – Sintaxe não suportada em T-SQL

Finalmente, MySQL INSERT tem casos de sintaxe não suportados em T-SQL. Um deles é INSERT…ON DUPLICATE KEY UPDATE. O que é que isso pode fazer?

Quando uma tabela tem uma chave exclusiva e você insere um valor que causará uma duplicata, o INSERT falhará. No entanto, quando você usar INSERT…ON DUPLICATE KEY UPDATE, ocorrerá uma atualização da linha existente. O erro não ocorrerá.

Digamos que temos esses registros nas pessoas tabela:

Observe o valor do registro do navio em vermelho e toda a linha. O problema é que vamos inserir o mesmo registro com ON DUPLICATE KEY UPDATE.

Agora, vamos disparar a declaração abaixo:

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;

Existe um erro? Vamos verificar!

Legal, não é?

O mesmo efeito acontece quando você faz isso:

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

Enquanto isso, você pode expressar a intenção em T-SQL assim:

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);

O mesmo resultado ocorrerá.

Conclusão

Benjamin Franklin disse uma vez:“Um investimento em conhecimento sempre rende os melhores juros”. Espero que este artigo seja recompensado com o tempo.

Vamos recapitular:

A sintaxe básica do MySQL INSERT é quase a mesma no T-SQL, exceto pela ausência do nome do esquema e pelo uso de acentos graves.
Inserir registros no MySQL de outra tabela é quase o mesmo que no T-SQL.
Os valores das colunas são tratados de forma diferente no MySQL INSERT. Os valores Unicode são os mais notáveis. Além disso, a sintaxe é diferente no uso de AUTO_INCREMENT.
A inserção de registros em uma tabela temporária no MySQL tem uma pequena diferença no T-SQL com o '# ‘ símbolo.
INSERT…ON DUPLICATE KEY UPDATE parece bom para encurtar a sintaxe para evitar erros duplicados.

Espero que o artigo tenha sido útil para você enquanto você está aprendendo MySQL. Se você gostou deste post, compartilhe-o em suas redes sociais favoritas!