OPRET TABEL MySQL vs T-SQL med syntakseksempler

Er du en T-SQL-udvikler, der lærer det grundlæggende i MySQL? Så er en af de ting, du måske vil lære, MySQL CREATE TABLE-sætning. Desuden er den hurtigste måde at lære en ny SQL-databaseplatform på ved at sammenligne dens almindelige funktionalitet og syntaks.

Det er det, vi skal gøre i dag. Men den fulde syntaks er meget. Så vi vil kun dække 5 grundlæggende punkter for at få dig i gang med MySQL CREATE TABLE-kommandoen.

Men før vi fortsætter, lad os præcisere et par punkter:

MySQL-versionen, der bruges her, er MySQL 8, der bruger InnoDB-lagringsmotoren.
SQL Server-versionen, der bruges her, er SQL Server 2019.

Lyder godt? Lad os begynde.

Opret tabelerklæring i MySQL og T-SQL

Lad os starte sammenligningen med at definere tabelnavnet.

En af de mærkbare syntaksforskelle i MySQL CREATE TABLE er fraværet af et skemanavn. Sådan går det:

CREATE TABLE database_name.table_name

Har du bemærket tabelnavnet foran databasenavnet? Nu, her er et T-SQL-ækvivalent format, du er bekendt med:


CREATE TABLE database_name.schema_name.table_name

Hvorfor? For i MySQL er et skema synonymt med en database. Database- og skemanavnene er valgfrie. Men hvis du har brug for at oprette en tabel i en anden database i samme script, er dette et must.

Det er rigtigt. Brug af firkantede parenteser i tabel- og kolonnenavne vil udløse en fejl i MySQL. Du bør bruge et par backticks til at omslutte identifikatorer i stedet. Figur 1 viser, hvor du finder det på et amerikansk tastaturlayout:

Tjek nu prøven:

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

Fra kodeeksemplet ovenfor er tabel- og kolonnenavne-id'er omgivet af backticks. Hvis du ikke er vant til at omslutte tabel- og kolonnenavne med dette, så tro mig, du er ikke alene.

Tjek den tilsvarende kode i T-SQL nedenfor:

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

Du behøver selvfølgelig ikke at vedlægge disse identifikatorer. Men hvis du bruger reserveord eller mellemrum i tabel- eller kolonnenavne, vil der opstå en fejl.

Sådan Opret en midlertidig tabel

Er du vild med midlertidige borde? Så vil MySQL lade dig skrive mere for at definere en midlertidig tabel. Se prøven:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

I mellemtiden bruges T-SQL-kodere til # symbol før tabelnavnet. Se den tilsvarende kode fra ovenstående:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Vi er færdige med tabeldefinitioner og navne. Lad os fortsætte med kolonnedefinitioner.

MySQL-kolonnesyntaks

Du kan ikke have en grundlæggende SQL-tabel uden kolonner. Så hvilke ligheder og forskelle er der mellem MySQL og SQL Server?

Kolonnenavne og datatyper

Du kender allerede til backticks. Alt andet grundlæggende om kolonnenavne og datatyper er det samme i MySQL og T-SQL. Se eksemplet nedenfor:

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

Der er dog mere.

Kolonnens nulstilling

Kolonner kan være nullable eller ej. Du kan gøre det ved at tilføje NULL eller NOT NULL i kolonnedefinitionen.

Lad os udvide vores tidligere eksempel.

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

Det er stort set det samme som T-SQL. Hvad med standardværdier?

Kolonnestandardværdier

Næste er kolonnens standardværdier. Disse er praktiske, når du indsætter en post, men ikke har angivet en specifik værdi for en kolonne. Lad os udvide vores tidligere eksempel mere:

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

ModifiedDate kolonnen er som standard den aktuelle systemdato og -klokkeslæt. Hvis du laver en INSERT på denne tabel som den nedenfor, vil der altid være en værdi for ModifiedDate .

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

Det virker som forventet efter INSERT. Her er et skærmbillede fra dbForge Studio til MySQL:

MySQL-opret tabel med primære, fremmede og unikke nøgler

Som i enhver SQL-platform kan du definere regler for tabelkolonnedata ved hjælp af begrænsninger i MySQL. Da dette er vigtigt for borddesign, skal vi overveje dette næste punkt.

En T-SQL-udvikler skal føle sig hjemme med MySQL-primære nøgler, fremmednøgler og unikke nøgler.

