MySQL
Tabell skapande

Syntax

• SKAPA TABELL tabellnamn (kolumnnamn1 datatyp (storlek), kolumnnamn2 datatyp (storlek), kolumnnamn3 datatyp (storlek), ....); // Grundläggande tabellskapande

• SKAPA TABELL tabellnamn [IF NOT EXISTS] (column_name1 data_type (storlek), column_name2 data_type (storlek), column_name3 data_type (storlek), ....); // Tabellskapande som kontrollerar befintlig

• CREATE [TEMPORARY] TABLE tabellnamn [IF NOT EXISTS] (column_name1 data_type (size), column_name2 data_type (size), column_name3 data_type (size), ....); // Tillfällig tabellskapning

• SKAPA TABELL new_tbl [AS] VÄLJ * FRÅN orig_tbl; // Tabellskapande från SELECT

Anmärkningar

CREATE TABLE table_name ( column_definitions ) ENGINE=engine;

Grundläggande tabellskapande

CREATE TABLE används för att skapa en tabell i en MySQL-databas.

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

Varje fältdefinition måste ha:

1. Fältnamn: Ett giltigt fältnamn. Se till att kolla in namnen i `-fält. Detta säkerställer att du kan använda t.ex. rymdfält i fältnamnet.
2. Datatyp [Längd]: Om fältet är CHAR eller VARCHAR , är det obligatoriskt att ange en fältlängd.
3. Attribut NULL | NOT NULL : Om NOT NULL anges, kommer alla försök att lagra ett NULL värde i det fältet att misslyckas.
4. Se mer om datatyper och deras attribut här .

Engine=... är en valfri parameter som används för att specificera tabellens lagringsmotor. Om ingen lagringsmotor anges skapas tabellen med serverns standardmaskin för tabelllagring (vanligtvis InnoDB eller MyISAM).

Ställer in standardvärden

Om det dessutom är vettigt kan du ställa in ett standardvärde för varje fält med 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;

Om det inte finns någon Street infogningar, kommer det fältet att vara NULL när det hämtas. När inget Country anges vid infoga, kommer det att vara "USA".

Du kan ställa in standardvärden för alla kolumntyper, med undantag för BLOB , TEXT , GEOMETRY och JSON .

Tabellskapning med Primär nyckel

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

En primär nyckel är en NOT NULL singel eller en flerkolumnidentifierare som unikt identifierar en rad i en tabell. Ett index skapas, och om det inte uttryckligen förklaras som NOT NULL , kommer MySQL att förklara dem så tyst och implicit.

En tabell kan endast ha en PRIMARY KEY , och varje tabell rekommenderas att ha en. InnoDB skapar automatiskt en i sin frånvaro (som det ses i MySQL-dokumentation ), men detta är mindre önskvärt.

Ofta används en AUTO_INCREMENT INT även känd som "surrogatnyckel" för tunn indexoptimering och förhållanden med andra tabeller. Detta värde kommer (normalt) att öka med 1 när en ny post läggs till, med början från ett standardvärde på 1.

Men trots dess namn är det inte dess syfte att garantera att värden är inkrementella, bara att de är sekventiella och unika.

Ett automatiskt inkrement INT värde återställs inte till sitt standardstartvärde om alla rader i tabellen raderas, såvida inte tabellen är trunkerad med TRUNCATE TABLE .

Definiera en kolumn som primär nyckel (inline definition)

Om den primära nyckeln består av en enda kolumn, kan PRIMARY KEY klausulen placeras i linje med kolumndefinitionen:

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

Denna form av kommandot är kortare och lättare att läsa.

Definiera en primärnyckel med flera kolumner

Det är också möjligt att definiera en primär nyckel som innehåller mer än en kolumn. Detta kan t.ex. göras på barnbordet med en utländsk nyckelförhållande. En primärnyckel med flera kolumner definieras genom att de deltagande kolumnerna PRIMARY KEY i en separat PRIMARY KEY klausul. Inline syntax är inte tillåtet här, eftersom endast en kolumn kan förklaras PRIMARY KEY inline. Till exempel:

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

Observera att kolumnerna i den primära nyckeln ska anges i logisk sorteringsordning, vilket kan skilja sig från den ordning i vilken kolumnerna definierades, som i exemplet ovan.

Större index kräver mer diskutrymme, minne och I / O. Därför bör tangenterna vara så små som möjligt (särskilt när det gäller komponerade nycklar). I InnoDB inkluderar varje "sekundärt index" en kopia av kolumnerna på PRIMARY KEY .

Tabellskapande med utländsk nyckel

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;

Utländsk nyckel: En utländsk nyckel ( FK ) är antingen en enda kolumn, eller sammansatt av kolumner i en referenstabell . Detta FK bekräftas att det finns i den refererade tabellen. Det rekommenderas starkt att den hänvisade tabellnyckeln som bekräftar FK är en primär nyckel, men den verkställs inte. Det används som en snabbuppslagning i den refererade där den inte behöver vara unik, och i själva verket kan vara ett index till vänster där.

Utländska nyckelförhållanden involverar en överordnad tabell som innehåller de centrala datavärdena, och en underordnad tabell med identiska värden som pekar tillbaka till dess överordnade. Utländsk nyckelklausul anges i underordnatabellen. Förälder- och barntabellerna måste använda samma lagringsmotor. De får inte vara TIDIGA tabeller.

Motsvarande kolumner i den främmande nyckeln och den referensnyckeln måste ha liknande datatyper. Storleken och tecknet för heltalstyper måste vara desamma. Längden på strängtyper behöver inte vara densamma. För icke-binära (tecken) strängkolumner måste teckenuppsättningen och sammanställningen vara desamma.

Obs: begränsningar med utländsk nyckel stöds under InnoDB-lagringsmotorn (inte MyISAM eller MEMORY). DB-uppsättningar som använder andra motorer accepterar detta CREATE TABLE uttalande men respekterar inte begränsningar med utländsk nyckel. (Även om nyare MySQL-versioner är standard för InnoDB , men det är god praxis att vara uttrycklig.)

Kloning av ett befintligt bord

En tabell kan replikeras enligt följande:

CREATE TABLE ClonedPersons LIKE Persons;

Den nya tabellen har exakt samma struktur som den ursprungliga tabellen, inklusive index och kolumnattribut.

Förutom att manuellt skapa en tabell är det också möjligt att skapa tabell genom att välja data från en annan tabell:

CREATE TABLE ClonedPersons SELECT * FROM Persons;

Du kan använda någon av de normala funktionerna i ett SELECT uttalande för att ändra uppgifterna när du går:

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

Primära nycklar och index sparas inte när du skapar tabeller från SELECT . Du måste förklara dem:

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

SKAPA TABELL FRÅN VÄLJ

Du kan skapa en tabell från en annan genom att lägga till ett SELECT uttalande i slutet av CREATE TABLE uttalandet:

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

Skapa en tabell i samma databas:

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

Skapa tabeller från olika databaser:

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

För att skapa en tabell av samma tabell som finns i en annan databas måste du ange namnet på databasen så här:

FROM NAME_DATABASE.name_table

Visa tabellstruktur

Om du vill se schemainformationen i din tabell kan du använda något av följande:

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;

Om det används från kommandoradsverktyget mysql, är detta mindre ordbok:

SHOW CREATE TABLE child \G

Ett mindre beskrivande sätt att visa tabellstrukturen:

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

Både DESCRIBE och DESC ger samma resultat.

För att se DESCRIBE utförda på alla tabeller i en databas på en gång, se detta exempel .

Tabell Skapa med TimeStamp-kolumn för att visa senaste uppdatering

Kolumnen TIMESTAMP kommer att visas när raden senast uppdaterades.

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'
;