Escolher o tipo de dados adequado para uma coluna da tabela é uma decisão importante. Reduz a necessidade de conversões de tipo de dados, melhora o desempenho das consultas de banco de dados e minimiza os requisitos de armazenamento.
Neste guia, você explora os vários tipos de dados que são usados em sistemas de gerenciamento de banco de dados relacional (RDBMS). Esses tipos de dados podem ser usados ao criar ou alterar uma tabela ou ao declarar variáveis em procedimentos armazenados do banco de dados. Alguns RDBMS conhecidos são MySQL e PostgreSQL.
Tipos de dados binários do SQL
Para armazenar dados binários (
0
ou 1
), você usa o BINARY
e VARBINARY
tipos de dados. O BINARY
tipo de dados armazena dados binários de comprimento fixo, enquanto VARBINARY
armazena dados binários de comprimento variável. Ambos os tipos de dados são usados para armazenar strings de bits (0
's e 1
s). Seus valores são atribuídos e recuperados usando representação hexadecimal, que é indicada por um prefixo de 0x
. As colunas (ou variáveis) do Binary
e VarBinary
tipos de dados são usados para armazenar o conteúdo de arquivos de imagem como JPEG, BMP, arquivos de documentos, etc. Por exemplo, para um valor decimal de
63
, seu valor hexadecimal é representado por 0x3F
e seu equivalente de string de bits binários é 111111
. Para entender o valor dessas strings binárias e como elas são armazenadas, considere o exemplo abaixo:Observação A menos que mencionado de outra forma, todos os comandos de banco de dados demonstrados neste guia funcionam bem tanto em MySQL e PostgreSQL .
-
Na linha de comando, crie uma tabela chamadaBinaryExample
como mostrado abaixo:
CREATE TABLE BinaryExample ( BinaryCol BINARY (10), VarBinaryCol VARBINARY (10) );
-
Insira uma linha noBinaryExample
tabela:
INSERT INTO BinaryExample (BinaryCol, VarBinaryCol) VALUES (0x4D7953514C, 0x39274D);
-
Selecione os dados doBinaryExample
tabela:
SELECT BinaryCol, VarBinaryCol FROM BinaryExample;
A saída tem a seguinte aparência:
+------------------------+----------------------------+ | BinaryCol | VarBinaryCol | +------------------------+----------------------------+ | 0x4D7953514C0000000000 | 0x39274D | +------------------------+----------------------------+
Como você pode ver, o
BinaryCol
os dados são preenchidos até o tamanho máximo da coluna com zeros à direita, mas o VarBinaryCol
coluna de dados não é. Isso ocorre porque as colunas de VarBinaryCol
são definidos como comprimento variável. Observação O tamanho máximo (comprimento) dos tipos de dados Binary e VarBinary varia dependendo da implementação do banco de dados. Eles geralmente são muito grandes (mais de 8.000 bytes). Algumas implementações de banco de dados têm extensões binárias para esses tipos de dados principais que podem armazenar dados em tamanhos de vários gigabytes.
Tipos de dados numéricos SQL
Os tipos de dados numéricos disponíveis podem ser divididos nos seguintes grupos:tipos de dados numéricos inteiros, tipos de dados numéricos exatos e tipos de dados numéricos aproximados. As seções abaixo discutem cada grupo.
Tipos de dados numéricos inteiros
Os tipos de dados inteiros podem ser não assinados e assinados. Não assinado pode armazenar apenas números zero e positivos, enquanto Signed permite números zero, positivos e negativos.
A maioria das implementações SQL suporta tipos de dados inteiros de
INT
, SMALLINT
e TINYINT
para armazenamento de números inteiros positivos e negativos. O tipo de dados numérico inteiro escolhido depende do intervalo de valores que você precisa armazenar. A tabela a seguir exibe o armazenamento permitido em bytes para os tipos de dados numéricos inteiros e seus valores SIGNED mínimo e máximo.
Tipo | Armazenamento (bytes) | Valor mínimo ASSINADO | Valor máximo ASSINADO |
---|---|---|---|
INT | 4 | menos 2^31 (-2147483648) | mais 2^31 (2147483647) |
SMALLINT | 2 | menos 2^15 (-32768) | mais 2^15 (32767) |
TINYINT | 1 | -128 | 127 |
O exemplo abaixo demonstra os valores com sinal mínimo e máximo dos tipos de dados numéricos Integer usando uma tabela chamada
NumericExample
. -
Na linha de comando, crie oNumericExample
tabela.
CREATE TABLE NumericExample ( IntColumn INT, SmallIntColumn SMALLINT, TinyIntColumn TINYINT );
-
Insira os seguintes valores noNumericExample
tabela.
INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn) VALUES (3258594758, 32767, 255);
Quando você executa o comando acima, obtém umOut of range
erro conforme mostrado na saída abaixo. Você não pode inserir os valores3258594758
e255
paraIntColumn
eTinyIntColumn
respectivamente. Isso ocorre porque o valor SIGNED máximo para um tipo de dados inteiro é2147483647
e a de um TinyInt é127
.
ERROR 1264 (22003): Out of range value for column 'IntColumn' at row 1
-
Atualize os valores daIntColumn
eTinyIntColumn
colunas e execute novamente oINSERT
comando.
INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn) VALUES (2147483647, 32767, 127);
-
Recupere os valores da coluna usando oSELECT
demonstração:
SELECT IntColumn, SmallIntColumn, TinyIntColumn FROM NumericExample;
A saída se assemelha ao exemplo abaixo:
+------------+----------------+---------------+ | IntColumn | SmallIntColumn | TinyIntColumn | +------------+----------------+---------------+ | 2147483647 | 32767 | 127 | +------------+----------------+---------------+
Tipos de dados numéricos decimais (numéricos exatos)
Os tipos de dados Decimal,
DECIMAL
e NUMERIC
, armazena valores numéricos exatos e fixos. Esses tipos de dados também são conhecidos como numéricos exatos tipos de dados. Eles armazenam um valor inteiro à esquerda do ponto decimal e um valor fracionário à direita do ponto decimal. Eles são funcionalmente equivalentes com os mesmos requisitos de armazenamento. O armazenamento usado para esses tipos depende da precisão e dos intervalos especificados. Eles podem variar de 2 bytes a 17 bytes, e seus valores podem variar de -10^38 +1
para +10^38 -1
. Esses dois tipos de dados são definidos por uma precisão e uma escala . A precisão denota o número de casas à esquerda e à direita do ponto decimal combinado, enquanto a escala denota o número total de dígitos à direita do ponto decimal. Esses dois tipos de dados são criados usando a seguinte sintaxe:
DECIMAL(precision, scale)
ou
NUMERIC(precision,scale)
O exemplo abaixo demonstra como criar e usar o tipo de dados numérico decimal.
-
Na linha de comando, crie oExactNumericExample
tabela.
CREATE TABLE ExactNumericExample ( DecimalCol DECIMAL(5,2), NumericCol NUMERIC(7,2) );
-
Insira os seguintes valores noExactNumericExample
tabela.
INSERT INTO ExactNumericExample (DecimalCol, NumericCol) VALUES (123.45, 12345.67);
-
Recupere os valores da coluna usando oSELECT
demonstração:
SELECT DecimalCol, NumericCol FROM ExactNumericExample;
A saída é semelhante à seguinte:
+------------+------------+ | DecimalCol | NumericCol | +------------+------------+ | 123.45 | 12345.67 | +------------+------------+
Tipos de dados numéricos de ponto flutuante (numéricos aproximados)
Os tipos de dados numéricos de ponto flutuante são
FLOAT
e REAL
. Eles também são chamados de numérico aproximado tipos de dados. Esses tipos de dados armazenam um valor aproximado devido à representação binária dos dados de ponto flutuante. A sintaxe para criar uma coluna ou variável de ponto flutuante é a seguinte:Float(N)
O parâmetro
N
indica se o campo deve conter quatro ou oito bytes. Um valor de N
maior que sete requer oito bytes; sete ou menos requer quatro bytes. A precisão flutuante para este tipo de dados varia de -1.79E + 308
para 1.79E + 308
. Da mesma forma, uma coluna e uma variável definida como tipo de dados
REAL
ocupa quatro bytes de armazenamento e fornece um intervalo de valores de -3.40E + 38
para 3.40E + 38
. Tipos de dados de caracteres SQL
Os tipos de dados
CHAR
e VARCHAR
são usados para armazenar dados de caracteres de até 8.000 bytes de comprimento. Ambos os tipos de dados armazenam valores de string em colunas de banco de dados, mas diferem em como seus valores são armazenados e recuperados. O comprimento do CHAR
tipo de dados permanece fixo em seu comprimento especificado se esse espaço de alocação é utilizado ou não. Se o espaço não for utilizado, a coluna ou variável será preenchida com espaços extras. VARCHAR
emite o valor como está, sem espaços adicionais. O exemplo abaixo demonstra o tipo de dados de caractere.
-
Na linha de comando, crie oEmployee
tabela.
CREATE TABLE Employee ( LastName VARCHAR(25), FirstName VARCHAR(20), Sex CHAR(1) );
-
Insira os seguintes valores noEmployee
tabela.
INSERT INTO Employee (LastName, FirstName, Sex) VALUES ('Jones', 'Mary', 'F');
-
Recupere os valores da coluna usando oSELECT
demonstração:
SELECT LastName, FirstName, Sex FROM Employee;
A saída gostaria do seguinte:
+----------+-----------+------+ | LastName | FirstName | Sex | +----------+-----------+------+ | Jones | Mary | F | +----------+-----------+------+
As colunas
LastName
e Firstname
são declarados tipo Varchar
. Isso permite que os nomes sejam tão longos quanto a definição do tipo de dados. Mas para nomes menores que o máximo especificado, nenhum espaço em branco é anexado aos dados nessas colunas. Tipo de dados de data e hora SQL
O
DATETIME
tipo de dados é usado para armazenar os valores de data e hora no banco de dados. Valores para DATETIME
tipo de dados usa quatro bytes de armazenamento para a parte de data e quatro bytes para a parte de hora. A parte de tempo desse tipo de dados especifica o tempo com uma granularidade até o número de milissegundos após a meia-noite. A precisão para este tipo de dados varia de “1 de janeiro de 1753” a “31 de dezembro de 9999”, com uma precisão de 3,33 milissegundos. Observação Se você atribuir apenas o valor de data a um DATETIME
coluna ou variável de tipo de dados, a parte de hora é padronizada para meia-noite.
O exemplo abaixo demonstra o
DATETIME
tipo de dados. DELIMITER //
CREATE PROCEDURE Datetimedemo()
BEGIN
DECLARE BirthDate DATETIME
SET BirthDate = '1990-01-01 09:00:00'
SELECT BirthDate
END//
DELIMITER ;
call Datetimedemo;
A saída é semelhante à seguinte:
+----------+-----------+
| BirthDate |
+----------+-----------+
| 1990-01-01 09:00:00 |
+----------+-----------+
Observação Algumas implementações SQL suportam tipos de dados adicionais, que são um subconjunto, superconjunto ou variante de todos os tipos de dados especificados acima.
Considerações sobre tipos de dados SQL
Ao projetar um banco de dados, é extremamente importante selecionar cuidadosamente os tipos de dados apropriados para colunas de tabela e variáveis de procedimento armazenado.
As escolhas feitas podem ter um impacto significativo na eficiência do armazenamento e no desempenho geral do banco de dados. Um exemplo simples é definir a
Age
de uma pessoa coluna seja do Tinyint
tipo de dados, em oposição ao Int
tipo de dados. Isso ocorre pelos seguintes motivos:- Como observado anteriormente,
Tinyint
tipos de dados têm ¼ dos requisitos de armazenamento deInt
tipos de dados. - A eficiência de recuperação de um
Tinyint
coluna versus umInt
coluna é muito maior.
Na superfície, isso pode não parecer uma grande preocupação. Mas, se a tabela afetada tiver milhões de linhas, a eficiência de armazenamento e desempenho certamente poderá ser alcançada. Se você estender esses critérios de design em um banco de dados inteiro, poderá gerar essas eficiências em ordens de magnitude.
Gastar o tempo de design necessário na seleção do tipo de dados do banco de dados pode potencialmente mitigar a necessidade de realizar conversões de tipo caras em consultas e lógica de procedimento armazenado, ao comparar colunas de diferentes tipos de dados.
Por exemplo, em uma tabela, você armazena uma data em um
Varchar(20)
coluna e em outra tabela você armazena uma data em um Datetime
coluna. Se você precisar comparar as duas colunas, deverá usar uma função de conversão de tipo de dados em uma consulta em uma das duas colunas. Esta é uma operação cara. Conclusão
Tipos de dados SQL são os atributos associados às colunas e variáveis do banco de dados. Esses atributos podem ser binários, numéricos, caracteres e data/hora. É necessário um tempo de design cuidadoso para garantir que as colunas e variáveis sejam definidas com um tipo de dados correto, para garantir a eficiência do armazenamento e da execução da consulta.