Introduzione ai tipi di dati SQL

La scelta del tipo di dati corretto per una colonna di tabella è una decisione importante. Riduce la necessità di conversioni del tipo di dati, migliora le prestazioni delle query del database e riduce al minimo i requisiti di archiviazione.

In questa guida esplorerai i vari tipi di dati utilizzati nei sistemi di gestione di database relazionali (RDBMS). Questi tipi di dati possono essere utilizzati durante la creazione o la modifica di una tabella o durante la dichiarazione di variabili nelle stored procedure del database. Alcuni noti RDBMS sono MySQL e PostgreSQL.

Tipi di dati binari SQL

Per memorizzare dati binari (0 o 1 ), utilizzi il BINARY e VARBINARY tipi di dati. Il BINARY il tipo di dati memorizza dati binari a lunghezza fissa, mentre VARBINARY memorizza dati binari a lunghezza variabile. Entrambi questi tipi di dati vengono utilizzati per memorizzare stringhe di bit (0 's e 1 'S). I loro valori vengono assegnati e recuperati utilizzando la rappresentazione esadecimale, indicata da un prefisso 0x . Le colonne (o variabili) di entrambi i Binary e VarBinary i tipi di dati vengono utilizzati per memorizzare il contenuto di file di immagine come JPEG, BMP, file di documenti, ecc.

Ad esempio, per un valore decimale di 63 , il suo valore esadecimale è rappresentato da 0x3F e la sua stringa di bit binari equivalente è 111111 . Per comprendere il valore di queste stringhe binarie e come vengono archiviate, considera l'esempio seguente:

Nota Salvo diversa indicazione, tutti i comandi del database illustrati in questa guida funzionano bene su entrambi MySQL e PostgreSQL .

1. Dalla riga di comando, crea una tabella chiamata BinaryExample come mostrato di seguito:

    CREATE TABLE BinaryExample (
      BinaryCol BINARY (10),
      VarBinaryCol VARBINARY (10)
    );
   

2. Inserisci una riga in BinaryExample tabella:

    INSERT INTO BinaryExample (BinaryCol, VarBinaryCol)
    VALUES (0x4D7953514C, 0x39274D);
   

3. Seleziona i dati da BinaryExample tabella:

    SELECT BinaryCol, VarBinaryCol FROM BinaryExample;
   

   L'output ha il seguente aspetto:

   +------------------------+----------------------------+
   | BinaryCol              | VarBinaryCol               |
   +------------------------+----------------------------+
   | 0x4D7953514C0000000000 | 0x39274D                   |
   +------------------------+----------------------------+

Come puoi vedere, il BinaryCol i dati vengono riempiti alla dimensione massima della colonna con zeri finali, ma il VarBinaryCol la colonna dei dati non lo è. Questo perché le colonne di VarBinaryCol sono definiti come lunghezza variabile.

Nota La dimensione massima (lunghezza) dei tipi di dati Binary e VarBinary varia a seconda dell'implementazione del database. Sono generalmente abbastanza grandi (oltre 8.000 byte). Alcune implementazioni di database hanno estensioni binarie a questi tipi di dati di base che possono archiviare dati in dimensioni di più gigabyte.

Tipi di dati numerici SQL

I tipi di dati numerici disponibili possono essere suddivisi nei seguenti gruppi:tipi di dati numerici interi, tipi di dati numerici esatti e tipi di dati numerici approssimativi. Le sezioni seguenti discutono ogni gruppo.

Tipi di dati numerici interi

I tipi di dati interi possono essere Unsigned e Signed. Non firmato può memorizzare solo numeri zero e positivi, mentre Signed consente numeri zero, positivi e negativi.

La maggior parte delle implementazioni SQL supporta i tipi di dati Interi di INT , SMALLINT e TINYINT per la memorizzazione di numeri interi positivi e negativi. Il tipo di dati numerico intero che scegli dipende dall'intervallo di valori che devi archiviare.

La tabella seguente mostra la memorizzazione consentita in byte per i tipi di dati numerici interi e i relativi valori SIGNED minimo e massimo.

L'esempio seguente mostra i valori con segno minimo e massimo dei tipi di dati numerici Integer utilizzando una tabella denominata NumericExample .

1. Dalla riga di comando, crea l'NumericExample tabella.

    CREATE TABLE NumericExample (
      IntColumn INT,
      SmallIntColumn SMALLINT,
      TinyIntColumn TINYINT
    );
   

