Är du en T-SQL-utvecklare som lär dig grunderna i MySQL? Sedan är en av de saker du kanske vill lära dig MySQL CREATE TABLE-satsen. Dessutom är det snabbaste sättet att lära sig en ny SQL-databasplattform genom att jämföra dess vanliga funktionalitet och syntax.
Det är vad vi ska göra idag. Men den fullständiga syntaxen är mycket. Så vi kommer bara att täcka 5 grundläggande punkter för att komma igång med MySQL CREATE TABLE-kommandot.
Men innan vi fortsätter, låt oss förtydliga några punkter:
- MySQL-versionen som används här är MySQL 8 som använder InnoDB-lagringsmotorn.
- SQL Server-versionen som används här är SQL Server 2019.
Låter bra? Låt oss börja.
Skapa tabellutlåtande i MySQL och T-SQL
Låt oss börja jämförelsen med att definiera tabellnamnet.
En av de märkbara syntaxskillnaderna i MySQL CREATE TABLE är frånvaron av ett schemanamn. Så här går det till:
CREATE TABLE database_name.table_nameHar du märkt att tabellnamnet föregås av databasnamnet? Nu, här är ett T-SQL-likvärdigt format som du är bekant med:
CREATE TABLE database_name.schema_name.table_name
Varför? För i MySQL är ett schema synonymt med en databas. Databas- och schemanamnen är valfria. Men om du behöver skapa en tabell i en annan databas i samma skript är detta ett måste.
Det är rätt. Användning av hakparenteser i tabell- och kolumnnamn kommer att utlösa ett fel i MySQL. Du bör använda ett par backticks för att omsluta identifierare istället. Figur 1 visar var du hittar den på en amerikansk tangentbordslayout:
Kolla in provet nu:
-- 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`));
Från kodexemplet ovan är tabell- och kolumnnamnsidentifierare omgivna av backticks. Om du inte är van vid att omge tabell- och kolumnnamn med detta, tro mig, du är inte ensam.
Kontrollera motsvarande kod i T-SQL nedan:
-- 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]
Naturligtvis behöver du inte bifoga dessa identifierare. Men om du använder reservord eller mellanslag i tabell- eller kolumnnamn kommer ett fel att uppstå.
Så här Skapa en tillfällig tabell
Förtjust i tillfälliga bord? Då låter MySQL dig skriva mer för att definiera en tillfällig tabell. Kolla in provet:
-- MySQL Temporary Table
CREATE TEMPORARY TABLE `MyTempTable`
Samtidigt används T-SQL-kodare för # symbol före tabellnamnet. Se motsvarande kod från ovan:
-- T-SQL Temporary Table
CREATE TABLE #MyTempTable
Vi är klara med tabelldefinitioner och namn. Låt oss fortsätta med kolumndefinitioner.
MySQL-kolumnsyntax
Du kan inte ha en grundläggande SQL-tabell utan kolumner. Så, vilka likheter och skillnader finns det mellan MySQL och SQL Server?
Kolumnnamn och datatyper
Du vet redan om backticks. Allt annat grundläggande om kolumnnamn och datatyper är detsamma i MySQL och T-SQL. Se exemplet nedan:
CREATE TABLE `testdatabase`.`people`
(
`ID` INT,
`LastName` VARCHAR(50),
...
);
Men det finns mer.
Nullbarhet för kolumn
Kolumner kan vara nullbara eller inte. Du kan göra det genom att lägga till NULL eller NOT NULL i kolumndefinitionen.
Låt oss utöka vårt tidigare exempel.
CREATE TABLE `testdatabase`.`people`
(
`ID` INT NOT NULL,
`LastName` VARCHAR(50) NOT NULL,
`FirstName` VARCHAR(50) NOT NULL,
`MiddleName` VARCHAR(50) NULL,
...
);
Det är ungefär samma som T-SQL. Vad sägs om standardvärden?
Standardvärden för kolumn
Nästa är kolumns standardvärden. Dessa är praktiska när du infogar en post men inte angav ett specifikt värde för en kolumn. Låt oss utöka vårt tidigare exempel lite mer:
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(),
...
);
Ändrat datum kolumnen är standard till det aktuella systemets datum och tid. Om du gör en INSERT på den här tabellen som den nedan, kommer det alltid att finnas ett värde för ModifiedDate .
INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');
Det fungerar som förväntat efter INSERT. Här är en skärmdump från dbForge Studio för MySQL:
MySQL Skapa tabell med primära, främmande och unika nycklar
Som i vilken SQL-plattform som helst, kan du definiera regler för tabellkolumndata med hjälp av begränsningar i MySQL. Eftersom detta är viktigt för bordsdesign måste vi överväga nästa punkt.
En T-SQL-utvecklare ska känna sig som hemma med MySQL-primärnycklar, främmande nycklar och unika nycklar.
Primär nyckel
Du kan definiera en eller flera kolumner som primärnyckel. Syntaxen är nästan densamma som i SQL Server. Några undantag? Ja. Det är användningen av klustrade och icke-klustrade index. Men låt oss reservera diskussionen om denna i nästa avsnitt.
För närvarande fokuserar vi på syntaxen för primärnycklar. Här är samma exempel som vi hade tidigare, men vi lägger till ID-kolumnen som primärnyckel:
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()
);
Lätt, eller hur?
Men vad händer om du behöver flera kolumner? Som i T-SQL har du 2 alternativ. Kontrollera exemplen nedan:
-- 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 är det för primärnycklar.
Främmande nyckel
En annan viktig begränsning är den främmande nyckeln. Detta används för att korshänvisa en tabell till en annan tabell:
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åg du likheten med T-SQL?
Unik nyckel
Ibland vill du se till att informationen som infogas i en tabell är unik. MySQL stöder också unika nycklar. Här är ett exempel:
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`)
);
Ovanstående kod säkerställer att endast unika namn läggs till i tabellen.
Skapa exempel på tabellindex (klustrade och icke-klustrade)
I de tidigare exemplen har du sett primära och sekundära nycklar skapade. Men var finns klustrade och icke-klustrade index? Det märks eftersom du i SQL Server uttryckligen anger nyckelordet CLUSTERED för att skapa ett klustrat index.
Det intressanta är att MySQL inte har CLUSTERED eller ICLUSTERED nyckelord. Hur skapar du klustrade index?
Enkel. Ange bara kolumnen/kolumnerna som primärnyckel, så kommer InnoDB-lagringsmotorn att göra det till ett klustrat index. I exemplet nedan, ID är den primära nyckeln OCH det klustrade indexet.
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`)
);
Om du inte anger en primärnyckel kommer alla unika index att användas som klustrade index.
Återigen, om du inte har en primärnyckel och ett unikt index, skapar InnoDB ett dolt klustrat index. Kontrollera beviset här.
Nästa fråga är, vad sägs om ett icke-klustrat index?
Om du redan har en primärnyckel som ett klustrat index, kommer alla andra index att vara icke-klustrade eller sekundära. Dessutom kan du bara ha ett klustrat index.
Nästa avsnitt kommer att diskutera en unik syntax för MySQL CREATE TABLE som inte finns i T-SQL.
Syntax för kloning och kopiering av MySQL-tabeller
Låt oss diskutera bordskloning. Vi kan göra det i MySQL CREATE TABLE. Sedan kommer vi att visa T-SQL-motsvarigheten.
Exemplet nedan skapar tabellen med samma struktur som den första tabellen med CREATE TABLE...LIKE.
CREATE TABLE `people2` LIKE `people`Vi har precis klonat folket tabell till människor2 . Det är dock bara strukturen hos folket tabell som har kopierats, inte data. Den kopierade också nyckelbegränsningarna och indexen för den ursprungliga tabellen. Ganska praktiskt, om du frågar mig.
Den närmaste T-SQL-motsvarigheten är denna:
-- 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 vad händer om du vill ha data? Sedan, CREATE TABLE...SELECT är svaret:
CREATE TABLE `people3` AS
SELECT * FROM `people`;
Oavsett vilken data som finns i folket tabell, kommer den att kopieras till people3 tabell. Detta kommando kommer dock inte att inkludera index och begränsningar.
Nu är den närmaste T-SQL-motsvarigheten denna:
-- T-SQL table copying
SELECT * INTO people3
FROM people
Slutsats
Jag hoppas att punkterna ovan kan få dig att komma igång med att använda MySQL CREATE TABLE ur ett perspektiv av en SQL Server T-SQL-utvecklare.
Vissa av er föredrar att använda grafiska verktyg. Men senare kommer du att leta efter en referens när du behöver skapa arbetstabeller i dina lagrade procedurer eller ad-hoc-skript. Eller så är du helt enkelt typen som söker mer kontroll genom att skriva allt. Hur som helst kan en one-stop-shop som jämför den grundläggande syntaxen vara en livräddare.
Om du gillar den här artikeln får du gärna dela den på dina sociala favoritmedier.
Lycka till med kodningen, alla.