sql >> Database >  >> RDS >> Mysql

MAAK TABEL MySQL versus T-SQL met syntaxisvoorbeelden

Ben jij een T-SQL-ontwikkelaar die de basis van MySQL leert? Een van de dingen die u misschien wilt leren, is de MySQL CREATE TABLE-instructie. Bovendien is de snelste manier om een ​​nieuw SQL-databaseplatform te leren kennen, door de algemene functionaliteit en syntaxis ervan te vergelijken.

Dat is wat we vandaag gaan doen. Maar de volledige syntaxis is veel. We behandelen dus slechts 5 basispunten om u op weg te helpen met de opdracht MySQL CREATE TABLE.

Laten we echter, voordat we verder gaan, een paar punten verduidelijken:

  1. De hier gebruikte MySQL-versie is MySQL 8 die de InnoDB-opslagengine gebruikt.
  2. De hier gebruikte SQL Server-versie is SQL Server 2019.

Klinkt goed? Laten we beginnen.

Tabelverklaring maken in MySQL en T-SQL

Laten we de vergelijking beginnen door de tabelnaam te definiëren.

Een van de opvallende syntaxisverschillen in MySQL CREATE TABLE is de afwezigheid van een schemanaam. Zo gaat het:

CREATE TABLE database_name.table_name

Is het u opgevallen dat de tabelnaam wordt voorafgegaan door de databasenaam? Hier is een T-SQL-equivalent formaat waarmee u bekend bent:


CREATE TABLE database_name.schema_name.table_name

Waarom? Omdat in MySQL een schema synoniem is met een database. De database- en schemanamen zijn optioneel. Als u echter een tabel in een andere database in hetzelfde script moet maken, is dit een must.

Dat klopt. Het gebruik van vierkante haken in tabel- en kolomnamen leidt tot een fout in MySQL. U moet in plaats daarvan een paar backticks gebruiken om identifiers in te sluiten. Afbeelding 1 laat zien waar u het vindt op een Amerikaanse toetsenbordindeling:

Bekijk nu het voorbeeld:

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

Van het bovenstaande codevoorbeeld zijn tabel- en kolomnaam-ID's tussen backticks ingesloten. Als je niet gewend bent om hier tabel- en kolomnamen bij te voegen, geloof me, je bent niet de enige.

Controleer de equivalente code in T-SQL hieronder:

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

U hoeft deze identifiers natuurlijk niet bij te voegen. Maar als u reservewoorden of spatie gebruikt in tabel- of kolomnamen, treedt er een fout op.

Hoe Tijdelijke tabel maken

Ben je dol op tijdelijke tafels? Dan laat MySQL je meer typen om een ​​tijdelijke tabel te definiëren. Bekijk het voorbeeld:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Ondertussen zijn T-SQL-codeerders gewend aan de # symbool voor de tabelnaam. Zie de equivalente code van het bovenstaande:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

We zijn klaar met tabeldefinities en namen. Laten we doorgaan met kolomdefinities.

MySQL-kolomsyntaxis

U kunt geen standaard SQL-tabel hebben zonder kolommen. Dus, welke overeenkomsten en verschillen zijn er tussen MySQL en SQL Server?

Kolomnamen en gegevenstypen

Je weet al van de backticks. Al het andere elementaire over kolomnamen en gegevenstypen is hetzelfde in MySQL en T-SQL. Zie het voorbeeld hieronder:

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

Er is echter meer.

Kolomnulbaarheid

Kolommen kunnen nullable zijn of niet. U kunt dat doen door NULL of NOT NULL toe te voegen aan de kolomdefinitie.

Laten we ons vorige voorbeeld uitbreiden.

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

Het is vrijwel hetzelfde als T-SQL. Hoe zit het met standaardwaarden?

Standaardwaarden kolom

Hierna volgen de standaardwaarden van de kolom. Deze zijn handig wanneer u een record invoegt maar geen specifieke waarde voor een kolom opgeeft. Laten we ons vorige voorbeeld nog wat uitbreiden:

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

De ModifiedDate kolom is standaard ingesteld op de huidige systeemdatum en -tijd. Als u een INSERT doet in deze tabel zoals hieronder, zal er altijd een waarde zijn voor ModifiedDate .

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

Het werkt zoals verwacht na de INSERT. Hier is een screenshot van dbForge Studio voor MySQL:

MySQL-tabel maken met primaire, buitenlandse en unieke sleutels

Zoals op elk SQL-platform kunt u regels voor tabelkolomgegevens definiëren met behulp van beperkingen in MySQL. Omdat dit belangrijk is voor tafelontwerp, moeten we dit volgende punt in overweging nemen.

Een T-SQL-ontwikkelaar zou zich meteen thuis moeten voelen met primaire MySQL-sleutels, externe sleutels en unieke sleutels.

Primaire sleutel

