CREATE TABLE MySQL vs T-SQL com exemplos de sintaxe

Você é um desenvolvedor T-SQL aprendendo o básico do MySQL? Então, uma das coisas que você pode querer aprender é a instrução MySQL CREATE TABLE. Além disso, a maneira mais rápida de aprender uma nova plataforma de banco de dados SQL é comparando sua funcionalidade e sintaxe comuns.

É isso que vamos fazer hoje. Mas a sintaxe completa é muito. Portanto, abordaremos apenas 5 pontos básicos para colocá-lo em funcionamento com o comando MySQL CREATE TABLE.

No entanto, antes de prosseguirmos, vamos esclarecer alguns pontos:

A versão do MySQL usada aqui é o MySQL 8 usando o mecanismo de armazenamento InnoDB.
A versão do SQL Server usada aqui é o SQL Server 2019.

Soa bem? Vamos começar.

Criar instrução de tabela em MySQL e T-SQL

Vamos começar a comparação definindo o nome da tabela.

Uma das diferenças de sintaxe notáveis no MySQL CREATE TABLE é a ausência de um nome de esquema. Veja como vai:

CREATE TABLE database_name.table_name

Você notou o nome da tabela precedido pelo nome do banco de dados? Agora, aqui está um formato equivalente de T-SQL com o qual você está familiarizado:


CREATE TABLE database_name.schema_name.table_name

Por quê? Porque no MySQL, um esquema é sinônimo de um banco de dados. Os nomes do banco de dados e do esquema são opcionais. No entanto, se você precisar criar uma tabela em outro banco de dados no mesmo script, isso é obrigatório.

Está certo. O uso de colchetes em nomes de tabelas e colunas acionará um erro no MySQL. Você deve usar um par de acentos graves para incluir identificadores. A Figura 1 mostra onde você o encontra em um layout de teclado americano:

Agora, confira a amostra:

-- MySQL CREATE TABLE

