Introduktion till SQL-datatyper

Att välja rätt datatyp för en tabellkolumn är ett viktigt beslut. Det minskar behovet av datatypkonverteringar, förbättrar prestandan för databasfrågor och minimerar lagringskraven.

I den här guiden utforskar du de olika datatyperna som används i relationsdatabashanteringssystem (RDBMS). Dessa datatyper kan användas när du skapar eller ändrar en tabell, eller när du deklarerar variabler i databaslagrade procedurer. Några välkända RDBMS är MySQL och PostgreSQL.

SQL binära datatyper

För att lagra binär data (0 eller 1 ), använder du BINARY och VARBINARY datatyper. BINARY datatyp lagrar binär data med fast längd, medan VARBINARY lagrar binär data med variabel längd. Båda dessa datatyper används för att lagra bitsträngar (0 ’s och 1 s). Deras värden tilldelas och hämtas med hjälp av hexadecimal representation, vilket indikeras med prefixet 0x . Kolumnerna (eller variablerna) för både Binary och VarBinary datatyper används för att lagra innehållet i bildfiler som JPEG, BMP, dokumentfiler, etc.

Till exempel för ett decimalvärde på 63 , dess hexadecimala värde representeras av 0x3F och dess binära bitsträngsekvivalent är 111111 . För att förstå värdet av dessa binära strängar och hur de lagras, överväg exemplet nedan:

Obs Om inget annat nämns fungerar alla databaskommandon som visas i den här guiden bra på både MySQL och PostgreSQL .

1. Från kommandoraden skapar du en tabell som heter BinaryExample som visas nedan:

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

2. Infoga en rad i BinaryExample tabell:

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

3. Välj data från BinaryExample tabell:

    SELECT BinaryCol, VarBinaryCol FROM BinaryExample;
   

   Utgången ser ut som följer:

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

Som du kan se är BinaryCol data utfylls till maximal kolumnstorlek med efterföljande nollor, men VarBinaryCol datakolumnen är det inte. Detta beror på att kolumnerna i VarBinaryCol definieras som variabel längd.

Obs Den maximala storleken (längden) för binära och VarBinära datatyper varierar beroende på databasens implementering. De är i allmänhet ganska stora (över 8 000 byte). Vissa databasimplementeringar har binära tillägg till dessa kärndatatyper som kan lagra data i storlekar på flera gigabyte.

SQL-numeriska datatyper

De tillgängliga numeriska datatyperna kan delas upp i följande grupper:Heltals numeriska datatyper, Exakta numeriska datatyper och Ungefärliga numeriska datatyper. Avsnitten nedan diskuterar varje grupp.

Numeriska heltalsdatatyper

Heltalsdatatyper kan vara osignerade och signerade. Osignerad kan endast lagra noll och positiva tal, medan Signade tillåter noll, positiva och negativa tal.

De flesta SQL-implementationer stöder heltalsdatatyper av INT , SMALLINT och TINYINT för lagring av positiva och negativa heltal. Vilken heltalsdatatyp du väljer beror på intervallet av värden som du behöver lagra.

Följande tabell visar tillåten lagring i byte för heltals numeriska datatyper och deras lägsta och högsta SIGNED-värden.

Exemplet nedan visar de lägsta och högsta teckenvärdena för heltals numeriska datatyper med hjälp av en tabell med namnet NumericExample .

1. Skapa NumericExample från kommandoraden bord.

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

2. Infoga följande värden i NumericExample bord.

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

   När du utför kommandot ovan får du en Out of range fel som visas i utgången nedan. Du kan inte infoga värdena 3258594758 och 255 till IntColumn och TinyIntColumn respektive. Detta beror på att det maximala SIGNED-värdet för en heltalsdatatyp är 2147483647 och det för en TinyInt är 127 .

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

3. Uppdatera värdena för IntColumn och TinyIntColumn kolumner och kör INSERT igen kommando.

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

4. Hämta kolumnvärdena med SELECT uttalande:

    SELECT IntColumn, SmallIntColumn, TinyIntColumn
    FROM NumericExample;
   

   Utdata liknar exemplet nedan:

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

Decimal numeriska datatyper (exakt numeriska)

Decimaldatatyperna, DECIMAL och NUMERIC , lagra exakta och fasta numeriska värden. Dessa datatyper är även kända som exakta numeriska datatyper. De lagrar ett heltalsvärde till vänster om decimalkomma och ett bråktal till höger om decimalkomma. De är funktionellt likvärdiga med samma lagringskrav. Lagringen som används för dessa typer beror på den specificerade precisionen och intervallen. De kan variera från 2 byte till 17 byte, och deras värden kan variera från -10^38 +1 till +10^38 -1 .

Dessa två datatyper definieras av en precision och en skala . Precisionen anger antalet platser till vänster och höger om decimalkomma kombinerat, medan skalan anger det totala antalet siffror till höger om decimalkomma. Dessa två datatyper skapas med följande syntax:

DECIMAL(precision, scale)

eller

NUMERIC(precision,scale)

