Mysql
 sql >> Database >  >> RDS >> Mysql

CREATE TABLE MySQL vs T-SQL con esempi di sintassi

Sei uno sviluppatore T-SQL che sta imparando le basi di MySQL? Quindi, una delle cose che potresti voler imparare è l'istruzione CREATE TABLE di MySQL. Inoltre, il modo più veloce per imparare una nuova piattaforma di database SQL è confrontarne le funzionalità e la sintassi comuni.

Questo è ciò che faremo oggi. Ma la sintassi completa è molto. Quindi, tratteremo solo 5 punti di base per metterti in funzione con il comando MySQL CREATE TABLE.

Tuttavia, prima di procedere, chiariamo alcuni punti:

  1. La versione di MySQL utilizzata qui è MySQL 8 che utilizza il motore di archiviazione InnoDB.
  2. La versione di SQL Server utilizzata qui è SQL Server 2019.

Suona bene? Cominciamo.

Crea istruzione tabella in MySQL e T-SQL

Iniziamo il confronto definendo il nome della tabella.

Una delle notevoli differenze di sintassi in MySQL CREATE TABLE è l'assenza di un nome di schema. Ecco come va:

CREATE TABLE database_name.table_name

Hai notato il nome della tabella preceduto dal nome del database? Ora, ecco un formato equivalente T-SQL che conosci:


CREATE TABLE database_name.schema_name.table_name

Come mai? Perché in MySQL uno schema è sinonimo di database. I nomi del database e dello schema sono facoltativi. Tuttavia, se devi creare una tabella in un altro database nello stesso script, questo è un must.

Giusto. L'uso di parentesi quadre nei nomi di tabelle e colonne attiverà un errore in MySQL. Dovresti invece usare una coppia di backtick per racchiudere gli identificatori. La figura 1 mostra dove lo trovi su un layout di tastiera statunitense:

Ora, controlla l'esempio:

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

Dall'esempio di codice sopra, gli identificatori di nomi di tabelle e colonne sono racchiusi tra apici a ritroso. Se non sei abituato a racchiudere nomi di tabelle e colonne con questo, fidati, non sei solo.

Controlla il codice equivalente in T-SQL di seguito:

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

Naturalmente, non è necessario racchiudere questi identificatori. Ma se utilizzi parole riservate o spazi nei nomi di tabelle o colonne, si verificherà un errore.

Come Crea tabella temporanea

Appassionato di tavoli temporanei? Quindi MySQL ti consentirà di digitare di più per definire una tabella temporanea. Guarda il campione:

-- MySQL Temporary Table

CREATE TEMPORARY TABLE `MyTempTable`

Nel frattempo, i codificatori T-SQL vengono utilizzati per # simbolo prima del nome della tabella. Vedi il codice equivalente di cui sopra:


-- T-SQL Temporary Table

CREATE TABLE #MyTempTable

Abbiamo finito con le definizioni e i nomi delle tabelle. Procediamo con le definizioni delle colonne.

Sintassi della colonna MySQL

Non puoi avere una tabella SQL di base senza colonne. Quindi, quali somiglianze e differenze ci sono tra MySQL e SQL Server?

Nomi delle colonne e tipi di dati

Conoscete già i backtick. Qualsiasi altra cosa di base sui nomi delle colonne e sui tipi di dati è la stessa in MySQL e T-SQL. Vedi l'esempio qui sotto:

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

Tuttavia, c'è di più.

Annullabilità della colonna

Le colonne possono essere annullabili o meno. Puoi farlo aggiungendo NULL o NOT NULL nella definizione della colonna.

Espandiamo il nostro esempio precedente.

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

È praticamente lo stesso di T-SQL. Che ne dici dei valori predefiniti?

Valori predefiniti della colonna

Successivamente ci sono i valori predefiniti della colonna. Questi sono utili quando si inserisce un record ma non si specifica un valore specifico per una colonna. Espandiamo ulteriormente il nostro esempio precedente:

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

La Data di modifica per impostazione predefinita, la colonna è la data e l'ora del sistema correnti. Se esegui un INSERT su questa tabella come quello di seguito, ci sarà sempre un valore per ModifiedDate .

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

Funziona come previsto dopo l'INSERT. Ecco uno screenshot di dbForge Studio per MySQL:

Crea tabella MySQL con chiavi primarie, esterne e univoche