CREATE TABLE `testdatabase`.`person` (
  `BusinessEntityID` INT NOT NULL,
  `PersonType` NCHAR(2) NOT NULL,
  `Title` VARCHAR(8) NULL,
  `FirstName` NVARCHAR(50) NOT NULL,
  `MiddleName` VARCHAR(50) NULL,
  `LastName` VARCHAR(50) NOT NULL,
  `Suffix` NVARCHAR(10) NULL,
  `EmailPromotion` INT NOT NULL,
  `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
  PRIMARY KEY (`BusinessEntityID`));

No exemplo de código acima, os identificadores de nome de tabela e coluna são colocados entre acentos graves. Se você não está acostumado a incluir nomes de tabelas e colunas com isso, confie em mim, você não está sozinho.

Verifique o código equivalente em T-SQL abaixo:

-- T-SQL CREATE TABLE
CREATE TABLE [testdatabase].[dbo].[Person](
	[BusinessEntityID] [int] NOT NULL,
	[PersonType] [nchar](2) NOT NULL,
	[Title] [nvarchar](8) NULL,
	[FirstName] [nvarchar](50) NOT NULL,
	[MiddleName] [nvarchar](50) NULL,
	[LastName] [nvarchar](50) NOT NULL,
	[Suffix] [nvarchar](10) NULL,
	[EmailPromotion] [int] NOT NULL,
	[ModifiedDate] [datetime] NOT NULL DEFAULT GETDATE(),
 CONSTRAINT [PK_Person_BusinessEntityID] PRIMARY KEY  
  (
	[BusinessEntityID] ASC
  )
) ON [PRIMARY]

Claro, você não precisa incluir esses identificadores. Mas se você usar palavras de reserva ou espaço em nomes de tabelas ou colunas, ocorrerá um erro.

Como Criar tabela temporária

Gosta de mesas temporárias? Então o MySQL permitirá que você digite mais para definir uma tabela temporária. Confira a amostra:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Enquanto isso, os codificadores T-SQL são usados para o # símbolo antes do nome da tabela. Veja o código equivalente do acima:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Terminamos com as definições e os nomes das tabelas. Vamos prosseguir com as definições de coluna.

Sintaxe da coluna MySQL

Você não pode ter uma tabela SQL básica sem colunas. Então, quais semelhanças e diferenças existem entre o MySQL e o SQL Server?

Nomes de coluna e tipos de dados

Você já sabe sobre os backticks. Qualquer outra coisa básica sobre nomes de colunas e tipos de dados é a mesma no MySQL e no T-SQL. Veja a amostra abaixo:

CREATE TABLE `testdatabase`.`people`
(
    `ID` INT,
    `LastName` VARCHAR(50),
    ...
);

No entanto, há mais.

Anulabilidade da coluna

As colunas podem ser anuláveis ou não. Você pode fazer isso adicionando NULL ou NOT NULL na definição da coluna.

Vamos expandir nosso exemplo anterior.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     ...
);

É praticamente o mesmo que T-SQL. E os valores padrão?

Valores padrão da coluna

A seguir estão os valores padrão da coluna. Eles são úteis quando você insere um registro, mas não especifica um valor específico para uma coluna. Vamos expandir nosso exemplo anterior um pouco mais:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     ...
);

A ModifiedDate A coluna assume como padrão a data e hora atuais do sistema. Se você fizer um INSERT nesta tabela como a abaixo, sempre haverá um valor para ModifiedDate .

INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');

Funciona como esperado após o INSERT. Aqui está uma captura de tela do dbForge Studio para MySQL:

MySQL cria tabela com chaves primárias, estrangeiras e exclusivas

Como em qualquer plataforma SQL, você pode definir regras nos dados da coluna da tabela usando restrições no MySQL. Como isso é importante para o design da tabela, precisamos considerar este próximo ponto.

Um desenvolvedor T-SQL deve se sentir em casa com chaves primárias, chaves estrangeiras e chaves exclusivas do MySQL.

Chave primária

Você pode definir uma ou mais colunas para serem a chave primária. A sintaxe é quase a mesma do SQL Server. Alguma exceção? Sim. É o uso de índices clusterizados e não clusterizados. Mas vamos reservar a discussão desta na próxima seção.

Por enquanto, focamos na sintaxe das chaves primárias. Aqui está o mesmo exemplo que tivemos anteriormente, mas adicionamos a coluna ID como a chave primária:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NULL,
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW()
);

Fácil, não é?

Mas e se você precisar de várias colunas? Como no T-SQL, você tem 2 opções. Confira os exemplos abaixo:

-- OPTION 1: Let MySQL generate the constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
     PRIMARY KEY (`LastName`,`FirstName`,`MiddleName`)
);

-- OPTION 2: Specify your constraint name

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `pk_name` PRIMARY KEY (`LastName`, `FirstName`, `MiddleName`)
);

É isso para chaves primárias.

Chave estrangeira

Outra restrição importante é a chave estrangeira. Isso é usado para fazer referência cruzada de uma tabela para outra tabela:

CREATE TABLE `testdatabase`.`address`
(
    `ID` int NOT NULL PRIMARY KEY,
    `parent_id` int NOT NULL,
    `full_address` varchar(100) NOT NULL,
    CONSTRAINT `FK_address_parent_id` FOREIGN KEY (`parent_id`)
    REFERENCES `people` (`ID`)
);

Você viu a semelhança com o T-SQL?

Chave exclusiva

Às vezes, você quer ter certeza de que os dados inseridos em uma tabela são exclusivos. O MySQL também suporta chaves exclusivas. Aqui está um exemplo:

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `PK_people_id` PRIMARY KEY (`ID`),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)

);

O código acima garantirá que apenas nomes exclusivos sejam adicionados à tabela.

Criar exemplos de índice de tabela (em cluster e não em cluster)

Nos exemplos anteriores, você viu as chaves primárias e secundárias criadas. Mas onde estão os índices clusterizados e não clusterizados? Isso é perceptível porque no SQL Server você especifica explicitamente a palavra-chave CLUSTERED para criar um índice clusterizado.

A parte interessante é que o MySQL não possui palavras-chave CLUSTERED ou NONCLUSTERED. Como você cria índices clusterizados?

Simples. Basta especificar a(s) coluna(s) como a chave primária e o mecanismo de armazenamento InnoDB fará disso um índice clusterizado. No exemplo abaixo, ID é a chave primária E o índice clusterizado.

CREATE TABLE `testdatabase`.`people`
(
     `ID` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `LastName` VARCHAR(50) NOT NULL,
     `FirstName` VARCHAR(50) NOT NULL,
     `MiddleName` VARCHAR(50) NOT NULL DEFAULT '',
     `ModifiedDate` DATETIME NOT NULL DEFAULT NOW(),
    CONSTRAINT `IDX_name` UNIQUE KEY (`LastName`,`FirstName`,`MiddleName`)
);

Se você não especificar uma chave primária, qualquer índice exclusivo será usado como índice clusterizado.

Então, novamente, se você não tiver uma chave primária e um índice exclusivo, o InnoDB cria um índice clusterizado oculto. Confira a prova aqui.

A próxima pergunta é:que tal um índice não clusterizado?

Se você já tiver uma chave primária como índice clusterizado, quaisquer outros índices serão não clusterizados ou secundários. Além disso, você só pode ter um índice clusterizado.

A próxima seção discutirá uma sintaxe única para MySQL CREATE TABLE não encontrada em T-SQL.

Clonagem de tabela MySQL e sintaxe de cópia

Vamos discutir a clonagem de tabelas. Podemos fazer isso no MySQL CREATE TABLE. Em seguida, mostraremos o equivalente T-SQL.

O exemplo abaixo cria a tabela com a mesma estrutura da primeira tabela usando CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Acabamos de clonar as pessoas tabela em pessoas2 . No entanto, é apenas a estrutura das pessoas tabela que foi copiada, não os dados. Também copiou as principais restrições e índices da tabela original. Bastante útil, se você me perguntar.

O equivalente T-SQL mais próximo é este:

-- T-SQL way of cloning a table. The indexes & key constraints are not included, 
-- though

SELECT * INTO people2
FROM people
WHERE 1=0     -- this will cause the SELECT to return an empty result set.

Mas e se você quiser os dados? Então, CREATE TABLE…SELECT é a resposta:

CREATE TABLE `people3` AS
SELECT * FROM `people`;

Quaisquer que sejam os dados nas pessoas tabela, ela será copiada para o people3 tabela. No entanto, esse comando não incluirá índices e restrições.

Agora, o equivalente T-SQL mais próximo é este:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Conclusão

Espero que os pontos acima possam ajudá-lo a usar o MySQL CREATE TABLE da perspectiva de um desenvolvedor SQL Server T-SQL.

Alguns de vocês preferirão usar ferramentas gráficas. Mas mais tarde, você se encontrará procurando uma referência quando precisar criar tabelas de trabalho em seus procedimentos armazenados ou scripts ad-hoc. Ou você é simplesmente do tipo que busca mais controle digitando tudo. Em qualquer caso, um balcão único comparando a sintaxe básica pode ser um salva-vidas.

Se você gostou deste artigo, sinta-se à vontade para compartilhá-lo em suas redes sociais favoritas.

Boa codificação a todos.