CREATE TABLE MySQL vs T-SQL z przykładami składni

Czy jesteś programistą T-SQL, który uczy się podstaw MySQL? Jedną z rzeczy, których możesz chcieć się nauczyć, jest instrukcja MySQL CREATE TABLE. Poza tym najszybszym sposobem nauczenia się nowej platformy bazy danych SQL jest porównanie jej wspólnej funkcjonalności i składni.

To właśnie zamierzamy zrobić dzisiaj. Ale pełna składnia to dużo. Omówimy więc tylko 5 podstawowych punktów, które pozwolą Ci zacząć korzystać z polecenia MySQL CREATE TABLE.

Zanim jednak przejdziemy dalej, wyjaśnijmy kilka punktów:

1. Wersja MySQL użyta tutaj to MySQL 8 korzystający z silnika pamięci masowej InnoDB.
2. Użyta tutaj wersja SQL Server to SQL Server 2019.

Brzmi dobrze? Zacznijmy.

Utwórz instrukcję tabeli w MySQL i T-SQL

Zacznijmy porównanie od zdefiniowania nazwy tabeli.

Jedną z zauważalnych różnic składniowych w MySQL CREATE TABLE jest brak nazwy schematu. Oto jak to działa:

CREATE TABLE database_name.table_name

Czy zauważyłeś nazwę tabeli poprzedzoną nazwą bazy danych? Oto odpowiednik formatu T-SQL, który znasz:

CREATE TABLE database_name.schema_name.table_name

Czemu? Ponieważ w MySQL schemat jest synonimem bazy danych. Nazwy bazy danych i schematu są opcjonalne. Jeśli jednak musisz utworzyć tabelę w innej bazie danych w tym samym skrypcie, jest to konieczne.

Zgadza się. Użycie nawiasów kwadratowych w nazwach tabel i kolumn spowoduje błąd w MySQL. Zamiast tego powinieneś użyć pary backticków, aby zawrzeć identyfikatory. Rysunek 1 pokazuje, gdzie można go znaleźć w układzie klawiatury w USA:

Teraz sprawdź przykład:

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

W powyższym przykładzie kodu identyfikatory nazw tabel i kolumn są ujęte w znaki wsteczne. Jeśli nie jesteś przyzwyczajony do zamykania w ten sposób nazw tabel i kolumn, zaufaj mi, nie jesteś sam.

Sprawdź odpowiedni kod w T-SQL poniżej:

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

Oczywiście nie musisz załączać tych identyfikatorów. Ale jeśli użyjesz zarezerwowanych słów lub spacji w nazwach tabel lub kolumn, wystąpi błąd.

Jak Utwórz tabelę tymczasową

Lubisz tabele tymczasowe? Następnie MySQL pozwoli ci wpisać więcej, aby zdefiniować tabelę tymczasową. Sprawdź przykład:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Tymczasem kodery T-SQL są używane do # symbol przed nazwą tabeli. Zobacz odpowiedni kod z powyższego:

-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Skończyliśmy z definicjami i nazwami tabel. Przejdźmy do definicji kolumn.

Składnia kolumny MySQL

Nie można mieć podstawowej tabeli SQL bez kolumn. Więc jakie są podobieństwa i różnice między MySQL i SQL Server?

Nazwy kolumn i typy danych

Wiesz już o backtickach. Wszystko inne podstawowe o nazwach kolumn i typach danych jest takie samo w MySQL i T-SQL. Zobacz przykład poniżej:

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

Jest jednak więcej.

Nulacja kolumny

Kolumny mogą zawierać wartości null lub nie. Możesz to zrobić, dodając NULL lub NOT NULL w definicji kolumny.

Rozwińmy nasz poprzedni przykład.

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

To prawie to samo, co T-SQL. A co z wartościami domyślnymi?

Domyślne wartości kolumn

Dalej są domyślne wartości kolumn. Są one przydatne, gdy wstawiasz rekord, ale nie określasz konkretnej wartości dla kolumny. Rozwińmy jeszcze bardziej nasz poprzedni przykład:

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

Data modyfikacji kolumna jest domyślnie ustawiona na bieżącą datę i godzinę systemową. Jeśli wykonasz INSERT w tej tabeli, tak jak poniżej, zawsze będzie wartość ModifiedDate .

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

Działa zgodnie z oczekiwaniami po wstawieniu. Oto zrzut ekranu z dbForge Studio dla MySQL:

Utwórz tabelę MySQL z kluczami podstawowymi, obcymi i unikalnymi

Podobnie jak w każdej platformie SQL, możesz zdefiniować reguły dotyczące danych kolumn tabeli za pomocą ograniczeń w MySQL. Ponieważ jest to ważne przy projektowaniu stołów, musimy rozważyć następny punkt.