U kunt een of meer kolommen definiëren als de primaire sleutel. De syntaxis is bijna hetzelfde als in SQL Server. Enige uitzonderingen? Ja. Het is het gebruik van geclusterde en niet-geclusterde indexen. Maar laten we de bespreking hiervan in de volgende sectie reserveren.

Voor nu concentreren we ons op de syntaxis van primaire sleutels. Hier is hetzelfde voorbeeld dat we eerder hadden, maar we voegen de ID-kolom toe als de primaire sleutel:

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

Makkelijk, nietwaar?

Maar wat als u meerdere kolommen nodig heeft? Net als in T-SQL heb je 2 opties. Bekijk de onderstaande voorbeelden:

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

Dat is het voor primaire sleutels.

Buitenlandse sleutel

Een andere belangrijke beperking is de externe sleutel. Dit wordt gebruikt om een ​​tabel naar een andere tabel te verwijzen:

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

Zag je de overeenkomst met T-SQL?

Unieke sleutel

Soms wilt u er zeker van zijn dat de gegevens die in een tabel worden ingevoegd, uniek zijn. MySQL ondersteunt ook unieke sleutels. Hier is een voorbeeld:

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

);

De bovenstaande code zorgt ervoor dat alleen unieke namen aan de tabel worden toegevoegd.

Tabelindexvoorbeelden maken (geclusterd en niet-geclusterd)

In de vorige voorbeelden heb je gezien dat primaire en secundaire sleutels zijn gemaakt. Maar waar zijn geclusterde en niet-geclusterde indexen? Dat valt op omdat je in SQL Server expliciet het trefwoord CLUSTERED specificeert om een ​​geclusterde index te maken.

Het interessante is dat MySQL geen CLUSTERED of NONCLUSTERED trefwoorden heeft. Hoe maak je geclusterde indexen?

Gemakkelijk. Geef gewoon de kolom(men) op als de primaire sleutel, en de InnoDB-opslagengine maakt daar een geclusterde index van. In het onderstaande voorbeeld, ID is de primaire sleutel EN de geclusterde index.

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

Als u geen primaire sleutel opgeeft, wordt elke unieke index gebruikt als de geclusterde index.

Aan de andere kant, als u geen primaire sleutel en een unieke index hebt, maakt InnoDB een verborgen geclusterde index. Bekijk hier het bewijs.

De volgende vraag is, hoe zit het met een niet-geclusterde index?

Als u al een primaire sleutel als geclusterde index hebt, zijn alle andere indexen niet-geclusterd of secundair. Bovendien kun je maar één geclusterde index hebben.

In de volgende sectie wordt een unieke syntaxis besproken voor MySQL CREATE TABLE die niet in T-SQL wordt gevonden.

MySQL-tabel klonen en syntaxis kopiëren

Laten we het klonen van tabellen bespreken. We kunnen het doen in MySQL CREATE TABLE. Vervolgens laten we het T-SQL-equivalent zien.

In het onderstaande voorbeeld wordt de tabel gemaakt met dezelfde structuur als de eerste tabel met CREATE TABLE...LIKE.

CREATE TABLE `people2` LIKE `people`

We hebben zojuist de mensen gekloond tabel in people2 . Het is echter alleen de structuur van de mensen tabel die is gekopieerd, niet de gegevens. Het kopieerde ook de belangrijkste beperkingen en indexen van de originele tabel. Best handig, als je het mij vraagt.

Het dichtstbijzijnde T-SQL-equivalent is dit:

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

Maar wat als u de gegevens wilt? CREATE TABLE...SELECT is dan het antwoord:

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

Welke gegevens zich ook in de mensen bevinden tabel, wordt deze gekopieerd naar de people3 tafel. Deze opdracht bevat echter geen indexen en beperkingen.

Het dichtstbijzijnde T-SQL-equivalent is dit:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Conclusie

Ik hoop dat de bovenstaande punten je op weg kunnen helpen met het gebruik van MySQL CREATE TABLE vanuit het perspectief van een SQL Server T-SQL-ontwikkelaar.

Sommigen van jullie zullen liever grafische tools gebruiken. Maar later zult u merken dat u op zoek bent naar een referentie wanneer u werktabellen moet maken in uw opgeslagen procedures of ad-hocscripts. Of je bent gewoon het type dat meer controle zoekt door alles te typen. In ieder geval kan een one-stop-shop die de basissyntaxis vergelijkt, levensreddend zijn.

Als je dit artikel leuk vindt, deel het dan gerust op je favoriete sociale media.

Veel plezier met coderen, allemaal.


  1. Gegevens ophalen uit MySQL-database naar html-vervolgkeuzelijst

  2. Dynamisch gegevens laden op div-scroll met behulp van php, mysql, jQuery en ajax

  3. 1052:Kolom 'id' in veldlijst is dubbelzinnig

  4. Zoek een waarde in de kolomwaarde die door komma's gescheiden waarden opslaat