2. Inserisci i seguenti valori in NumericExample tabella.

    INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn)
    VALUES (3258594758, 32767, 255);
   

   Quando esegui il comando sopra, ottieni un Out of range errore come mostrato nell'output di seguito. Non puoi inserire i valori 3258594758 e 255 a IntColumn e TinyIntColumn rispettivamente. Questo perché il valore SIGNED massimo per un tipo di dati intero è 2147483647 e quello di TinyInt è 127 .

   ERROR 1264 (22003): Out of range value for column 'IntColumn' at row 1

3. Aggiorna i valori di IntColumn e TinyIntColumn colonne ed eseguire nuovamente INSERT comando.

    INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn)
    VALUES (2147483647, 32767, 127);
   

4. Recupera i valori delle colonne usando SELECT dichiarazione:

    SELECT IntColumn, SmallIntColumn, TinyIntColumn
    FROM NumericExample;
   

   L'output è simile all'esempio seguente:

   +------------+----------------+---------------+
   | IntColumn  | SmallIntColumn | TinyIntColumn |
   +------------+----------------+---------------+
   | 2147483647 |          32767 |           127 |
   +------------+----------------+---------------+

Tipi di dati numerici decimali (numerico esatto)

I tipi di dati decimali, DECIMAL e NUMERIC , memorizza valori numerici esatti e fissi. Questi tipi di dati sono anche noti come numerico esatto tipi di dati. Memorizzano un valore intero a sinistra della virgola decimale e un valore frazionario a destra della virgola decimale. Sono funzionalmente equivalenti con gli stessi requisiti di archiviazione. La memoria utilizzata per questi tipi dipende dalla precisione e dagli intervalli specificati. Possono variare da 2 byte a 17 byte e i loro valori possono variare da -10^38 +1 a +10^38 -1 .

Questi due tipi di dati sono definiti da una precisione e una scala . La precisione indica il numero di posizioni a sinistra ea destra della virgola decimale combinate, mentre la scala indica il numero totale di cifre a destra della virgola decimale. Questi due tipi di dati vengono creati utilizzando la seguente sintassi:

DECIMAL(precision, scale)

o

NUMERIC(precision,scale)

L'esempio seguente mostra come creare e utilizzare il tipo di dati numerico decimale.

1. Dalla riga di comando, crea il ExactNumericExample tabella.

    CREATE TABLE ExactNumericExample (
      DecimalCol DECIMAL(5,2),
      NumericCol NUMERIC(7,2)
    );
   

2. Inserisci i seguenti valori in ExactNumericExample tabella.

    INSERT INTO ExactNumericExample (DecimalCol, NumericCol)
    VALUES (123.45, 12345.67);
   

3. Recupera i valori delle colonne usando SELECT dichiarazione:

    SELECT DecimalCol, NumericCol FROM ExactNumericExample;
   

   L'output è simile al seguente:

   +------------+------------+
   | DecimalCol | NumericCol |
   +------------+------------+
   |     123.45 |   12345.67 |
   +------------+------------+

Tipi di dati numerici a virgola mobile (numerico approssimativo)

I tipi di dati numerici in virgola mobile sono FLOAT e REAL . Sono anche chiamati numerico approssimativo tipi di dati. Questi tipi di dati memorizzano un valore approssimativo dovuto alla rappresentazione binaria dei dati in virgola mobile. La sintassi per creare una colonna o una variabile in virgola mobile è la seguente:

Float(N)

Il parametro N indica se il campo deve contenere quattro o otto byte. Un valore di N maggiore di sette richiede otto byte; sette o meno richiede quattro byte. La precisione mobile per questo tipo di dati varia da -1.79E + 308 a 1.79E + 308 .

Allo stesso modo, una colonna e una variabile definite come tipo di dati REAL occupa quattro byte di memoria e fornisce un intervallo di valori da -3.40E + 38 a 3.40E + 38 .

Tipi di dati di carattere SQL

I tipi di dati CHAR e VARCHAR vengono utilizzati per memorizzare dati di caratteri fino a 8.000 byte di lunghezza. Entrambi questi tipi di dati memorizzano i valori di stringa nelle colonne del database, ma differiscono nel modo in cui i loro valori vengono archiviati e recuperati. La lunghezza del CHAR il tipo di dati rimane fisso alla lunghezza specificata indipendentemente dal fatto che lo spazio di allocazione venga utilizzato o meno. Se lo spazio non viene utilizzato, la colonna o la variabile viene riempita con spazi aggiuntivi. VARCHAR restituisce il valore così com'è, senza spazi aggiuntivi.

