Jste vývojář T-SQL, který se učí základy MySQL? Jednou z věcí, které byste se mohli chtít naučit, je příkaz MySQL CREATE TABLE. Kromě toho nejrychlejší způsob, jak se naučit novou databázovou platformu SQL, je porovnat její běžnou funkčnost a syntaxi.
To je to, co dnes uděláme. Ale plná syntaxe je hodně. Budeme se tedy zabývat pouze 5 základními body, abychom vám pomohli spustit příkaz MySQL CREATE TABLE.
Než však budeme pokračovat, ujasněme si několik bodů:
- Tady použitá verze MySQL je MySQL 8 využívající úložiště InnoDB.
- Tady použitá verze serveru SQL je SQL Server 2019.
To zní dobře? Začněme.
Vytvoření příkazu tabulky v MySQL a T-SQL
Začněme srovnání definováním názvu tabulky.
Jedním z nápadných rozdílů v syntaxi v MySQL CREATE TABLE je absence názvu schématu. Jde to takto:
CREATE TABLE database_name.table_nameVšimli jste si názvu tabulky, kterému předcházel název databáze? Nyní je zde ekvivalentní formát T-SQL, který znáte:
CREATE TABLE database_name.schema_name.table_name
Proč? Protože v MySQL je schéma synonymem pro databázi. Názvy databáze a schématu jsou volitelné. Pokud však potřebujete vytvořit tabulku v jiné databázi ve stejném skriptu, je to nutnost.
To je správně. Použití hranatých závorek v názvech tabulek a sloupců způsobí chybu v MySQL. Místo toho byste měli k uzavření identifikátorů použít pár zpětných zaškrtnutí. Obrázek 1 ukazuje, kde jej najdete na americkém rozložení klávesnice:
Nyní se podívejte na ukázku:
-- 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`));
Z výše uvedeného příkladu kódu jsou identifikátory názvů tabulek a sloupců uzavřeny v zadních značkách. Pokud nejste zvyklí takto uzavírat názvy tabulek a sloupců, věřte mi, nejste sami.
Zkontrolujte ekvivalentní kód v T-SQL níže:
-- 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]
Tyto identifikátory samozřejmě přikládat nemusíte. Pokud však v názvech tabulek nebo sloupců použijete rezervní slova nebo mezeru, dojde k chybě.
Jak na to Vytvořit dočasnou tabulku
Máte rádi dočasné stoly? Poté vám MySQL umožní zadat více, abyste mohli definovat dočasnou tabulku. Podívejte se na ukázku:
-- MySQL Temporary Table
CREATE TEMPORARY TABLE `MyTempTable`
Mezitím jsou kodéry T-SQL zvyklé na # symbol před názvem tabulky. Viz ekvivalentní kód z výše uvedeného:
-- T-SQL Temporary Table
CREATE TABLE #MyTempTable
S definicemi a názvy tabulek jsme skončili. Pokračujme s definicemi sloupců.
Syntaxe sloupců MySQL
Nemůžete mít základní SQL tabulku bez sloupců. Jaké podobnosti a rozdíly tedy existují mezi MySQL a SQL Serverem?
Názvy sloupců a datové typy
O zpětných odpalech už víte. Cokoli dalšího základního o názvech sloupců a datových typech je v MySQL a T-SQL stejné. Podívejte se na ukázku níže:
CREATE TABLE `testdatabase`.`people`
(
`ID` INT,
`LastName` VARCHAR(50),
...
);
Je toho však více.
Pomocí hodnoty Null ve sloupci
Sloupce mohou mít hodnotu null nebo ne. Můžete to udělat přidáním NULL nebo NOT NULL do definice sloupce.
Rozšiřme náš předchozí příklad.
CREATE TABLE `testdatabase`.`people`
(
`ID` INT NOT NULL,
`LastName` VARCHAR(50) NOT NULL,
`FirstName` VARCHAR(50) NOT NULL,
`MiddleName` VARCHAR(50) NULL,
...
);
Je to skoro stejné jako T-SQL. A co výchozí hodnoty?
Výchozí hodnoty sloupce
Dále jsou výchozí hodnoty sloupců. Jsou užitečné, když vložíte záznam, ale nezadáte konkrétní hodnotu pro sloupec. Rozšiřme náš předchozí příklad o něco více:
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(),
...
);
Datum změny sloupec výchozí na aktuální systémové datum a čas. Pokud do této tabulky provedete INSERT, jako je ten níže, bude zde vždy hodnota ModifiedDate .
INSERT INTO testdatabase.people
(ID, LastName, FirstName, MiddleName)
VALUES
(1,'Kirk','James','Tiberius');
Po INSERT funguje podle očekávání. Zde je snímek obrazovky z dbForge Studio pro MySQL:
MySQL Vytvořte tabulku s primárním, cizím a jedinečným klíčem
Stejně jako v jakékoli platformě SQL můžete definovat pravidla pro data sloupců tabulky pomocí omezení v MySQL. Protože je to důležité pro návrh tabulky, musíme zvážit tento další bod.
Vývojář T-SQL by se měl s primárními klíči MySQL, cizími klíči a jedinečnými klíči cítit jako doma.
Primární klíč
Jako primární klíč můžete definovat jeden nebo více sloupců. Syntaxe je téměř stejná jako v SQL Server. Nějaké výjimky? Ano. Jde o použití seskupených a neshlukovaných indexů. Ale nechme si diskuzi o tomto v další sekci.
Prozatím se zaměříme na syntaxi primárních klíčů. Zde je stejný příklad jako dříve, ale přidáme sloupec ID jako primární klíč:
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()
);
Snadné, že?
Ale co když potřebujete více sloupců? Stejně jako v T-SQL máte 2 možnosti. Podívejte se na příklady níže:
-- 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`)
);
To je vše pro primární klíče.
Zahraniční klíč
Dalším důležitým omezením je cizí klíč. To se používá pro křížové odkazování tabulky na jinou tabulku:
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`)
);
Viděli jste podobnost s T-SQL?
Jedinečný klíč
Někdy se chcete ujistit, že data vložená do tabulky jsou jedinečná. MySQL také podporuje unikátní klíče. Zde je příklad:
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`)
);
Výše uvedený kód zajistí, že do tabulky budou přidána pouze jedinečná jména.
Příklady vytvoření tabulkového indexu (seskupené a neseskupené)
V předchozích příkladech jste viděli vytvořené primární a sekundární klíče. Ale kde jsou seskupené a neshlukované indexy? To je patrné, protože v SQL Server explicitně zadáte klíčové slovo CLUSTERED, abyste vytvořili seskupený index.
Zajímavé na tom je, že MySQL nemá klíčová slova CLUSTERED nebo NONCLUSTERED. Jak vytvoříte seskupené indexy?
Jednoduchý. Stačí zadat sloupec(y) jako primární klíč a úložiště InnoDB z toho udělá seskupený index. V níže uvedeném příkladu ID je primární klíč A seskupený 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`)
);
Pokud neurčíte primární klíč, bude jako seskupený index použit jakýkoli jedinečný index.
Pak znovu, pokud nemáte primární klíč a jedinečný index, InnoDB vytvoří skrytý seskupený index. Zkontrolujte důkaz zde.
Další otázkou je, jak je to s indexem bez klastrů?
Pokud již máte primární klíč jako seskupený index, všechny ostatní indexy nebudou seskupené nebo sekundární. Kromě toho můžete mít pouze jeden seskupený index.
Další část se bude zabývat jedinečnou syntaxí pro MySQL CREATE TABLE, která se v T-SQL nenachází.
Klonování tabulky MySQL a syntaxe kopírování
Pojďme diskutovat o klonování tabulky. Můžeme to udělat v MySQL CREATE TABLE. Poté si ukážeme ekvivalent T-SQL.
Níže uvedený příklad vytvoří tabulku se stejnou strukturou jako první tabulka pomocí CREATE TABLE…LIKE.
CREATE TABLE `people2` LIKE `people`Právě jsme naklonovali lidi tabulku do lidí2 . Je to však pouze struktura lidí tabulka, která byla zkopírována, nikoli data. Také zkopírovala klíčová omezení a indexy původní tabulky. Docela užitečné, pokud se mě ptáte.
Nejbližší ekvivalent T-SQL je tento:
-- 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.
Ale co když data chcete? Pak je odpovědí CREATE TABLE…SELECT:
CREATE TABLE `people3` AS
SELECT * FROM `people`;
Jakákoliv data jsou v lidech tabulky, bude zkopírován do lide3 stůl. Tento příkaz však nebude obsahovat indexy a omezení.
Nyní je nejbližší ekvivalent T-SQL toto:
-- T-SQL table copying
SELECT * INTO people3
FROM people
Závěr
Doufám, že výše uvedené body vám pomohou začít používat MySQL CREATE TABLE z pohledu vývojáře SQL Server T-SQL.
Někteří z vás budou raději používat grafické nástroje. Později však zjistíte, že hledáte odkaz, když potřebujete vytvořit pracovní tabulky ve vašich uložených procedurách nebo ad-hoc skriptech. Nebo jste prostě typ, který hledá větší kontrolu tím, že píšete všechno. V každém případě vám může zachraňovat život na jednom místě porovnávající základní syntaxi.
Pokud se vám tento článek líbí, neváhejte ho sdílet na svých oblíbených sociálních sítích.
Šťastné kódování, všichni.