sql >> Base de Datos >  >> RDS >> Mysql

Introducción a los tipos de datos SQL

Elegir el tipo de datos adecuado para una columna de tabla es una decisión importante. Reduce la necesidad de conversiones de tipos de datos, mejora el rendimiento de las consultas de la base de datos y minimiza los requisitos de almacenamiento.

En esta guía, explorará los diversos tipos de datos que se utilizan en los sistemas de administración de bases de datos relacionales (RDBMS). Estos tipos de datos se pueden usar al crear o modificar una tabla, o al declarar variables en los procedimientos almacenados de la base de datos. Algunos RDBMS conocidos son MySQL y PostgreSQL.

Tipos de datos binarios de SQL

Para almacenar datos binarios (0 o 1 ), usas el BINARY y VARBINARY tipos de datos. El BINARY El tipo de datos almacena datos binarios de longitud fija, mientras que VARBINARY almacena datos binarios de longitud variable. Ambos tipos de datos se utilizan para almacenar cadenas de bits (0 y 1 's). Sus valores se asignan y recuperan mediante representación hexadecimal, que se indica con un prefijo de 0x . Las columnas (o variables) tanto del Binary y VarBinary los tipos de datos se utilizan para almacenar el contenido de archivos de imagen como JPEG, BMP, archivos de documentos, etc.

Por ejemplo, para un valor decimal de 63 , su valor hexadecimal está representado por 0x3F y su cadena de bits binaria equivalente es 111111 . Para comprender el valor de estas cadenas binarias y cómo se almacenan, considere el siguiente ejemplo:

Nota A menos que se indique lo contrario, todos los comandos de base de datos que se muestran en esta guía funcionan bien tanto en MySQL y PostgreSQL .

  1. Desde la línea de comando, cree una tabla llamada BinaryExample como se muestra a continuación:

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

  2. Inserta una fila en el BinaryExample tabla:

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

  3. Seleccione los datos del BinaryExample tabla:

     SELECT BinaryCol, VarBinaryCol FROM BinaryExample;

    El resultado es el siguiente:

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

Como puede ver, el BinaryCol los datos se rellenan al tamaño máximo de columna con ceros finales, pero el VarBinaryCol la columna de datos no lo es. Esto se debe a que las columnas de VarBinaryCol se definen como de longitud variable.

Nota El tamaño máximo (longitud) de los tipos de datos Binary y VarBinary varía según la implementación de la base de datos. Por lo general, son bastante grandes (más de 8000 bytes). Algunas implementaciones de bases de datos tienen extensiones binarias para estos tipos de datos centrales que pueden almacenar datos en tamaños de varios gigabytes.

Tipos de datos numéricos de SQL

Los tipos de datos numéricos disponibles se pueden dividir en los siguientes grupos:tipos de datos numéricos enteros, tipos de datos numéricos exactos y tipos de datos numéricos aproximados. Las siguientes secciones analizan cada grupo.

Tipos de datos numéricos enteros

Los tipos de datos enteros pueden ser Sin firmar y Firmados. Sin firmar puede almacenar solo cero y números positivos, mientras que Firmado permite números cero, positivos y negativos.

La mayoría de las implementaciones de SQL admiten tipos de datos enteros de INT , SMALLINT y TINYINT para el almacenamiento de números enteros positivos y negativos. El tipo de datos numéricos enteros que elija depende del rango de valores que necesite almacenar.

La siguiente tabla muestra el almacenamiento permitido en bytes para los tipos de datos numéricos enteros y sus valores SIGNED mínimos y máximos.

Tipo Almacenamiento (bytes) Valor mínimo FIRMADO Valor máximo FIRMADO
INT 4 menos 2^31 (-2147483648) más 2^31 (2147483647)
SMALLINT 2 menos 2^15 (-32768) más 2^15 (32767)
TINYINT 1 -128 127

El siguiente ejemplo demuestra los valores mínimos y máximos con signo de los tipos de datos numéricos Integer usando una tabla llamada NumericExample .

  1. Desde la línea de comando, cree el NumericExample mesa.

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

  2. Inserte los siguientes valores en el NumericExample mesa.

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

    Cuando ejecuta el comando anterior, obtiene un Out of range error como se muestra en el resultado a continuación. No puede insertar los valores 3258594758 y 255 a IntColumn y TinyIntColumn respectivamente. Esto se debe a que el valor máximo FIRMADO para un tipo de datos entero es 2147483647 y el de un TinyInt es 127 .

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

  3. Actualice los valores de IntColumn y TinyIntColumn columnas y vuelva a ejecutar INSERT comando.

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

  4. Recupere los valores de la columna usando SELECT declaración:

     SELECT IntColumn, SmallIntColumn, TinyIntColumn
 FROM NumericExample;

    El resultado se parece al siguiente ejemplo:

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

Tipos de datos numéricos decimales (numéricos exactos)

Los tipos de datos decimales, DECIMAL y NUMERIC , almacenar valores numéricos exactos y fijos. Estos tipos de datos también se conocen como numéricos exactos. tipos de datos. Almacenan un valor entero a la izquierda del punto decimal y un valor fraccionario a la derecha del punto decimal. Son funcionalmente equivalentes con los mismos requisitos de almacenamiento. El almacenamiento utilizado para estos tipos depende de la precisión y los rangos especificados. Pueden variar de 2 bytes a 17 bytes, y sus valores pueden variar desde -10^38 +1 a +10^38 -1 .

Estos dos tipos de datos están definidos por una precisión y una escala . La precisión denota el número de lugares a la izquierda y derecha del punto decimal combinado, mientras que la escala denota el número total de dígitos a la derecha del punto decimal. Estos dos tipos de datos se crean usando la siguiente sintaxis:

DECIMAL(precision, scale)

o

NUMERIC(precision,scale)

El siguiente ejemplo muestra cómo crear y utilizar el tipo de datos numérico decimal.

  1. Desde la línea de comando, cree el ExactNumericExample mesa.

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

  2. Inserte los siguientes valores en el ExactNumericExample mesa.

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

  3. Recupere los valores de la columna usando SELECT declaración:

     SELECT DecimalCol, NumericCol FROM ExactNumericExample;

    El resultado es similar al siguiente:

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

Tipos de datos numéricos de punto flotante (numérico aproximado)

Los tipos de datos numéricos de coma flotante son FLOAT y REAL . También se les llama numérico aproximado tipos de datos. Estos tipos de datos almacenan un valor aproximado debido a la representación binaria de los datos de coma flotante. La sintaxis para crear una columna o variable de coma flotante es la siguiente:

Float(N)

El parámetro N indica si el campo debe contener cuatro u ocho bytes. Un valor de N más de siete requiere ocho bytes; siete o menos requiere cuatro bytes. La precisión flotante para este tipo de datos oscila entre -1.79E + 308 a 1.79E + 308 .

De manera similar, una columna y una variable definidas como tipo de datos REAL ocupa cuatro bytes de almacenamiento y proporciona un rango de valores desde -3.40E + 38 a 3.40E + 38 .

Tipos de datos de caracteres SQL

Los tipos de datos CHAR y VARCHAR se utilizan para almacenar datos de caracteres de hasta 8.000 bytes de longitud. Ambos tipos de datos almacenan valores de cadena en las columnas de la base de datos, pero difieren en cómo se almacenan y recuperan sus valores. La longitud del CHAR el tipo de datos permanece fijo en su longitud especificada, ya sea que se utilice o no ese espacio de asignación. Si no se utiliza el espacio, la columna o variable se rellena con espacios adicionales. VARCHAR genera el valor tal como es, sin espacios adicionales.

El siguiente ejemplo demuestra el tipo de datos de caracteres.

  1. Desde la línea de comando, crea el Employee mesa.

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

  2. Inserte los siguientes valores en el Employee mesa.

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

  3. Recupere los valores de la columna usando SELECT declaración:

     SELECT LastName, FirstName, Sex FROM Employee;

    La salida sería la siguiente:

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

Las columnas LastName y Firstname se declaran tipo Varchar . Esto permite que los nombres sean tan largos como la definición del tipo de datos. Pero para nombres más cortos que el máximo especificado, no se agregan espacios en blanco a los datos en estas columnas.

Tipo de datos SQL de fecha y hora

El DATETIME El tipo de datos se utiliza para almacenar los valores de fecha y hora en la base de datos. Valores para el DATETIME El tipo de datos utiliza cuatro bytes de almacenamiento para la parte de la fecha y cuatro bytes para la parte de la hora. La porción de tiempo de este tipo de datos especifica el tiempo con una granularidad hasta el número de milisegundos después de la medianoche. La precisión para este tipo de datos va desde el "1 de enero de 1753" hasta el "31 de diciembre de 9999", con una precisión de 3,33 milisegundos.

Nota Si asigna solo el valor de la fecha a un DATETIME columna o variable de tipo de datos, la porción de tiempo predeterminada es medianoche.

El siguiente ejemplo demuestra el DATETIME tipo de datos.

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

El resultado es similar al siguiente:

+----------+-----------+
| BirthDate            |
+----------+-----------+
| 1990-01-01 09:00:00  |
+----------+-----------+
Nota Algunas implementaciones de SQL admiten tipos de datos adicionales, que son un subconjunto, un superconjunto o una variante de todos los tipos de datos especificados anteriormente.

Consideraciones sobre tipos de datos SQL

Al diseñar una base de datos, es extremadamente importante seleccionar cuidadosamente los tipos de datos apropiados para las columnas de la tabla y las variables del procedimiento almacenado.

Las elecciones realizadas pueden tener un impacto significativo en la eficiencia del almacenamiento y el rendimiento general de la base de datos. Un ejemplo simple es definir la Age de una persona columna para ser del Tinyint tipo de datos, a diferencia del Int tipo de datos. Esto se debe a las siguientes razones:

  1. Como se señaló anteriormente, Tinyint los tipos de datos tienen ¼ de los requisitos de almacenamiento de Int tipos de datos.
  2. La eficiencia de recuperación de un Tinyint columna versus un Int columna es mucho mayor.

En la superficie, esto puede no parecer una gran preocupación. Pero, si la tabla afectada tiene millones de filas, ciertamente se pueden lograr eficiencias tanto de almacenamiento como de rendimiento. Si extiende este criterio de diseño a toda una base de datos, puede generar estas eficiencias por órdenes de magnitud.

Pasar el tiempo de diseño necesario en la selección del tipo de datos de la base de datos puede mitigar potencialmente la necesidad de realizar conversiones de tipos costosas en consultas y lógica de procedimientos almacenados, al comparar columnas de diferentes tipos de datos.

Por ejemplo, en una tabla, almacena una fecha en un Varchar(20) columna, y en otra tabla almacena una fecha en un Datetime columna. Si necesita comparar las dos columnas, debe usar una función de conversión de tipos de datos en una consulta en una de las dos columnas. Esta es una operación costosa.

Conclusión

Los tipos de datos SQL son los atributos asociados con las columnas y variables de la base de datos. Estos atributos pueden ser binarios, numéricos, de carácter y de fecha/hora. Es necesario un tiempo de diseño cuidadoso para garantizar que las columnas y las variables se definan con un tipo de datos correcto, para garantizar la eficiencia tanto en el almacenamiento como en la ejecución de consultas.