L'esempio seguente mostra il tipo di dati del carattere.

1. Dalla riga di comando, crea il Employee tabella.

    CREATE TABLE Employee (
        LastName VARCHAR(25),
        FirstName VARCHAR(20),
        Sex CHAR(1)
    );
   

2. Inserisci i seguenti valori nel Employee tabella.

    INSERT INTO Employee (LastName, FirstName, Sex)
    VALUES ('Jones', 'Mary', 'F');
   

3. Recupera i valori delle colonne usando SELECT dichiarazione:

    SELECT LastName, FirstName, Sex FROM Employee;
   

   L'output vorrebbe quanto segue:

   +----------+-----------+------+
   | LastName | FirstName | Sex  |
   +----------+-----------+------+
   | Jones    | Mary      | F    |
   +----------+-----------+------+

Le colonne LastName e Firstname sono dichiarati di tipo Varchar . Ciò consente ai nomi di essere lunghi quanto la definizione del tipo di dati. Ma per i nomi più brevi del massimo specificato, non vengono aggiunti spazi vuoti ai dati in queste colonne.

Tipo di dati SQL Data e ora

Il DATETIME il tipo di dati viene utilizzato per memorizzare i valori di data e ora nel database. Valori per DATETIME il tipo di dati utilizza quattro byte di memoria per la parte della data e quattro byte per la parte dell'ora. La parte temporale di questo tipo di dati specifica l'ora con una granularità fino al numero di millisecondi dopo la mezzanotte. La precisione per questo tipo di dati varia da "1 gennaio 1753" a "31 dicembre 9999", con una precisione di 3,33 millisecondi.

Nota Se assegni solo il valore della data a un DATETIME colonna o variabile del tipo di dati, la parte dell'ora per impostazione predefinita è mezzanotte.

L'esempio seguente mostra il DATETIME tipo di dati.

DELIMITER //
CREATE PROCEDURE Datetimedemo()
BEGIN
DECLARE BirthDate DATETIME
SET BirthDate = '1990-01-01 09:00:00'
SELECT BirthDate
END//
DELIMITER ;
call Datetimedemo;

L'output è simile al seguente:

+----------+-----------+
| BirthDate            |
+----------+-----------+
| 1990-01-01 09:00:00  |
+----------+-----------+

Nota Alcune implementazioni SQL supportano tipi di dati aggiuntivi, che sono un sottoinsieme, un superset o una variante di tutti i tipi di dati sopra specificati.

Considerazioni sui tipi di dati SQL

Quando si progetta un database, è estremamente importante selezionare con attenzione i tipi di dati appropriati per le colonne della tabella e le variabili della procedura memorizzata.

Le scelte effettuate possono avere un impatto significativo sull'efficienza dello storage e sulle prestazioni complessive del database. Un semplice esempio è definire l'Age di una persona colonna deve essere del Tinyint tipo di dati, al contrario di Int tipo di dati. Ciò è dovuto ai seguenti motivi:

1. Come notato in precedenza, Tinyint i tipi di dati hanno ¼ dei requisiti di archiviazione di Int tipi di dati.
2. L'efficienza di recupero di un Tinyint colonna rispetto a un Int colonna è molto più grande.

In apparenza, questo potrebbe non sembrare una grande preoccupazione. Tuttavia, se la tabella interessata contiene milioni di righe, è sicuramente possibile ottenere sia l'efficienza di archiviazione che le prestazioni. Se estendi questi criteri di progettazione a un intero database, puoi generare queste efficienze per ordini di grandezza.

Trascorrere il tempo di progettazione necessario nella selezione del tipo di dati del database può potenzialmente ridurre la necessità di eseguire costose conversioni di tipo nelle query e nella logica della procedura memorizzata, quando si confrontano colonne di tipi di dati diversi.

Ad esempio, in una tabella, memorizzi una data in un Varchar(20) colonna e in un'altra tabella memorizzi una data in un Datetime colonna. Se è necessario confrontare le due colonne, è necessario utilizzare una funzione di conversione del tipo di dati in una query su una delle due colonne. Questa è un'operazione costosa.

Conclusione

I tipi di dati SQL sono gli attributi associati alle colonne e alle variabili del database. Questi attributi possono assumere la forma di essere binari, numerici, caratteri e data/ora. È necessario un attento tempo di progettazione per garantire che le colonne e le variabili siano definite con un tipo di dati corretto, per garantire l'efficienza dell'archiviazione e dell'esecuzione delle query.