Exemplet nedan visar hur man skapar och använder den decimala numeriska datatypen.

1. Skapa ExactNumericExample från kommandoraden bord.

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

2. Infoga följande värden i ExactNumericExample bord.

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

3. Hämta kolumnvärdena med SELECT uttalande:

    SELECT DecimalCol, NumericCol FROM ExactNumericExample;
   

   Utdata liknar följande:

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

Numeriska flyttalsdatatyper (ungefärliga numeriska)

De flytande numeriska datatyperna är FLOAT och REAL . De kallas också för ungefärliga numeriska datatyper. Dessa datatyper lagrar ett ungefärligt värde på grund av den binära representationen av flyttalsdata. Syntaxen för att skapa en flyttalskolumn eller variabel är följande:

Float(N)

Parametern N indikerar om fältet ska innehålla fyra eller åtta byte. Ett värde på N större än sju kräver åtta byte; sju eller mindre kräver fyra byte. Flytande precision för denna datatyp sträcker sig från -1.79E + 308 till 1.79E + 308 .

På liknande sätt definieras en kolumn och variabel som datatyp REAL tar upp fyra byte lagringsutrymme och ger ett värdeintervall från -3.40E + 38 till 3.40E + 38 .

SQL-teckendatatyper

Datatyperna CHAR och VARCHAR används för att lagra teckendata upp till 8 000 byte långa. Båda dessa datatyper lagrar strängvärden i databaskolumner, men de skiljer sig åt i hur deras värden lagras och hämtas. Längden på CHAR datatypen förblir fixerad vid sin specificerade längd oavsett om det allokeringsutrymmet används eller inte. Om utrymmet inte utnyttjas, fylls kolumnen eller variabeln med extra mellanslag. VARCHAR matar ut värdet som det är, utan några ytterligare mellanslag.

Exemplet nedan visar teckendatatypen.

1. Från kommandoraden skapar du Employee bord.

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

2. Infoga följande värden i Employee bord.

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

3. Hämta kolumnvärdena med SELECT uttalande:

    SELECT LastName, FirstName, Sex FROM Employee;
   

   Utdata skulle vilja ha följande:

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

Kolumnerna LastName och Firstname deklareras typ Varchar . Detta gör att namn kan vara lika långa som definitionen av datatyp. Men för namn som är kortare än det angivna maximala värdet läggs inga blanksteg till i uppgifterna i dessa kolumner.

SQL datatyp för datum och tid

DATETIME datatyp används för att lagra datum- och tidsvärdena i databasen. Värden för DATETIME datatyp använder fyra byte lagring för datumdelen och fyra byte för tidsdelen. Tidsdelen av denna datatyp anger tid med en granularitet ner till antalet millisekunder efter midnatt. Precisionen för denna datatyp sträcker sig från "1 januari 1753" till "31 december 9999", med en noggrannhet på 3,33 millisekunder.

Obs Om du bara tilldelar datumvärdet till en DATETIME datatyp kolumn eller variabel, är tidsdelen som standard midnatt.

Exemplet nedan visar DATETIME datatyp.

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

Utdata liknar följande:

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

Obs Vissa SQL-implementationer stöder ytterligare datatyper, som antingen är en delmängd, supermängd eller variant av alla ovan angivna datatyper.

SQL-datatypsöverväganden

När du utformar en databas är det extremt viktigt att noggrant välja lämpliga datatyper för tabellkolumner och lagrade procedurvariabler.

Val som görs kan ha en betydande inverkan på lagringseffektivitet och övergripande databasprestanda. Ett enkelt exempel är att definiera en persons Age kolumnen för att vara av Tinyint datatyp, i motsats till Int data typ. Detta beror på följande skäl:

1. Som nämnts tidigare, Tinyint datatyper har ¼ av lagringskraven för Int datatyper.
2. Hämtningseffektiviteten för en Tinyint kolumn kontra en Int kolumnen är mycket större.

På ytan verkar detta kanske inte vara ett stort problem. Men om den drabbade tabellen har miljontals rader kan både lagrings- och prestandaeffektivitet uppnås. Om du utökar detta designkriterier över en hel databas kan du generera dessa effektivitetsvinster i storleksordningar.

Att spendera den nödvändiga designtiden i val av databasdatatyp kan potentiellt minska behovet av att utföra dyra typomvandlingar i frågor och lagrad procedurlogik, när man jämför kolumner med olika datatyper.

Till exempel, i en tabell lagrar du ett datum i en Varchar(20) kolumn, och i en annan tabell lagrar du ett datum i en Datetime kolumn. Om du behöver jämföra de två kolumnerna måste du använda en datatypkonverteringsfunktion i en fråga på en av de två kolumnerna. Detta är en dyr operation.

Slutsats

SQL-datatyper är de attribut som är associerade med databaskolumner och variabler. Dessa attribut kan ha formen av att vara binära, numeriska, tecken och datum/tid. Noggrann designtid är nödvändig för att säkerställa att kolumner och variabler definieras med en korrekt datatyp, för att säkerställa både lagring och exekveringseffektivitet.