Programista T-SQL powinien czuć się jak w domu dzięki kluczom podstawowym MySQL, kluczom obcym i kluczom unikalnym.

Klucz główny

Możesz zdefiniować jedną lub więcej kolumn jako klucz podstawowy. Składnia jest prawie taka sama jak w SQL Server. Jakieś wyjątki? Tak. Jest to wykorzystanie indeksów klastrowych i nieklastrowych. Ale zarezerwujmy dyskusję na ten temat w następnej sekcji.

Na razie skupiamy się na składni kluczy podstawowych. Oto ten sam przykład, który mieliśmy wcześniej, ale dodajemy kolumnę ID jako klucz podstawowy:

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

Proste, prawda?

Ale co, jeśli potrzebujesz wielu kolumn? Podobnie jak w T-SQL masz 2 opcje. Sprawdź poniższe przykłady:

-- 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 tyle, jeśli chodzi o klucze podstawowe.

Klucz zagraniczny

Kolejnym ważnym ograniczeniem jest klucz obcy. Służy do odwoływania się do tabeli z inną 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`)
);

Czy zauważyłeś podobieństwo z T-SQL?

Unikalny klucz

Czasami chcesz się upewnić, że dane wstawiane do tabeli są unikatowe. MySQL obsługuje również unikalne klucze. Oto przykład:

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

);

Powyższy kod zapewni, że do tabeli zostaną dodane tylko unikalne nazwy.

Tworzenie przykładów indeksu tabel (w klastrach i bez klastrów)

W poprzednich przykładach widziałeś utworzone klucze podstawowe i pomocnicze. Ale gdzie są indeksy klastrowe i nieklastrowe? Jest to zauważalne, ponieważ w SQL Server jawnie określasz słowo kluczowe CLUSTERED, aby utworzyć indeks klastrowy.

Interesujące jest to, że MySQL nie zawiera słów kluczowych CLUSTERED ani NONCLUSTERED. Jak tworzyć indeksy klastrowe?

Jedyny. Po prostu określ kolumnę (kolumny) jako klucz podstawowy, a mechanizm przechowywania InnoDB uczyni z tego indeks klastrowy. W poniższym przykładzie ID jest kluczem podstawowym ORAZ indeksem klastrowym.

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

Jeśli nie określisz klucza podstawowego, jako indeks klastrowy zostanie użyty dowolny unikalny indeks.

Z drugiej strony, jeśli nie masz klucza podstawowego i unikalnego indeksu, InnoDB tworzy ukryty indeks klastrowy. Sprawdź dowód tutaj.

Następne pytanie brzmi:co powiesz na indeks nieklastrowany?

Jeśli masz już klucz podstawowy jako indeks klastrowany, wszelkie inne indeksy będą nieklastrowane lub pomocnicze. Poza tym możesz mieć tylko jeden indeks klastrowy.

W następnej sekcji omówiona zostanie unikalna składnia MySQL CREATE TABLE, której nie można znaleźć w T-SQL.

Składnia klonowania i kopiowania tabeli MySQL

Omówmy klonowanie stołu. Możemy to zrobić w MySQL CREATE TABLE. Następnie pokażemy odpowiednik T-SQL.

Poniższy przykład tworzy tabelę o takiej samej strukturze jak pierwsza tabela za pomocą CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Właśnie sklonowaliśmy ludzi tabeli na ludzie2 . Jest to jednak tylko struktura ludzi skopiowanej tabeli, a nie danych. Skopiował również kluczowe ograniczenia i indeksy oryginalnej tabeli. Całkiem przydatne, jeśli mnie o to pytasz.

Najbliższy odpowiednik T-SQL to:

-- 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, jeśli chcesz danych? Następnie CREATE TABLE…SELECT jest odpowiedzią:

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

Wszelkie dane znajdują się w ludziach tabeli, zostanie skopiowany do ludzi3 stół. Jednak to polecenie nie będzie zawierało indeksów i ograniczeń.

Teraz najbliższym odpowiednikiem T-SQL jest:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Wniosek

Mam nadzieję, że powyższe punkty pomogą Ci rozpocząć korzystanie z MySQL CREATE TABLE z perspektywy programisty SQL Server T-SQL.

Niektórzy z Was woleliby korzystać z narzędzi graficznych. Później jednak będziesz szukał odwołania, gdy będziesz musiał utworzyć tabele robocze w procedurach składowanych lub skryptach ad hoc. Lub po prostu jesteś typem, który szuka większej kontroli, wpisując wszystko. W każdym razie punkt kompleksowej obsługi porównujący podstawową składnię może być ratunkiem.

Jeśli podoba Ci się ten artykuł, udostępnij go w swoich ulubionych mediach społecznościowych.

Życzę wszystkim miłego kodowania.