Mysql
 sql >> Datenbank >  >> RDS >> Mysql

Einführung in SQL-Datentypen

Die Auswahl des richtigen Datentyps für eine Tabellenspalte ist eine wichtige Entscheidung. Es reduziert die Notwendigkeit von Datentypkonvertierungen, verbessert die Leistung von Datenbankabfragen und minimiert den Speicherbedarf.

In diesem Handbuch lernen Sie die verschiedenen Datentypen kennen, die in relationalen Datenbankverwaltungssystemen (RDBMS) verwendet werden. Diese Datentypen können beim Erstellen oder Ändern einer Tabelle oder beim Deklarieren von Variablen in gespeicherten Datenbankprozeduren verwendet werden. Einige bekannte RDBMS sind MySQL und PostgreSQL.

SQL-Binärdatentypen

Zum Speichern von Binärdaten (0 oder 1 ), verwenden Sie den BINARY und VARBINARY Datentypen. Der BINARY Der Datentyp speichert binäre Daten fester Länge, während VARBINARY speichert Binärdaten variabler Länge. Diese beiden Datentypen werden zum Speichern von Bitfolgen (0 ’s und 1 's). Ihre Werte werden mithilfe der hexadezimalen Darstellung zugewiesen und abgerufen, was durch das Präfix 0x angezeigt wird . Die Spalten (oder Variablen) der beiden Binary und VarBinary Datentypen werden verwendet, um den Inhalt von Bilddateien wie JPEG, BMP, Dokumentdateien usw. zu speichern.

Zum Beispiel für einen Dezimalwert von 63 , sein Hexadezimalwert wird durch 0x3F dargestellt und sein binäres Bit-String-Äquivalent ist 111111 . Betrachten Sie das folgende Beispiel, um den Wert dieser binären Zeichenfolgen und ihre Speicherung zu verstehen:

Hinweis Sofern nicht anders erwähnt, funktionieren alle Datenbankbefehle, die in diesem Handbuch gezeigt werden, sowohl auf MySQL als auch gut und PostgreSQL .

  1. Erstellen Sie über die Befehlszeile eine Tabelle mit dem Namen BinaryExample wie unten gezeigt:

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

  2. Fügen Sie eine Zeile in das BinaryExample ein Tabelle:

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

  3. Wählen Sie die Daten aus dem BinaryExample aus Tabelle:

     SELECT BinaryCol, VarBinaryCol FROM BinaryExample;

    Die Ausgabe sieht wie folgt aus:

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

Wie Sie sehen können, ist die BinaryCol data wird mit nachgestellten Nullen bis zur maximalen Spaltengröße aufgefüllt, aber die VarBinaryCol Datenspalte ist es nicht. Das liegt daran, dass die Spalten von VarBinaryCol sind als variable Länge definiert.

Hinweis Die maximale Größe (Länge) der Datentypen Binary und VarBinary variiert je nach Datenbankimplementierung. Sie sind im Allgemeinen ziemlich groß (über 8.000 Bytes). Einige Datenbankimplementierungen haben binäre Erweiterungen zu diesen Kerndatentypen, die Daten in Größen von mehreren Gigabyte speichern können.

Numerische SQL-Datentypen

Die verfügbaren numerischen Datentypen können in die folgenden Gruppen unterteilt werden:ganzzahlige numerische Datentypen, exakte numerische Datentypen und ungefähre numerische Datentypen. In den folgenden Abschnitten wird jede Gruppe besprochen.

Ganzzahlige numerische Datentypen

Ganzzahlige Datentypen können Unsigned und Signed sein. Unsigniert kann nur Null und positive Zahlen speichern, wohingegen Signed erlaubt null, positive und negative Zahlen.

Die meisten SQL-Implementierungen unterstützen Integer-Datentypen von INT , SMALLINT , und TINYINT zur Speicherung positiver und negativer ganzer Zahlen. Der ganzzahlige numerische Datentyp, den Sie auswählen, hängt von dem Wertebereich ab, den Sie speichern müssen.

Die folgende Tabelle zeigt die zulässige Speicherung in Bytes für die ganzzahligen numerischen Datentypen und ihre minimalen und maximalen SIGNED-Werte.

Typ Speicher (Bytes) Mindestwert SIGNED Maximalwert SIGNED
INT 4 minus 2^31 (-2147483648) plus 2^31 (2147483647)
SMALLINT 2 minus 2^15 (-32768) plus 2^15 (32767)
TINYINT 1 -128 127

Das folgende Beispiel zeigt die minimalen und maximalen vorzeichenbehafteten Werte von numerischen Integer-Datentypen unter Verwendung einer Tabelle namens NumericExample .

  1. Erstellen Sie über die Befehlszeile das NumericExample Tabelle.

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

  2. Fügen Sie die folgenden Werte in das NumericExample ein Tabelle.

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

    Wenn Sie den obigen Befehl ausführen, erhalten Sie ein Out of range Fehler, wie in der Ausgabe unten gezeigt. Sie können die Werte 3258594758 nicht einfügen und 255 zu IntColumn und TinyIntColumn bzw. Dies liegt daran, dass der maximale SIGNED-Wert für einen ganzzahligen Datentyp 2147483647 ist und die eines TinyInt ist 127 .

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

  3. Aktualisieren Sie die Werte von IntColumn und TinyIntColumn Spalten und führen Sie INSERT erneut aus Befehl.

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

  4. Rufen Sie die Spaltenwerte mit SELECT ab Aussage:

     SELECT IntColumn, SmallIntColumn, TinyIntColumn
 FROM NumericExample;

    Die Ausgabe ähnelt dem folgenden Beispiel:

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

Dezimalnumerische Datentypen (exakt numerisch)

Die Decimal-Datentypen, DECIMAL und NUMERIC , speichern Sie genaue und feste numerische Werte. Diese Datentypen werden auch als exakt numerisch bezeichnet Datentypen. Sie speichern einen ganzzahligen Wert links vom Dezimalkomma und einen Bruchwert rechts vom Dezimalkomma. Sie sind funktional gleichwertig mit den gleichen Speicheranforderungen. Der für diese Typen verwendete Speicher hängt von der angegebenen Genauigkeit und den angegebenen Bereichen ab. Sie können zwischen 2 Byte und 17 Byte lang sein, und ihre Werte können zwischen -10^38 +1 liegen an +10^38 -1 .

Diese beiden Datentypen werden durch eine Präzision definiert und eine Skala . Die Präzision bezeichnet die Anzahl der Stellen links und rechts vom Dezimalpunkt zusammen, während die Skala die Gesamtzahl der Stellen rechts vom Dezimalpunkt angibt. Diese beiden Datentypen werden mit der folgenden Syntax erstellt:

DECIMAL(precision, scale)

oder

NUMERIC(precision,scale)

Das folgende Beispiel zeigt, wie der dezimale numerische Datentyp erstellt und verwendet wird.

  1. Erstellen Sie über die Befehlszeile das ExactNumericExample Tabelle.

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

  2. Fügen Sie die folgenden Werte in das ExactNumericExample ein Tabelle.

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

  3. Rufen Sie die Spaltenwerte mit SELECT ab Aussage:

     SELECT DecimalCol, NumericCol FROM ExactNumericExample;

    Die Ausgabe sieht wie folgt aus:

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

Numerische Fließkomma-Datentypen (ungefähr numerisch)

Die numerischen Fließkomma-Datentypen sind FLOAT und REAL . Sie werden auch ungefähr numerisch genannt Datentypen. Diese Datentypen speichern aufgrund der binären Darstellung von Fließkommadaten einen ungefähren Wert. Die Syntax zum Erstellen einer Gleitkommaspalte oder -variablen lautet wie folgt:

Float(N)

Der Parameter N gibt an, ob das Feld vier oder acht Bytes enthalten soll. Ein Wert von N größer als sieben erfordert acht Bytes; sieben oder weniger erfordern vier Bytes. Die Floating-Genauigkeit für diesen Datentyp reicht von -1.79E + 308 zu 1.79E + 308 .

Ebenso eine Spalte und Variable, die als Datentyp REAL definiert sind belegt vier Byte Speicherplatz und stellt einen Wertebereich von -3.40E + 38 bereit bis 3.40E + 38 .

SQL-Zeichendatentypen

Die Datentypen CHAR und VARCHAR werden verwendet, um Zeichendaten mit einer Länge von bis zu 8.000 Byte zu speichern. Diese beiden Datentypen speichern Zeichenfolgenwerte in Datenbankspalten, unterscheiden sich jedoch darin, wie ihre Werte gespeichert und abgerufen werden. Die Länge des CHAR Der Datentyp bleibt auf seiner angegebenen Länge festgelegt, unabhängig davon, ob dieser Zuordnungsraum verwendet wird oder nicht. Wenn das Leerzeichen nicht verwendet wird, wird die Spalte oder Variable mit zusätzlichen Leerzeichen aufgefüllt. VARCHAR gibt den Wert so aus, wie er ist, ohne zusätzliche Leerzeichen.

Das folgende Beispiel demonstriert den Zeichendatentyp.

  1. Erstellen Sie über die Befehlszeile den Employee Tabelle.

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

  2. Fügen Sie die folgenden Werte in den Employee ein Tabelle.

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

  3. Rufen Sie die Spaltenwerte mit SELECT ab Aussage:

     SELECT LastName, FirstName, Sex FROM Employee;

    Die Ausgabe würde wie folgt aussehen:

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

Die Spalten LastName und Firstname sind als Typ Varchar deklariert . Dadurch können Namen so lang sein wie die Datentypdefinition. Aber für Namen, die kürzer als das angegebene Maximum sind, werden keine Leerzeichen an die Daten in diesen Spalten angehängt.

SQL-Datentyp für Datum und Uhrzeit

Die DATETIME Der Datentyp wird verwendet, um die Datums- und Uhrzeitwerte in der Datenbank zu speichern. Werte für DATETIME Datentyp verwenden vier Bytes Speicherplatz für den Datumsteil und vier Bytes für den Zeitteil. Der Zeitteil dieses Datentyps gibt die Zeit mit einer Granularität bis zur Anzahl von Millisekunden nach Mitternacht an. Die Genauigkeit für diesen Datentyp reicht von „1. Januar 1753“ bis „31. Dezember 9999“ mit einer Genauigkeit von 3,33 Millisekunden.

Hinweis Wenn Sie einem DATETIME nur den Datumswert zuweisen Datentyp-Spalte oder -Variable, der Zeitteil ist standardmäßig Mitternacht.

Das folgende Beispiel demonstriert den DATETIME Datentyp.

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

Die Ausgabe sieht wie folgt aus:

+----------+-----------+
| BirthDate            |
+----------+-----------+
| 1990-01-01 09:00:00  |
+----------+-----------+
Hinweis Einige SQL-Implementierungen unterstützen zusätzliche Datentypen, die entweder eine Teilmenge, eine Obermenge oder eine Variante aller oben angegebenen Datentypen sind.

Überlegungen zum SQL-Datentyp

Beim Entwerfen einer Datenbank ist es äußerst wichtig, geeignete Datentypen für Tabellenspalten und gespeicherte Prozedurvariablen sorgfältig auszuwählen.

Die getroffenen Entscheidungen können sich erheblich auf die Speichereffizienz und die Gesamtleistung der Datenbank auswirken. Ein einfaches Beispiel ist die Definition des Age einer Person Spalte vom Typ Tinyint sein Datentyp, im Gegensatz zu Int Datentyp. Dies hat folgende Gründe:

  1. Wie bereits erwähnt, Tinyint Datentypen haben ¼ der Speicheranforderungen von Int Datentypen.
  2. Die Abrufeffizienz eines Tinyint Spalte gegenüber einem Int Spalte ist viel größer.

Oberflächlich betrachtet scheint dies kein großes Problem zu sein. Wenn die betroffene Tabelle jedoch Millionen von Zeilen enthält, können sicherlich sowohl Speicher- als auch Leistungseffizienz erreicht werden. Wenn Sie diese Entwurfskriterien auf eine gesamte Datenbank ausdehnen, können Sie diese Effizienzen um Größenordnungen generieren.

Wenn Sie die erforderliche Entwurfszeit für die Auswahl des Datenbankdatentyps aufwenden, kann dies möglicherweise die Notwendigkeit verringern, teure Typkonvertierungen in Abfragen und in der Logik gespeicherter Prozeduren durchzuführen, wenn Spalten verschiedener Datentypen verglichen werden.

Beispielsweise speichern Sie in einer Tabelle ein Datum in einem Varchar(20) Spalte und in einer anderen Tabelle speichern Sie ein Datum in einem Datetime Säule. Wenn Sie die beiden Spalten vergleichen müssen, müssen Sie eine Datentypkonvertierungsfunktion in einer Abfrage für eine der beiden Spalten verwenden. Dies ist eine teure Operation.

Schlussfolgerung

SQL-Datentypen sind die Attribute, die Datenbankspalten und -variablen zugeordnet sind. Diese Attribute können binär, numerisch, Zeichen und Datum/Uhrzeit sein. Es ist eine sorgfältige Entwurfszeit erforderlich, um sicherzustellen, dass Spalten und Variablen mit einem korrekten Datentyp definiert werden, um sowohl die Speicher- als auch die Abfrageausführungseffizienz sicherzustellen.