Inleiding tot SQL-gegevenstypen

Het kiezen van het juiste gegevenstype voor een tabelkolom is een belangrijke beslissing. Het vermindert de noodzaak voor conversies van gegevenstypes, verbetert de prestaties van databasequery's en minimaliseert opslagvereisten.

In deze handleiding verkent u de verschillende gegevenstypen die worden gebruikt in relationele databasebeheersystemen (RDBMS). Deze gegevenstypen kunnen worden gebruikt bij het maken of wijzigen van een tabel, of bij het declareren van variabelen in opgeslagen procedures in de database. Enkele bekende RDBMS zijn MySQL en PostgreSQL.

SQL binaire gegevenstypen

Om binaire gegevens op te slaan (0 of 1 ), gebruik je de BINARY en VARBINARY gegevens typen. De BINARY gegevenstype slaat binaire gegevens met een vaste lengte op, terwijl VARBINARY slaat binaire gegevens met variabele lengte op. Beide datatypes worden gebruikt om reeksen bits op te slaan (0 ’s en 1 's). Hun waarden worden toegewezen en opgehaald met behulp van hexadecimale weergave, die wordt aangegeven door een voorvoegsel van 0x . De kolommen (of variabelen) van zowel de Binary en VarBinary gegevenstypen worden gebruikt om de inhoud van afbeeldingsbestanden zoals JPEG, BMP, documentbestanden, enz. op te slaan.

Bijvoorbeeld voor een decimale waarde van 63 , de hexadecimale waarde wordt weergegeven door 0x3F en het equivalent van de binaire bitreeks is 111111 . Bekijk het onderstaande voorbeeld om de waarde van deze binaire strings en hoe ze worden opgeslagen te begrijpen:

Opmerking Tenzij anders vermeld, werken alle databasecommando's die in deze handleiding worden gedemonstreerd goed op zowel MySQL en PostgreSQL .

1. Maak vanaf de opdrachtregel een tabel met de naam BinaryExample zoals hieronder weergegeven:

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

2. Een rij invoegen in het BinaryExample tafel:

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

3. Selecteer de gegevens uit het BinaryExample tafel:

    SELECT BinaryCol, VarBinaryCol FROM BinaryExample;
   

   De uitvoer ziet er als volgt uit:

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

Zoals je kunt zien, is de BinaryCol gegevens worden opgevuld tot de maximale kolomgrootte met volgnullen, maar de VarBinaryCol gegevenskolom niet. Dit komt omdat de kolommen van VarBinaryCol zijn gedefinieerd als variabele lengte.

Opmerking De maximale grootte (lengte) van binaire en VarBinary-gegevenstypen is afhankelijk van de database-implementatie. Ze zijn over het algemeen vrij groot (meer dan 8.000 bytes). Sommige database-implementaties hebben binaire extensies voor deze kerngegevenstypen die gegevens kunnen opslaan in grootten van meerdere gigabytes.

SQL numerieke gegevenstypen

De beschikbare Numerieke gegevenstypen kunnen worden onderverdeeld in de volgende groepen:Integer numerieke gegevenstypen, Exacte numerieke gegevenstypen en Benaderende numerieke gegevenstypen. In de onderstaande secties wordt elke groep besproken.

Integer numerieke gegevenstypen

Integer-gegevenstypen kunnen niet-ondertekend en ondertekend zijn. Niet ondertekend kan alleen nul en positieve getallen opslaan, terwijl Getekend staat nul, positieve en negatieve getallen toe.

De meeste SQL-implementaties ondersteunen Integer-gegevenstypen van INT , SMALLINT , en TINYINT voor opslag van positieve en negatieve gehele getallen. Het gehele numerieke gegevenstype dat u kiest, hangt af van het waardenbereik dat u moet opslaan.

De volgende tabel toont de toegestane opslag in bytes voor de numerieke gegevenstypen met gehele getallen, en hun minimale en maximale SIGNED-waarden.

Het onderstaande voorbeeld demonstreert de minimum en maximum ondertekende waarden van Integer numerieke gegevenstypen met behulp van een tabel met de naam NumericExample .

1. Maak vanaf de opdrachtregel het NumericExample tafel.

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

2. Voer de volgende waarden in in het NumericExample tafel.

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

   Wanneer u het bovenstaande commando uitvoert, krijgt u een Out of range fout zoals weergegeven in de onderstaande uitvoer. U kunt de waarden 3258594758 . niet invoegen en 255 naar IntColumn en TinyIntColumn respectievelijk. Dit komt omdat de maximale SIGNED-waarde voor een geheel getal gegevenstype 2147483647 is en die van een TinyInt is 127 .

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

3. Werk de waarden van de IntColumn . bij en TinyIntColumn kolommen en voer de INSERT . opnieuw uit commando.

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

4. Haal de kolomwaarden op met de SELECT verklaring:

    SELECT IntColumn, SmallIntColumn, TinyIntColumn
    FROM NumericExample;
   

   De uitvoer lijkt op het onderstaande voorbeeld:

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

Decimaal numerieke gegevenstypen (exact numeriek)

De decimale gegevenstypen, DECIMAL en NUMERIC , sla exacte en vaste numerieke waarden op. Deze gegevenstypen staan ​​ook bekend als exact numeriek gegevens typen. Ze slaan een geheel getal op links van de komma en een breukwaarde rechts van de komma. Ze zijn functioneel equivalent met dezelfde opslagvereisten. De opslag die voor deze typen wordt gebruikt, is afhankelijk van de gespecificeerde precisie en bereiken. Ze kunnen variëren van 2 bytes tot 17 bytes en hun waarden kunnen variëren van -10^38 +1 tot +10^38 -1 .

Deze twee gegevenstypen worden gedefinieerd door een precisie en een schaal . De precisie geeft het aantal plaatsen links en rechts van de komma samen aan, terwijl de schaal het totale aantal cijfers rechts van de komma aangeeft. Deze twee gegevenstypen worden gemaakt met behulp van de volgende syntaxis:

DECIMAL(precision, scale)

of

NUMERIC(precision,scale)

Het onderstaande voorbeeld laat zien hoe u het decimale numerieke gegevenstype maakt en gebruikt.

1. Maak vanaf de opdrachtregel het ExactNumericExample tafel.

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

2. Voer de volgende waarden in in het ExactNumericExample tafel.

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

3. Haal de kolomwaarden op met de SELECT verklaring:

    SELECT DecimalCol, NumericCol FROM ExactNumericExample;
   

   De uitvoer lijkt op het volgende:

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

Numerieke gegevenstypen met drijvende komma (bij benadering)

De numerieke gegevenstypen met drijvende komma zijn FLOAT en REAL . Ze worden ook ongeveer numeriek genoemd gegevens typen. Deze gegevenstypen slaan een geschatte waarde op vanwege de binaire weergave van drijvende-kommagegevens. De syntaxis om een ​​drijvende-kommakolom of variabele te maken is de volgende:

Float(N)

De parameter N geeft aan of het veld vier of acht bytes moet bevatten. Een waarde van N groter dan zeven vereist acht bytes; zeven of minder vereist vier bytes. Zwevende precisie voor dit gegevenstype varieert van -1.79E + 308 tot 1.79E + 308 .

Evenzo, een kolom en variabele gedefinieerd als gegevenstype REAL neemt vier bytes aan opslagruimte in beslag en biedt een reeks waarden van -3.40E + 38 tot 3.40E + 38 .

SQL-tekengegevenstypen

De gegevenstypen CHAR en VARCHAR worden gebruikt om karaktergegevens tot 8.000 bytes lang op te slaan. Beide gegevenstypen slaan tekenreekswaarden op in databasekolommen, maar ze verschillen in de manier waarop hun waarden worden opgeslagen en opgehaald. De lengte van de CHAR datatype blijft op de gespecificeerde lengte gefixeerd, ongeacht of die toewijzingsruimte wordt gebruikt of niet. Als de ruimte niet wordt gebruikt, wordt de kolom of variabele opgevuld met extra spaties. VARCHAR voert de waarde uit zoals deze is, zonder extra spaties.

Het onderstaande voorbeeld demonstreert het karaktergegevenstype.

1. Maak vanaf de opdrachtregel de Employee tafel.

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

2. Voer de volgende waarden in in de Employee tafel.

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

3. Haal de kolomwaarden op met de SELECT verklaring:

    SELECT LastName, FirstName, Sex FROM Employee;
   

   De uitvoer wil het volgende:

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

De kolommen LastName en Firstname zijn gedeclareerd type Varchar . Hierdoor kunnen namen zo lang zijn als de definitie van het gegevenstype. Maar voor namen die korter zijn dan het opgegeven maximum, worden er geen spaties toegevoegd aan de gegevens in deze kolommen.

SQL datum en tijd gegevenstype

De DATETIME gegevenstype wordt gebruikt om de datum- en tijdwaarden in de database op te slaan. Waarden voor de DATETIME gegevenstype gebruikt vier bytes opslagruimte voor het datumgedeelte en vier bytes voor het tijdgedeelte. Het tijdgedeelte van dit gegevenstype specificeert de tijd met een granulariteit tot het aantal milliseconden na middernacht. De precisie voor dit gegevenstype varieert van "1 januari 1753" tot "31 december 9999", met een nauwkeurigheid van 3,33 milliseconden.

Opmerking Als u alleen de datumwaarde toewijst aan een DATETIME gegevenstype kolom of variabele, het tijdsgedeelte is standaard middernacht.

Het onderstaande voorbeeld demonstreert de DATETIME gegevenstype.

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

De uitvoer lijkt op het volgende:

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

Opmerking Sommige SQL-implementaties ondersteunen aanvullende gegevenstypen, die ofwel een subset, superset of variant zijn van alle hierboven gespecificeerde gegevenstypen.

Overwegingen bij SQL-gegevenstypes

Bij het ontwerpen van een database is het uiterst belangrijk om de juiste gegevenstypen voor tabelkolommen en opgeslagen procedurevariabelen zorgvuldig te selecteren.

Gemaakte keuzes kunnen een aanzienlijke impact hebben op de opslagefficiëntie en de algehele databaseprestaties. Een eenvoudig voorbeeld is het definiëren van iemands Age kolom moet van de Tinyint . zijn gegevenstype, in tegenstelling tot de Int data type. Dit is vanwege de volgende redenen:

1. Zoals eerder opgemerkt, Tinyint gegevenstypen hebben ¼ van de opslagvereisten van Int gegevenstypen.
2. De ophaalefficiëntie van een Tinyint kolom versus een Int kolom is veel groter.

Op het eerste gezicht lijkt dit misschien geen grote zorg. Maar als de betreffende tabel miljoenen rijen bevat, kunnen zowel opslag- als prestatie-efficiëntie zeker worden bereikt. Als u deze ontwerpcriteria uitbreidt over een hele database, kunt u deze efficiëntie in orde van grootte genereren.

Als u de nodige ontwerptijd besteedt aan het selecteren van databasegegevenstypes, kan dit de noodzaak verminderen om dure typeconversies uit te voeren in query's en opgeslagen procedurelogica, bij het vergelijken van kolommen met verschillende gegevenstypes.

In één tabel slaat u bijvoorbeeld een datum op in een Varchar(20) kolom, en in een andere tabel slaat u een datum op in een Datetime kolom. Als u de twee kolommen moet vergelijken, moet u een conversiefunctie van het gegevenstype gebruiken in een query op een van de twee kolommen. Dit is een dure operatie.

Conclusie

SQL-gegevenstypen zijn de kenmerken die zijn gekoppeld aan databasekolommen en -variabelen. Deze attributen kunnen de vorm aannemen van binair, numeriek, karakter en datum/tijd. Zorgvuldige ontwerptijd is nodig om ervoor te zorgen dat kolommen en variabelen worden gedefinieerd met het juiste gegevenstype, om zowel de opslag als de uitvoering van query's te garanderen.