Mysql
 sql >> Base de données >  >> RDS >> Mysql

CREATE TABLE MySQL vs T-SQL avec des exemples de syntaxe

Êtes-vous un développeur T-SQL apprenant les bases de MySQL ? Ensuite, l'une des choses que vous voudrez peut-être apprendre est l'instruction MySQL CREATE TABLE. En outre, le moyen le plus rapide d'apprendre une nouvelle plate-forme de base de données SQL consiste à comparer ses fonctionnalités et sa syntaxe courantes.

C'est ce que nous allons faire aujourd'hui. Mais la syntaxe complète est beaucoup. Ainsi, nous ne couvrirons que 5 points de base pour vous permettre d'être opérationnel avec la commande MySQL CREATE TABLE.

Cependant, avant de continuer, clarifions quelques points :

  1. La version de MySQL utilisée ici est MySQL 8 utilisant le moteur de stockage InnoDB.
  2. La version de SQL Server utilisée ici est SQL Server 2019.

Ça a l'air bien? Commençons.

Créer une instruction de table dans MySQL et T-SQL

Commençons la comparaison en définissant le nom de la table.

L'une des différences notables de syntaxe dans MySQL CREATE TABLE est l'absence de nom de schéma. Voici comment cela se passe :

CREATE TABLE database_name.table_name

Avez-vous remarqué le nom de la table précédé du nom de la base de données ? Maintenant, voici un format équivalent T-SQL que vous connaissez :


CREATE TABLE database_name.schema_name.table_name

Pourquoi? Parce que dans MySQL, un schéma est synonyme de base de données. Les noms de base de données et de schéma sont facultatifs. Cependant, si vous devez créer une table dans une autre base de données dans le même script, c'est indispensable.

C'est exact. L'utilisation de crochets dans les noms de table et de colonne déclenchera une erreur dans MySQL. Vous devez utiliser une paire de backticks pour encadrer les identifiants à la place. La figure 1 montre où vous le trouvez sur une disposition de clavier américain :

Maintenant, regardez l'exemple :

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

À partir de l'exemple de code ci-dessus, les identificateurs de nom de table et de colonne sont entourés de backticks. Si vous n'êtes pas habitué à entourer les noms de table et de colonne avec cela, croyez-moi, vous n'êtes pas seul.

Vérifiez le code équivalent dans T-SQL ci-dessous :

-- 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]

Bien sûr, vous n'avez pas besoin de joindre ces identifiants. Mais si vous utilisez des mots réservés ou des espaces dans les noms de table ou de colonne, une erreur se produira.

Comment Créer une table temporaire

Amateur de tables temporaires ? Ensuite, MySQL vous laissera taper plus pour définir une table temporaire. Découvrez l'exemple :

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Pendant ce temps, les codeurs T-SQL sont habitués au # symbole avant le nom de la table. Voir le code équivalent ci-dessus :


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Nous en avons fini avec les définitions et les noms de table. Passons aux définitions de colonnes.

Syntaxe des colonnes MySQL

Vous ne pouvez pas avoir une table SQL de base sans colonnes. Alors, quelles sont les similitudes et les différences entre MySQL et SQL Server ?

Noms de colonne et types de données

Vous connaissez déjà les backticks. Tout le reste de base concernant les noms de colonnes et les types de données est le même dans MySQL et T-SQL. Voir l'exemple ci-dessous :

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

Cependant, il y a plus.

Nullabilité des colonnes

Les colonnes peuvent être nullables ou non. Vous pouvez le faire en ajoutant NULL ou NOT NULL dans la définition de la colonne.

Développons notre exemple précédent.

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

C'est à peu près la même chose que T-SQL. Qu'en est-il des valeurs par défaut ?

Valeurs par défaut des colonnes

Viennent ensuite les valeurs par défaut de la colonne. Celles-ci sont pratiques lorsque vous insérez un enregistrement mais que vous n'avez pas spécifié de valeur spécifique pour une colonne. Développons un peu plus notre exemple précédent :

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(),
     ...
);

La date de modification la colonne utilise par défaut la date et l'heure actuelles du système. Si vous faites un INSERT sur cette table comme celle ci-dessous, il y aura toujours une valeur pour ModifiedDate .

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

Cela fonctionne comme prévu après l'INSERT. Voici une capture d'écran de dbForge Studio pour MySQL :

MySQL Créer une table avec des clés primaires, étrangères et uniques