Primær nøgle

Du kan definere en eller flere kolonner til at være den primære nøgle. Syntaksen er næsten den samme som i SQL Server. Nogle undtagelser? Ja. Det er brugen af klyngede og ikke-klyngede indekser. Men lad os reservere diskussionen om denne i næste afsnit.

For nu fokuserer vi på syntaksen af primære nøgler. Her er det samme eksempel, som vi havde tidligere, men vi tilføjer ID-kolonnen som den primære nøgle:

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

Nemt, ikke?

Men hvad hvis du har brug for flere kolonner? Ligesom i T-SQL har du 2 muligheder. Tjek eksemplerne nedenfor:

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

Det er det for primære nøgler.

Udenlandsk nøgle

En anden vigtig begrænsning er fremmednøglen. Dette bruges til at krydshenvise en tabel til en anden tabel:

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

Så du ligheden med T-SQL?

Unik nøgle

Nogle gange vil du gerne sikre dig, at de data, der er indsat i en tabel, er unikke. MySQL understøtter også unikke nøgler. Her er et eksempel:

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

);

Ovenstående kode vil sikre, at kun unikke navne vil blive tilføjet til tabellen.

Opret tabelindekseksempler (klyngede og ikke-klyngede)

I de foregående eksempler har du set primære og sekundære nøgler oprettet. Men hvor er klyngede og ikke-klyngede indekser? Det er bemærkelsesværdigt, fordi du i SQL Server udtrykkeligt angiver nøgleordet CLUSTERED for at lave et klynget indeks.

Den interessante del er, at MySQL ikke har CLUSTERED eller IKKE-CLUSTERED søgeord. Hvordan opretter du klyngede indekser?

Enkel. Angiv blot kolonnen/kolonnerne som den primære nøgle, og InnoDB-lagringsmotoren vil gøre det til et klynget indeks. I eksemplet nedenfor, ID er den primære nøgle OG det klyngede indeks.

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

Hvis du ikke angiver en primær nøgle, vil ethvert unikt indeks blive brugt som det klyngede indeks.

Så igen, hvis du ikke har en primær nøgle og et unikt indeks, opretter InnoDB et skjult klynget indeks. Tjek beviset her.

Det næste spørgsmål er, hvad med et ikke-klynget indeks?

Hvis du allerede har en primær nøgle som et klynget indeks, vil alle andre indekser være ikke-klyngede eller sekundære. Desuden kan du kun have ét klynget indeks.

Det næste afsnit vil diskutere en unik syntaks for MySQL CREATE TABLE, der ikke findes i T-SQL.

MySQL-tabelkloning og -kopieringssyntaks

Lad os diskutere bordkloning. Vi kan gøre det i MySQL CREATE TABLE. Derefter vil vi vise T-SQL-ækvivalenten.

Eksemplet nedenfor opretter tabellen med samme struktur som den første tabel ved hjælp af CREATE TABLE...LIKE.

CREATE TABLE `people2` LIKE `people`

Vi har lige klonet folket tabel ind i personer2 . Det er dog kun strukturen af folket tabel, der er blevet kopieret, ikke dataene. Den kopierede også de vigtigste begrænsninger og indekser i den originale tabel. Ganske praktisk, hvis du spørger mig.

Den nærmeste T-SQL-ækvivalent er denne:

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

Men hvad hvis du vil have dataene? Så, CREATE TABLE...SELECT er svaret:

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

Uanset hvilke data der er i mennesket tabellen, vil den blive kopieret til people3 bord. Denne kommando vil dog ikke inkludere indekser og begrænsninger.

Nu er den nærmeste T-SQL-ækvivalent dette:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Konklusion

Jeg håber, at ovenstående punkter kan få dig i gang med at bruge MySQL CREATE TABLE fra en SQL Server T-SQL-udviklers perspektiv.

Nogle af jer vil foretrække at bruge grafiske værktøjer. Men senere vil du finde dig selv på udkig efter en reference, når du skal lave arbejdstabeller i dine lagrede procedurer eller ad-hoc scripts. Eller du er simpelthen typen, der søger mere kontrol ved at skrive alt. Under alle omstændigheder kan en one-stop-shop, der sammenligner den grundlæggende syntaks, være en livredder.

Hvis du kan lide denne artikel, er du velkommen til at dele den på dine foretrukne sociale medier.

God kodning, alle sammen.