Come in qualsiasi piattaforma SQL, puoi definire regole sui dati delle colonne della tabella utilizzando i vincoli in MySQL. Poiché questo è importante per la progettazione del tavolo, dobbiamo considerare questo punto successivo.

Uno sviluppatore T-SQL dovrebbe sentirsi a proprio agio con le chiavi primarie, le chiavi esterne e le chiavi univoche MySQL.

Chiave primaria

È possibile definire una o più colonne come chiave primaria. La sintassi è quasi la stessa di SQL Server. Qualche eccezione? Sì. È l'uso di indici cluster e non cluster. Ma riserviamo la discussione di questo nella prossima sezione.

Per ora, ci concentriamo sulla sintassi delle chiavi primarie. Ecco lo stesso esempio che avevamo in precedenza, ma aggiungiamo la colonna ID come chiave primaria:

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

Facile, vero?

Ma cosa succede se hai bisogno di più colonne? Come in T-SQL, hai 2 opzioni. Controlla gli esempi seguenti:

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

Questo è tutto per le chiavi primarie.

Chiave straniera

Un altro vincolo importante è la chiave esterna. Viene utilizzato per fare riferimenti incrociati da una tabella a un'altra tabella:

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

Hai visto la somiglianza con T-SQL?

Chiave univoca

A volte, vuoi assicurarti che i dati inseriti in una tabella siano univoci. MySQL supporta anche chiavi univoche. Ecco un esempio:

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

);

Il codice sopra assicurerà che solo i nomi univoci vengano aggiunti alla tabella.

Crea esempi di indici di tabelle (in cluster e non in cluster)

Negli esempi precedenti sono state create chiavi primarie e secondarie. Ma dove sono gli indici cluster e non cluster? Questo è evidente perché in SQL Server specifichi esplicitamente la parola chiave CLUSTERED per creare un indice cluster.

La parte interessante è che MySQL non ha parole chiave CLUSTERED o NONCLUSTERED. Come si creano indici cluster?

Semplice. Basta specificare le colonne come chiave primaria e il motore di archiviazione InnoDB lo renderà un indice cluster. Nell'esempio seguente, ID è la chiave primaria E l'indice cluster.

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

Se non specifichi una chiave primaria, qualsiasi indice univoco verrà utilizzato come indice cluster.

Inoltre, se non hai una chiave primaria e un indice univoco, InnoDB crea un indice cluster nascosto. Controlla la prova qui.

La prossima domanda è:che ne dici di un indice non cluster?

Se hai già una chiave primaria come indice cluster, tutti gli altri indici saranno non cluster o secondari. Inoltre, puoi avere un solo indice cluster.

La prossima sezione discuterà una sintassi univoca per MySQL CREATE TABLE non trovata in T-SQL.

Sintassi di clonazione e copia di tabelle MySQL

Discutiamo della clonazione della tabella. Possiamo farlo in MySQL CREATE TABLE. Quindi, mostreremo l'equivalente T-SQL.

L'esempio seguente crea la tabella con la stessa struttura della prima tabella utilizzando CREATE TABLE…LIKE.

CREATE TABLE `people2` LIKE `people`

Abbiamo appena clonato le persone tabella in persone2 . Tuttavia, è solo la struttura delle persone tabella che è stata copiata, non i dati. Ha anche copiato i vincoli chiave e gli indici della tabella originale. Molto utile, se me lo chiedi.

L'equivalente T-SQL più vicino è questo:

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

Ma cosa succede se vuoi i dati? Quindi, CREATE TABLE…SELECT è la risposta:

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

Qualunque dato ci sia nelle persone tabella, verrà copiato in people3 tavolo. Tuttavia, questo comando non includerà indici e vincoli.

Ora, l'equivalente T-SQL più vicino è questo:

-- T-SQL table copying

SELECT * INTO people3 
FROM people

Conclusione

Spero che i punti precedenti possano renderti operativo con MySQL CREATE TABLE dal punto di vista di uno sviluppatore T-SQL di SQL Server.

Alcuni di voi preferiranno utilizzare strumenti grafici. Ma in seguito, ti ritroverai a cercare un riferimento quando devi creare tabelle di lavoro nelle tue stored procedure o script ad hoc. Oppure sei semplicemente il tipo che cerca un maggiore controllo digitando tutto. In ogni caso, uno sportello unico che confronta la sintassi di base può salvarti la vita.

Se ti piace questo articolo, sentiti libero di condividerlo sui tuoi social media preferiti.

Buona programmazione a tutti.