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

Introduktion til SQL-datatyper

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 .
  1. Fra kommandolinjen skal du oprette en tabel kaldet BinaryExample som vist nedenfor:

     OPRET TABEL BinaryExample ( BinaryCol BINARY (10), VarBinaryCol VARBINARY (10) ); 
  2. Indsæt en række i BinaryExample tabel:

     INSERT INTO BinaryExample (BinaryCol, VarBinaryCol) VALUES (0x4D7953514C, 0x39274D); 
  3. 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 .

  1. Fra kommandolinjen skal du oprette NumericExample tabel.

     CREATE TABLE NumericExample ( IntColumn INT, SmallIntColumn SMALLINT, TinyIntColumn TINYINT ); 
  2. 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ærdierne 3258594758 og 255 til IntColumn og TinyIntColumn henholdsvis. Dette skyldes, at den maksimale SIGNED-værdi for en heltalsdatatype er 2147483647 og den for en TinyInt er 127 .

    FEJL 1264 (22003):Uden for områdeværdi for kolonne 'IntColumn' i række 1 
  3. Opdater værdierne for IntColumn og TinyIntColumn kolonner og kør INSERT igen kommando.

     INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn) VALUES (2147483647, 32767, 127); 
  4. 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.

  1. Fra kommandolinjen skal du oprette ExactNumericExample tabel.

     CREATE TABLE ExactNumericExample ( DecimalCol DECIMAL(5,2), NumericCol NUMERIC(7,2) ); 
  2. Indsæt følgende værdier i ExactNumericExample tabel.

     INSERT INTO ExactNumericExample (DecimalCol, NumericCol) VALUES (123.45, 12345.67); 
  3. 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.

  1. Fra kommandolinjen skal du oprette Medarbejder tabel.

     OPRET TABEL Medarbejder (Efternavn VARCHAR(25), Fornavn VARCHAR(20), Køn CHAR(1) ); 
  2. Indsæt følgende værdier i Medarbejder tabel.

     INDSÆT I Medarbejder (Efternavn, Fornavn, Køn) VÆRDIER ('Jones', 'Mary', 'F'); 
  3. 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:

  1. Som tidligere nævnt, Tinyint datatyper har ¼ af lagerkravene til Int datatyper.
  2. Hentningseffektiviteten af ​​en Tinyint kolonne versus en Int 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.


  1. pg_ctl Tips og tricks

  2. Sådan konverteres decimal til hexadecimal ved hjælp af TO_CHAR() i Oracle

  3. Applikationsstakkens fremtid

  4. Multiplikationsaggregatoperator i SQL