MySQL
Tworzenie tabeli

Składnia

• CREATE TABLE nazwa_tabeli (nazwa_kolumny1 typ_danych (rozmiar), nazwa_kolumny2 typ_danych (rozmiar), nazwa_kolumny3 typ_danych (rozmiar), ....); // Podstawowe tworzenie tabel

• CREATE TABLE nazwa_tabeli [JEŚLI NIE ISTNIEJE] (nazwa_kolumny1 typ_danych (rozmiar), nazwa_kolumny2 typ_danych (rozmiar), nazwa_kolumny3 typ_danych (rozmiar), ....); // Sprawdzanie tworzenia tabeli istnieje

• CREATE [TEMPORARY] TABELA nazwa_tabeli [JEŚLI NIE ISTNIEJE] (nazwa_kolumny1 typ_danych (rozmiar), nazwa_kolumny2 typ_danych (rozmiar), nazwa_kolumny 3 typ_danych (rozmiar), ....); // Tymczasowe tworzenie tabeli

• UTWÓRZ TABELĘ new_tbl [AS] SELECT * FROM orig_tbl; // Tworzenie tabeli z SELECT

Uwagi

CREATE TABLE table_name ( column_definitions ) ENGINE=engine;

Podstawowe tworzenie tabel

Instrukcja CREATE TABLE służy do utworzenia tabeli w bazie danych MySQL.

CREATE TABLE Person (
    `PersonID`      INTEGER NOT NULL PRIMARY KEY,
    `LastName`      VARCHAR(80),
    `FirstName`     VARCHAR(80),
    `Address`       TEXT,
    `City`          VARCHAR(100)
) Engine=InnoDB;

Każda definicja pola musi zawierać:

1. Nazwa pola: Prawidłowa nazwa pola. Pamiętaj, aby zakodować nazwy w `-chars. Zapewnia to możliwość użycia np. Spacji w nazwie pola.
2. Typ danych [Długość]: Jeśli pole to CHAR lub VARCHAR , obowiązkowe jest podanie długości pola.
3. Atrybuty NULL | NOT NULL : Jeśli określono NOT NULL , każda próba zapisania wartości NULL w tym polu zakończy się niepowodzeniem.
4. Zobacz więcej na temat typów danych i ich atrybutów tutaj .

Engine=... jest opcjonalnym parametrem używanym do określania silnika pamięci tabeli. Jeśli nie zostanie określony żaden silnik pamięci masowej, tabela zostanie utworzona przy użyciu domyślnego mechanizmu pamięci masowej serwera (zwykle InnoDB lub MyISAM).

Ustawianie wartości domyślnych

Dodatkowo, gdy ma to sens, możesz ustawić wartość domyślną dla każdego pola za pomocą DEFAULT :

CREATE TABLE Address (
    `AddressID`   INTEGER NOT NULL PRIMARY KEY,
    `Street`      VARCHAR(80),
    `City`        VARCHAR(80),
    `Country`     VARCHAR(80) DEFAULT "United States",
    `Active`      BOOLEAN DEFAULT 1,
) Engine=InnoDB;

Jeśli podczas wstawiania nie zostanie podana Street , to pole będzie miało NULL podczas pobierania. Jeśli podczas wstawiania nie zostanie podany Country , domyślnie będzie to „Stany Zjednoczone”.

Można ustawić wartości domyślne dla wszystkich typów kolumn, z wyjątkiem pól BLOB , TEXT , GEOMETRY i JSON .

Tworzenie tabeli za pomocą klucza podstawowego

CREATE TABLE Person (
    PersonID     INT UNSIGNED NOT NULL,
    LastName     VARCHAR(66) NOT NULL,
    FirstName    VARCHAR(66),
    Address      VARCHAR(255),
    City         VARCHAR(66),
    PRIMARY KEY (PersonID)
);

Klucz podstawowy to pojedynczy lub wielokolumnowy identyfikator NOT NULL który jednoznacznie identyfikuje wiersz tabeli. Indeks jest tworzony i jeśli nie zostanie jawnie zadeklarowany jako NOT NULL , MySQL zadeklaruje je w sposób cichy i niejawny.

Tabela może mieć tylko jeden PRIMARY KEY , a zaleca się, aby każdy z nich miał jeden. InnoDB automatycznie utworzy go pod nieobecność (jak widać w dokumentacji MySQL ), choć jest to mniej pożądane.

Często AUTO_INCREMENT INT znany również jako „klucz zastępczy” służy do optymalizacji cienkiego indeksu i relacji z innymi tabelami. Wartość ta (normalnie) wzrośnie o 1 za każdym razem, gdy dodawany jest nowy rekord, zaczynając od domyślnej wartości 1.

Jednak pomimo swojej nazwy nie ma na celu zagwarantowania, że wartości są przyrostowe, a jedynie, że są one sekwencyjne i niepowtarzalne.

Wartość INT automatycznego przyrostu nie zostanie zresetowana do domyślnej wartości początkowej, jeśli wszystkie wiersze w tabeli zostaną usunięte, chyba że tabela zostanie obcięta za pomocą instrukcji TRUNCATE TABLE .

Definiowanie jednej kolumny jako klucza podstawowego (definicja wbudowana)

Jeśli klucz podstawowy składa się z pojedynczej kolumny, klauzula PRIMARY KEY może zostać umieszczona w jednej linii z definicją kolumny:

CREATE TABLE Person (
    PersonID     INT UNSIGNED NOT NULL PRIMARY KEY,
    LastName     VARCHAR(66) NOT NULL,
    FirstName    VARCHAR(66),
    Address      VARCHAR(255),
    City         VARCHAR(66)
);

Ta forma polecenia jest krótsza i łatwiejsza do odczytania.

Definiowanie klucza podstawowego z wieloma kolumnami

Możliwe jest również zdefiniowanie klucza podstawowego zawierającego więcej niż jedną kolumnę. Można to zrobić np. W tabeli potomnej relacji klucza obcego. Wielokolumnowy klucz podstawowy jest definiowany przez umieszczenie kolumn uczestniczących w osobnej klauzuli PRIMARY KEY . Składnia wbudowana jest tutaj niedozwolona, ponieważ tylko jedna kolumna może być zadeklarowana jako PRIMARY KEY . Na przykład:

CREATE TABLE invoice_line_items (
    LineNum      SMALLINT UNSIGNED NOT NULL,
    InvoiceNum   INT UNSIGNED NOT NULL,
    -- Other columns go here
    PRIMARY KEY (InvoiceNum, LineNum),
    FOREIGN KEY (InvoiceNum) REFERENCES -- references to an attribute of a table
);

Zauważ, że kolumny klucza podstawowego powinny być określone w logicznej kolejności sortowania, która może różnić się od kolejności, w której kolumny zostały zdefiniowane, jak w powyższym przykładzie.

Większe indeksy wymagają więcej miejsca na dysku, pamięci i we / wy. Dlatego klucze powinny być tak małe, jak to możliwe (szczególnie w przypadku kluczy złożonych). W InnoDB każdy „indeks wtórny” zawiera kopię kolumn PRIMARY KEY .

Tworzenie tabeli za pomocą klucza obcego

CREATE TABLE Account (
    AccountID     INT UNSIGNED NOT NULL,
    AccountNo     INT UNSIGNED NOT NULL,
    PersonID    INT UNSIGNED,
    PRIMARY KEY (AccountID),
    FOREIGN KEY (PersonID) REFERENCES Person (PersonID)
) ENGINE=InnoDB;

Klucz obcy: Klucz obcy ( FK ) to albo pojedyncza kolumna, albo wielokolumnowy złożony z kolumn w tabeli odniesienia . Potwierdzono, że ten FK istnieje w tabeli, do której istnieje odniesienie . Zdecydowanie zaleca się, aby odnośny klucz tabeli potwierdzający FK był kluczem podstawowym, ale nie jest to wymuszone. Stosowany jest jako fast-odnośnika do odwołania, jeżeli nie muszą być unikalne, aw rzeczywistości może być lewy najbardziej Indeks tam.

Relacje klucza obcego obejmują tabelę nadrzędną, która zawiera centralne wartości danych, oraz tabelę podrzędną z identycznymi wartościami wskazującymi z powrotem na jej element nadrzędny. Klauzula FOREIGN KEY jest podana w tabeli potomnej. Tabele nadrzędne i podrzędne muszą używać tego samego silnika pamięci. Nie mogą to być tabele TYMCZASOWE .

Odpowiednie kolumny w kluczu obcym i kluczu odniesienia muszą mieć podobne typy danych. Rozmiar i znak typów liczb całkowitych muszą być takie same. Długość typów ciągów nie musi być taka sama. W przypadku niebinarnych (ciągów znaków) kolumn zestaw znaków i układanie muszą być takie same.

Uwaga: ograniczenia klucza obcego są obsługiwane przez silnik pamięci InnoDB (nie MyISAM ani MEMORY). Konfiguracje DB korzystające z innych silników zaakceptują instrukcję CREATE TABLE , ale nie będą przestrzegać ograniczeń klucza obcego. (Chociaż nowsze wersje MySQL mają domyślnie InnoDB , ale dobrą praktyką jest jawność).

Klonowanie istniejącej tabeli

Tabelę można replikować w następujący sposób:

CREATE TABLE ClonedPersons LIKE Persons;

Nowa tabela będzie miała dokładnie taką samą strukturę jak oryginalna tabela, w tym indeksy i atrybuty kolumn.

Oprócz ręcznego tworzenia tabeli można również utworzyć tabelę, wybierając dane z innej tabeli:

CREATE TABLE ClonedPersons SELECT * FROM Persons;

Możesz użyć dowolnej z normalnych funkcji instrukcji SELECT , aby modyfikować dane w trakcie pracy:

CREATE TABLE ModifiedPersons
SELECT PersonID, FirstName + LastName AS FullName FROM Persons
WHERE LastName IS NOT NULL;

Klucze podstawowe i indeksy nie zostaną zachowane podczas tworzenia tabel z SELECT . Musisz je ponownie ustalić:

CREATE TABLE ModifiedPersons (PRIMARY KEY (PersonID))
SELECT PersonID, FirstName + LastName AS FullName FROM Persons
WHERE LastName IS NOT NULL;

UTWÓRZ TABELĘ Z WYBORU

Możesz utworzyć jedną tabelę z drugiej, dodając instrukcję SELECT na końcu instrukcji CREATE TABLE :

CREATE TABLE stack (
    id_user INT,
    username VARCHAR(30),
    password VARCHAR(30)
);

Utwórz tabelę w tej samej bazie danych:

-- create a table from another table in the same database with all attributes
CREATE TABLE stack2 AS SELECT * FROM stack;

-- create a table from another table in the same database with some attributes
CREATE TABLE stack3 AS SELECT username, password FROM stack;

Twórz tabele z różnych baz danych:

-- create a table from another table from another database with all attributes
CREATE TABLE stack2 AS SELECT * FROM second_db.stack;

-- create a table from another table from another database with some attributes
CREATE TABLE stack3 AS SELECT username, password FROM second_db.stack;

NB

Aby utworzyć tabelę taką samą jak inna tabela istniejąca w innej bazie danych, musisz podać nazwę bazy danych w następujący sposób:

FROM NAME_DATABASE.name_table

Pokaż strukturę tabeli

Jeśli chcesz zobaczyć informacje o schemacie tabeli, możesz użyć jednej z następujących opcji:

SHOW CREATE TABLE child; -- Option 1

CREATE TABLE `child` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `fullName` varchar(100) NOT NULL,
  `myParent` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `mommy_daddy` (`myParent`),
  CONSTRAINT `mommy_daddy` FOREIGN KEY (`myParent`) REFERENCES `parent` (`id`) 
      ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

W przypadku użycia z narzędzia wiersza polecenia mysql jest to mniej szczegółowe:

SHOW CREATE TABLE child \G

Mniej opisowy sposób pokazania struktury tabeli:

mysql> CREATE TABLE Tab1(id int, name varchar(30));
Query OK, 0 rows affected (0.03 sec)

mysql> DESCRIBE Tab1; -- Option 2 

+-------+-------------+------+-----+---------+-------+ 
| Field | Type        | Null | Key | Default | Extra |  
+-------+-------------+------+-----+---------+-------+ 
| id    | int(11)     | YES  |     | NULL    |       | 
| name  | varchar(30) | YES  |     | NULL    |       |  
+-------+-------------+------+-----+---------+-------+ 

Zarówno DESCRIBE, jak i DESC dają ten sam wynik.

Aby zobaczyć DESCRIBE wykonywane jednocześnie na wszystkich tabelach w bazie danych, zobacz ten przykład .

Utwórz tabelę z kolumną TimeStamp, aby wyświetlić ostatnią aktualizację

Kolumna TIMESTAMP pokaże, kiedy wiersz był ostatnio aktualizowany.

CREATE TABLE `TestLastUpdate` (
    `ID` INT NULL,
    `Name` VARCHAR(50) NULL,
    `Address` VARCHAR(50) NULL,
    `LastUpdate` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
)
COMMENT='Last Update'
;