Comme dans toute plate-forme SQL, vous pouvez définir des règles sur les données des colonnes de table à l'aide de contraintes dans MySQL. Comme cela est important pour la conception de la table, nous devons considérer ce point suivant.

Un développeur T-SQL doit se sentir à l'aise avec les clés primaires, les clés étrangères et les clés uniques MySQL.

Clé primaire

Vous pouvez définir une ou plusieurs colonnes comme clé primaire. La syntaxe est presque la même que dans SQL Server. Des exceptions ? Oui. C'est l'utilisation d'index clusterisés et non clusterisés. Mais réservons la discussion de celui-ci dans la section suivante.

Pour l'instant, nous nous concentrons sur la syntaxe des clés primaires. Voici le même exemple que nous avions précédemment, mais nous ajoutons la colonne ID comme clé primaire :

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

Facile, n'est-ce pas ?

Mais que se passe-t-il si vous avez besoin de plusieurs colonnes ? Comme dans T-SQL, vous avez 2 options. Vérifiez les exemples ci-dessous :

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

C'est tout pour les clés primaires.

Clé étrangère

Une autre contrainte importante est la clé étrangère. Ceci est utilisé pour croiser une table à une autre table :

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

Avez-vous vu la similitude avec T-SQL ?

Clé unique

Parfois, vous voulez vous assurer que les données insérées dans une table sont uniques. MySQL prend également en charge les clés uniques. Voici un exemple :

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

);

Le code ci-dessus garantira que seuls les noms uniques seront ajoutés au tableau.

Créer des exemples d'index de table (cluster et non cluster)

Dans les exemples précédents, vous avez vu des clés primaires et secondaires créées. Mais où sont les index clusterisés et non clusterisés ? Cela se remarque car dans SQL Server, vous spécifiez explicitement le mot-clé CLUSTERED pour créer un index clusterisé.

La partie intéressante est que MySQL n'a pas de mots-clés CLUSTERED ou NONCLUSTERED. Comment créer des index clusterisés ?

Simple. Spécifiez simplement la ou les colonnes comme clé primaire, et le moteur de stockage InnoDB en fera un index clusterisé. Dans l'exemple ci-dessous, ID est la clé primaire ET l'index clusterisé.

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

Si vous ne spécifiez pas de clé primaire, tout index unique sera utilisé comme index clusterisé.

Là encore, si vous n'avez pas de clé primaire et d'index unique, InnoDB crée un index cluster caché. Vérifiez la preuve ici.

La question suivante est, qu'en est-il d'un index non cluster ?

Si vous disposez déjà d'une clé primaire en tant qu'index clusterisé, tous les autres index seront non clusterisés ou secondaires. De plus, vous ne pouvez avoir qu'un seul index clusterisé.

La section suivante traitera d'une syntaxe unique pour MySQL CREATE TABLE introuvable dans T-SQL.

Syntaxe de clonage et de copie de table MySQL

Parlons du clonage de table. Nous pouvons le faire dans MySQL CREATE TABLE. Ensuite, nous montrerons l'équivalent T-SQL.

L'exemple ci-dessous crée la table avec la même structure que la première table en utilisant CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Nous venons de cloner les personnes table en people2 . Cependant, ce n'est que la structure des personnes table qui a été copiée, pas les données. Il a également copié les contraintes de clé et les index de la table d'origine. Assez pratique, si vous me demandez.

L'équivalent T-SQL le plus proche est celui-ci :

-- 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.

Mais que se passe-t-il si vous voulez les données ? Ensuite, CREATE TABLE…SELECT est la réponse :

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

Quelles que soient les données contenues dans les personnes table, il sera copié dans le people3 table. Cependant, cette commande n'inclura pas les index et les contraintes.

Maintenant, l'équivalent T-SQL le plus proche est celui-ci :

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Conclusion

J'espère que les points ci-dessus pourront vous aider à utiliser MySQL CREATE TABLE du point de vue d'un développeur SQL Server T-SQL.

Certains d'entre vous préféreront utiliser des outils graphiques. Mais plus tard, vous vous retrouverez à chercher une référence lorsque vous aurez besoin de créer des tables de travail dans vos procédures stockées ou vos scripts ad hoc. Ou vous êtes simplement du genre à rechercher plus de contrôle en tapant tout. Dans tous les cas, un guichet unique comparant la syntaxe de base peut sauver la vie.

Si vous aimez cet article, n'hésitez pas à le partager sur vos réseaux sociaux préférés.

Bon codage à tous.