At vælge den korrekte datatype for en tabelkolonne er en vigtig beslutning. Det reducerer behovet for datatypekonverteringer, forbedrer ydeevnen af databaseforespørgsler og minimerer lagerkravene.
I denne vejledning udforsker du de forskellige datatyper, der bruges i relationelle databasestyringssystemer (RDBMS). Disse datatyper kan bruges, når du opretter eller ændrer en tabel, eller når du erklærer variabler i databaselagrede procedurer. Nogle velkendte RDBMS er MySQL og PostgreSQL.
SQL binære datatyper
For at gemme binære data (0
eller 1
), bruger du BINÆR
og VARBINARY
datatyper. Den BINÆRE
datatypen gemmer binære data med fast længde, mens VARBINARY
gemmer binære data med variabel længde. Begge disse datatyper bruges til at gemme strenge af bit (0
's og 1
's). Deres værdier tildeles og hentes ved hjælp af hexadecimal repræsentation, som er angivet med præfikset 0x
. Kolonnerne (eller variablerne) i både Binær
og VarBinary
datatyper bruges til at gemme indholdet af billedfiler såsom JPEG, BMP, dokumentfiler osv.
For eksempel for en decimalværdi på 63
, er dens hexadecimale værdi repræsenteret af 0x3F
og dens binære bitstrengækvivalent er 111111
. For at forstå værdien af disse binære strenge, og hvordan de lagres, skal du overveje eksemplet nedenfor:
Bemærk Medmindre andet er nævnt, fungerer alle databasekommandoer, der er vist i denne vejledning, godt på både MySQL og PostgreSQL .
-
Fra kommandolinjen skal du oprette en tabel kaldet
BinaryExample
som vist nedenfor:OPRET TABEL BinaryExample ( BinaryCol BINARY (10), VarBinaryCol VARBINARY (10) );
-
Indsæt en række i
BinaryExample
tabel:INSERT INTO BinaryExample (BinaryCol, VarBinaryCol) VALUES (0x4D7953514C, 0x39274D);
-
Vælg data fra
BinaryExample
tabel:VÆLG BinaryCol, VarBinaryCol FRA BinaryExample;
Outputtet ser ud som følger:
+------------------------+------------------------ ----------+| BinaryCol | VarBinaryCol |+------------------------+-------------------------------- ------+| 0x4D7953514C0000000000 | 0x39274D |+------------------------+-------------------------------- ------+
Som du kan se, er BinaryCol
data udfyldes til den maksimale kolonnestørrelse med efterfølgende nuller, men VarBinaryCol
datakolonnen er det ikke. Dette skyldes, at kolonnerne i VarBinaryCol
er defineret som variabel længde.
Bemærk Den maksimale størrelse (længde) af binære og VarBinære datatyper varierer afhængigt af databaseimplementeringen. De er generelt ret store (over 8.000 bytes). Nogle databaseimplementeringer har binære udvidelser til disse kernedatatyper, der kan gemme data i størrelser på multi-gigabyte.
SQL numeriske datatyper
De tilgængelige numeriske datatyper kan opdeles i følgende grupper:Heltals numeriske datatyper, nøjagtige numeriske datatyper og Tilnærmede numeriske datatyper. Afsnittene nedenfor diskuterer hver gruppe.
Heltals numeriske datatyper
Heltalsdatatyper kan være Unsigned og Signed. Usigneret kan kun gemme nul og positive tal, hvorimod Underskrevet tillader nul, positive og negative tal.
De fleste SQL-implementeringer understøtter heltalsdatatyper af INT
, SMALLINT
og TINYINT
til lagring af positive og negative hele tal. Den heltal numeriske datatype, som du vælger, afhænger af rækken af værdier, du skal gemme.
Følgende tabel viser den tilladte lagring i bytes for de heltallige numeriske datatyper og deres minimum og maksimum SIGNED-værdier.
Type | Lagerplads (bytes) | Minimumsværdi SIGNERT | Maksimal værdi SIGNERT |
---|---|---|---|
INT | 4 | minus 2^31 (-2147483648) | plus 2^31 (2147483647) |
SMALLINT | 2 | minus 2^15 (-32768) | plus 2^15 (32767) |
TINYINT | 1 | -128 | 127 |
Eksemplet nedenfor viser minimum og maksimum fortegnsværdier af heltal numeriske datatyper ved hjælp af en tabel med navnet NumericExample
.
-
Fra kommandolinjen skal du oprette
NumericExample
tabel.CREATE TABLE NumericExample ( IntColumn INT, SmallIntColumn SMALLINT, TinyIntColumn TINYINT );
-
Indsæt følgende værdier i
NumericExample
tabel.INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn) VALUES (3258594758, 32767, 255);
Når du udfører ovenstående kommando får du en
Udenfor rækkevidde
fejl som vist i outputtet nedenfor. Du kan ikke indsætte værdierne3258594758
og255
tilIntColumn
ogTinyIntColumn
henholdsvis. Dette skyldes, at den maksimale SIGNED-værdi for en heltalsdatatype er2147483647
og den for en TinyInt er127
.FEJL 1264 (22003):Uden for områdeværdi for kolonne 'IntColumn' i række 1
-
Opdater værdierne for
IntColumn
ogTinyIntColumn
kolonner og kørINSERT
igen kommando.INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn) VALUES (2147483647, 32767, 127);
-
Hent kolonneværdierne ved hjælp af
SELECT
erklæring:VÆLG IntColumn, SmallIntColumn, TinyIntColumn FRA NumericExample;
Outputtet ligner eksemplet nedenfor:
+-------------+----------------+------------ --+| IntColumn | SmallIntColumn | TinyIntColumn |+------------+----------------+-------------+| 2147483647 | 32767 | 127 |+------------+----------------+-------------+
Decimale numeriske datatyper (eksakte numeriske)
Decimaldatatyperne, DECIMAL
og NUMERIC
, gem nøjagtige og faste numeriske værdier. Disse datatyper er også kendt som nøjagtige numeriske datatyper. De gemmer en heltalsværdi til venstre for decimaltegnet og en brøkværdi til højre for decimalkommaet. De er funktionelt ækvivalente med de samme opbevaringskrav. Den lagring, der bruges til disse typer, afhænger af den specificerede præcision og intervaller. De kan variere fra 2 bytes til 17 bytes, og deres værdier kan variere fra -10^38 +1
til +10^38 -1
.
Disse to datatyper er defineret af en præcision og en skala . Præcisionen angiver antallet af pladser til venstre og højre for decimaltegnet kombineret, hvorimod skalaen angiver det samlede antal cifre til højre for decimaltegnet. Disse to datatyper oprettes ved hjælp af følgende syntaks:
DECIMAL(præcision, skala)
eller
NUMERIC(præcision,skala)
Eksemplet nedenfor viser, hvordan du opretter og bruger den numeriske decimaldatatype.
-
Fra kommandolinjen skal du oprette
ExactNumericExample
tabel.CREATE TABLE ExactNumericExample ( DecimalCol DECIMAL(5,2), NumericCol NUMERIC(7,2) );
-
Indsæt følgende værdier i
ExactNumericExample
tabel.INSERT INTO ExactNumericExample (DecimalCol, NumericCol) VALUES (123.45, 12345.67);
-
Hent kolonneværdierne ved hjælp af
SELECT
erklæring:VÆLG DecimalCol, NumericCol FRA ExactNumericExample;
Outputtet ligner følgende:
+------------+------------+| DecimalKol | NumericCol |+------------+-------------+| 123,45 | 12345.67 |+-------------+--------+
Numeriske flydende kommadatatyper (omtrentlig numerisk)
De numeriske datatyper med flydende komma er FLOAT
og REAL
. De kaldes også omtrentlig numeriske datatyper. Disse datatyper gemmer en omtrentlig værdi på grund af den binære repræsentation af flydende kommadata. Syntaksen til at oprette en kolonne eller variabel med flydende komma er følgende:
Float(N)
Parameteren N
angiver, om feltet skal indeholde fire eller otte bytes. En værdi på N
større end syv kræver otte bytes; syv eller mindre kræver fire bytes. Flydende præcision for denne datatype spænder fra -1,79E + 308
til 1.79E + 308
.
På samme måde er en kolonne og variabel defineret som datatype REAL
fylder fire bytes lager og giver en række værdier fra -3.40E + 38
til 3.40E + 38
.
SQL-tegndatatyper
Datatyperne CHAR
og VARCHAR
bruges til at gemme tegndata på op til 8.000 bytes i længden. Begge disse datatyper gemmer strengværdier i databasekolonner, men de adskiller sig i, hvordan deres værdier gemmes og hentes. Længden af CHAR
datatypen forbliver fast i dens specificerede længde, uanset om denne allokeringsplads udnyttes eller ej. Hvis pladsen ikke udnyttes, udfyldes kolonnen eller variablen med ekstra mellemrum. VARCHAR
udlæser værdien, som den er, uden yderligere mellemrum.
Eksemplet nedenfor viser tegndatatypen.
-
Fra kommandolinjen skal du oprette
Medarbejder
tabel.OPRET TABEL Medarbejder (Efternavn VARCHAR(25), Fornavn VARCHAR(20), Køn CHAR(1) );
-
Indsæt følgende værdier i
Medarbejder
tabel.INDSÆT I Medarbejder (Efternavn, Fornavn, Køn) VÆRDIER ('Jones', 'Mary', 'F');
-
Hent kolonneværdierne ved hjælp af
SELECT
erklæring:VÆLG Efternavn, Fornavn, Køn FRA medarbejder;
Outputtet vil gerne have følgende:
+----------+------------+------+| Efternavn | Fornavn | Køn |+----------+------------+------+| Jones | Mary | F |+----------+------------+------+
Kolonnerne Efternavn
og Fornavn
er erklæret type Varchar
. Dette tillader navne at være lige så lange som datatypedefinitionen. Men for navne, der er kortere end det angivne maksimum, tilføjes der ingen tomme mellemrum til dataene i disse kolonner.
SQL dato og klokkeslæt datatype
DATETIME
datatypen bruges til at gemme dato- og tidsværdierne i databasen. Værdier for DATETIME
datatype bruger fire bytes lager til datodelen og fire bytes til tidsdelen. Tidsdelen af denne datatype angiver tid med en granularitet ned til antallet af millisekunder efter midnat. Præcisionen for denne datatype spænder fra "1. januar 1753" til "31. december 9999", med en nøjagtighed på 3,33 millisekunder.
Bemærk Hvis du kun tildeler datoværdien til en DATETIME
datatype kolonne eller variabel, er tidsdelen som standard midnat.
Eksemplet nedenfor viser DATETIME
datatype.
DELIMITER //CREATE PROCEDURE Datetimedemo()BEGINDECLARE Fødselsdato DATETIMESET Fødselsdato ='1990-01-01 09:00:00'VÆLG FødselsdatoEND//DELIMITER;call Datetimedemo;
Outputtet ligner følgende:
+----------+-----------+| Fødselsdato |+----------+-----------+| 1990-01-01 09:00:00 |+-----------+-----------+
Bemærk Nogle SQL-implementeringer understøtter yderligere datatyper, som enten er et undersæt, et supersæt eller en variant af alle ovennævnte datatyper.
SQL-datatypeovervejelser
Når du designer en database, er det ekstremt vigtigt at omhyggeligt vælge passende datatyper til tabelkolonner og lagrede procedurevariabler.
Valg, der træffes, kan have en betydelig indvirkning på lagereffektiviteten og den overordnede databaseydeevne. Et simpelt eksempel er at definere en persons Alder
kolonne til at være af Tinyint
datatype, i modsætning til Int
datatype. Dette er på grund af følgende årsager:
- Som tidligere nævnt,
Tinyint
datatyper har ¼ af lagerkravene tilInt
datatyper. - Hentningseffektiviteten af en
Tinyint
kolonne versus enInt
kolonnen er meget større.
På overfladen ser dette måske ikke ud til at være af stor bekymring. Men hvis den berørte tabel har millioner af rækker i sig, kan både lagring og ydeevne helt sikkert opnås. Hvis du udvider dette designkriterie på tværs af en hel database, kan du generere disse effektivitetsgevinster i størrelsesordener.
At bruge den nødvendige designtid på valg af databasedatatype kan potentielt mindske behovet for at udføre dyre typekonverteringer i forespørgsler og lagret procedurelogik, når man sammenligner kolonner med forskellige datatyper.
For eksempel, i en tabel gemmer du en dato i en Varchar(20)
kolonne, og i en anden tabel gemmer du en dato i en Datetime
kolonne. Hvis du skal sammenligne de to kolonner, skal du bruge en datatypekonverteringsfunktion i en forespørgsel på en af de to kolonner. Dette er en dyr operation.
Konklusion
SQL-datatyper er de attributter, der er knyttet til databasekolonner og variabler. Disse attributter kan have form af at være binære, numeriske, tegn og dato/klokkeslæt. Omhyggelig designtid er nødvendig for at sikre, at kolonner og variabler er defineret med en korrekt datatype, for at sikre både lager- og forespørgselsudførelseseffektivitet.