Mysql
 sql >> Base de Dados >  >> RDS >> Mysql

Introdução aos tipos de dados SQL


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 .

  1. Na linha de comando, crie uma tabela chamada BinaryExample como mostrado abaixo:
     CREATE TABLE BinaryExample (
       BinaryCol BINARY (10),
       VarBinaryCol VARBINARY (10)
     );
    

  2. Insira uma linha no BinaryExample tabela:
     INSERT INTO BinaryExample (BinaryCol, VarBinaryCol)
     VALUES (0x4D7953514C, 0x39274D);
    

  3. Selecione os dados do BinaryExample 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 .

  1. Na linha de comando, crie o NumericExample tabela.
     CREATE TABLE NumericExample (
       IntColumn INT,
       SmallIntColumn SMALLINT,
       TinyIntColumn TINYINT
     );
    

  2. Insira os seguintes valores no NumericExample tabela.
     INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn)
     VALUES (3258594758, 32767, 255);
    

    Quando você executa o comando acima, obtém um Out of range erro conforme mostrado na saída abaixo. Você não pode inserir os valores 3258594758 e 255 para IntColumn e TinyIntColumn 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

  3. Atualize os valores da IntColumn e TinyIntColumn colunas e execute novamente o INSERT comando.
     INSERT INTO NumericExample (IntColumn, SmallIntColumn, TinyIntColumn)
     VALUES (2147483647, 32767, 127);
    

  4. Recupere os valores da coluna usando o SELECT 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.

  1. Na linha de comando, crie o ExactNumericExample tabela.
     CREATE TABLE ExactNumericExample (
       DecimalCol DECIMAL(5,2),
       NumericCol NUMERIC(7,2)
     );
    

  2. Insira os seguintes valores no ExactNumericExample tabela.
     INSERT INTO ExactNumericExample (DecimalCol, NumericCol)
     VALUES (123.45, 12345.67);
    

  3. Recupere os valores da coluna usando o SELECT 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.

  1. Na linha de comando, crie o Employee tabela.
     CREATE TABLE Employee (
         LastName VARCHAR(25),
         FirstName VARCHAR(20),
         Sex CHAR(1)
     );
    

  2. Insira os seguintes valores no Employee tabela.
     INSERT INTO Employee (LastName, FirstName, Sex)
     VALUES ('Jones', 'Mary', 'F');
    

  3. Recupere os valores da coluna usando o SELECT 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:
  1. Como observado anteriormente, Tinyint tipos de dados têm ¼ dos requisitos de armazenamento de Int tipos de dados.
  2. A eficiência de recuperação de um Tinyint coluna versus um Int 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.