Tipos de dados e tipos de array do Hologres - Hologres: Central de Documentação do Alibaba Cloud

Tipos de dados

A tabela a seguir lista todos os tipos de dados suportados pelo Hologres. A maioria é compatível com o PostgreSQL, enquanto RoaringBitmap, RoaringBitmap64 e SPARSEVECTOR são específicos do Hologres. Todos os nomes de tipos e aliases não diferenciam maiúsculas de minúsculas em SQL, mas são exibidos em maiúsculas por convenção.

Nome	Aliases	Tamanho de armazenamento	Descrição	Faixa de valores	Exemplo
INTEGER	INT, INT4	4 bytes	Inteiro comum.	-2.147.483.648 a +2.147.483.647	2147483647
BIGINT	INT8	8 bytes	Inteiro de faixa ampla.	-9.223.372.036.854.775.808 a +9.223.372.036.854.775.807	9223372036854775807
SMALLINT	—	2 bytes	Inteiro de faixa reduzida.	-32.768 a +32.767	32767
REAL	FLOAT4	4 bytes	Ponto flutuante de precisão variável, inexato. No ecossistema PostgreSQL, `FLOAT` sem precisão especificada assume o padrão `DOUBLE PRECISION` (FLOAT8).	6 dígitos decimais de precisão	123.123
DOUBLE PRECISION	FLOAT8	8 bytes	Ponto flutuante de precisão variável, inexato.	15 dígitos decimais de precisão	123.123456789123
DECIMAL	NUMERIC	Variável	Numérico exato. Especifique tanto PRECISION (total de dígitos, 0–38) quanto SCALE (dígitos após a vírgula decimal, 0–PRECISION). A partir da V4.2, o modo de alta precisão suporta até 76 dígitos: PRECISION (0–76) e SCALE (0–PRECISION).	Até 38 dígitos antes e 38 dígitos depois da vírgula decimal. A partir da V4.2, suporta até 76 dígitos com alta precisão.	DECIMAL(38, 10)
BOOLEAN	BOOL	1 byte	Booleano.	True / False	True
TEXT	—	Variável	String de comprimento variável. Prefira TEXT em vez de VARCHAR(n) ou CHAR(n) para obter máxima flexibilidade.	Nenhum	abcdefg
CHAR(n)	—	Fixo, até n caracteres	String de caracteres de comprimento fixo. O tamanho de armazenamento não excede 1 GB.	Até n caracteres	abcd
VARCHAR(n)	—	Variável, até n caracteres	String de comprimento variável com limite de caracteres. O tamanho de armazenamento não excede 1 GB.	Até n caracteres	abcdefg
TIMESTAMP WITH TIME ZONE	TIMESTAMPTZ	8 bytes	Timestamp com fuso horário, armazenado com precisão de milissegundos. Se nenhum deslocamento de fuso horário for especificado, o sistema adiciona automaticamente o fuso horário padrão aos dados.	4713 a.C. a 294276 d.C.	2004-10-19 10:23:54+02
TIMESTAMP	—	8 bytes	Timestamp sem fuso horário, armazenado com precisão de microssegundos.	4713 a.C. a 5874897 d.C.	2020-01-01 01:01:01.123456
DATE	—	4 bytes	Data, com granularidade de dia.	4713 a.C. a 5874897 d.C.	2004-10-19
TIME	—	8 bytes	Hora do dia sem fuso horário, com precisão de microssegundos.	00:00:00 a 24:00:00	12:00:00
TIMETZ	—	12 bytes	Hora do dia com fuso horário, com precisão de microssegundos.	00:00:00 a 24:00:00	12:00:00+08
INTERVAL	—	16 bytes	Intervalo de tempo.	-178.000.000 anos a 178.000.000 anos	interval '1 year'
JSON	—	Variável	Tipo JSON. Para mais detalhes, consulte .	Nenhum	Nenhum
JSONB	—	Variável	Tipo JSON binário. Para mais detalhes, consulte .	Nenhum	Nenhum
BYTEA	—	Variável	String binária de comprimento variável. O tamanho de armazenamento não excede 1 GB. Para mais detalhes, consulte Binary Data Types.	Nenhum	Nenhum
BIT(n)	—	n bits	String de bits de comprimento fixo. O tamanho de armazenamento não excede 1 GB.	Nenhum	Nenhum
VARBIT(n)	—	Variável, até n bits	String de bits de comprimento variável. O tamanho de armazenamento não excede 1 GB.	Nenhum	Nenhum
INET	—	Variável	Endereço de host IPv4 ou IPv6. Para mais detalhes, consulte Network address types.	Nenhum	192.168.100.128/25
MONEY	—	8 bytes	Valor monetário com precisão fracionária fixa. Para mais detalhes, consulte Currency types.	-92.233.720.368.547.758,08 a +92.233.720.368.547.758,07	12.34 USD
OID	—	4 bytes	Identificador numérico de objeto.	Nenhum	1024
UUID	—	16 bytes	Identificador universalmente único (UUID), valor de comprimento fixo de 128 bits. Os algoritmos uuid-ossp não são suportados atualmente.	00000000-0000-0000-0000-000000000000 a ffffffff-ffff-ffff-ffff-ffffffffffff	a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11
SERIAL	—	Variável	Sequência de incremento automático. Para mais detalhes, consulte Sequência de incremento automático.	Nenhum	Nenhum
RoaringBitmap	—	Variável	Array INT eficiente que suporta operações de bitmap de array constante. Para mais detalhes, consulte RoaringBitmap functions.	Nenhum	Nenhum
RoaringBitmap64	—	Variável	Array BIGINT eficiente que suporta operações de bitmap de array constante. Para mais detalhes, consulte RoaringBitmap functions.	Nenhum	Nenhum
SPARSEVECTOR	—	Variável. Depende do número de elementos não nulos.	Tipo de vetor esparso. Armazena apenas os elementos não nulos e suas posições de índice, sendo adequado para cargas de trabalho de vetores esparsos de alta dimensão, como recuperação de texto e sistemas de recomendação.	Um conjunto de pares índice-valor. As posições de índice são inteiros que começam em 1 e devem ser menores que o valor term_id_limit do índice de vetor esparso; os valores são números de ponto flutuante.	'{1:0.1, 50:0.8, 200:0.3}'
GEOMETRY e GEOGRAPHY	—	Variável. Para mais detalhes, consulte PostGIS-based geographic analysis.	O PostGIS é uma extensão espacial do PostgreSQL que fornece objetos espaciais, índices espaciais, funções de operação espacial e operadores espaciais. O desempenho foi melhorado a partir da V1.3.	Nenhum	Nenhum

Disponibilidade por versão: Os tipos não disponíveis em todas as versões foram adicionados em releases específicos:

Tipo	Adicionado em
DATE, TIMESTAMP, CHAR(n), VARCHAR(n), SERIAL	Hologres V0.8
SMALLINT, JSON, JSONB, BYTEA, BIT(n), VARBIT(n), TIMETZ, TIME, INET, MONEY, OID, UUID	Hologres V0.9
RoaringBitmap	Hologres V0.10
RoaringBitmap64	Hologres V3.1
SPARSEVECTOR	Hologres V5.0
Todos os tipos restantes	Todas as versões do Hologres

Exemplos

Os exemplos a seguir demonstram operações comuns de DDL e DML para tipos selecionados.

Uso e exemplos de DECIMAL256

Limites de uso:

O DECIMAL256 é suportado apenas no Hologres V4.2 e posterior.
Não é possível usar DECIMAL256 como chave de distribuição, chave de clusterização, chave de partição, chave de segmento, índice bitmap ou coluna de codificação de dicionário.
Suportado nas instruções CREATE TABLE e CREATE DYNAMIC TABLE (atualização completa e incremental).
Compatível com armazenamento orientado a linhas, orientado a colunas e híbrido de linhas e colunas.
Funções suportadas: operações aritméticas, operações de comparação, SUM, AVG, MIN, MAX, CAST e TRY_CAST.

Exemplo:

-- Create a table with DECIMAL256 columns
CREATE TABLE financial_transactions (
    id INT PRIMARY KEY,
    -- Standard DECIMAL(38,19): supports up to 38 digits
    amount_standard DECIMAL(38, 19),
    -- DECIMAL256(76,38): supports up to 76 digits
    amount_high_precision DECIMAL(76, 38),
    description TEXT
);
-- Insert high-precision values
INSERT INTO financial_transactions VALUES
(1,
 1234567890123456789.1234567890123456789,  -- 38-digit precision
 '12345678901234567890123456789012345678.12345678901234567890123456789012345678',  -- 76-digit precision
 'High-precision transaction amount'
);

-- Query the data
SELECT * FROM financial_transactions;
 id |             amount_standard             |                             amount_high_precision                             |           description
----+-----------------------------------------+-------------------------------------------------------------------------------+----------------------------------
  1 | 1234567890123456789.1234567890123456789 | 12345678901234567890123456789012345678.12345678901234567890123456789012345678 | High-precision transaction amount
(1 row)

Exemplos de tipos de tempo

TIMESTAMPTZ, DATE e DECIMAL:

CREATE TABLE test_data_type (
  tswtz_column TIMESTAMP WITH TIME ZONE,
  date_column DATE,
  decimal_column DECIMAL(38, 10),
  char_column CHAR(20),
  varchar_column VARCHAR(225)
);

INSERT INTO test_data_type
VALUES ('2004-10-19 08:08:08', '2004-10-19', 123.456, 'abcd', 'a');

SELECT * FROM test_data_type;
      tswtz_column      | date_column | decimal_column |     char_column      | varchar_column
------------------------+-------------+----------------+----------------------+----------------
 2004-10-19 08:08:08+08 | 2004-10-19  | 123.4560000000 | abcd                 | a
(1 row)

BIT, VARBIT e BYTEA:

-- BIT and VARBIT
CREATE TABLE test (a BIT(3), b BIT VARYING(5));
INSERT INTO test VALUES (B'101', B'00');
INSERT INTO test VALUES (B'10', B'101');

ERROR:  bit string length 2 does not match type bit(3)

INSERT INTO test VALUES (B'10'::bit(3), B'101');
SELECT * FROM test;

  a  |  b
-----+-----
 101 | 00
 100 | 101

-- BYTEA (escape output format)
SET bytea_output = 'escape';

SELECT 'abc \153\154\155 \052\251\124'::bytea;
     bytea
----------------
 abc klm *\251T

RESET bytea_output;  -- 'hex' is the default

SELECT 'abc \153\154\155 \052\251\124'::bytea;
          bytea
--------------------------
 \x616263206b6c6d202aa954
(1 row)

Tipos de array

O Hologres suporta apenas arrays unidimensionais. A tabela a seguir mostra os tipos de array suportados com a sintaxe de declaração e uso.

Tipo	Descrição	Declarar em DDL	Inserir com palavra-chave ARRAY	Inserir com sintaxe {}	Consultar elemento único	Consultar um intervalo
int4[]	Array de inteiros unidimensional	`col int4[]`	`ARRAY[1, 2, 3, 4]`	`'{1, 2, 3, 4}'`	`col[3]`	`col[1:2]`
int8[]	Array bigint unidimensional	`col int8[]`	`ARRAY[1, 2, 3, 4]`	`'{1, 2, 3, 4}'`	`col[3]`	`col[1:2]`
float4[]	Array real unidimensional	`col float4[]`	`ARRAY[1.0, 2.0]`	`'{1.0, 2.0}'`	`col[1]`	`col[1:2]`
float8[]	Array double precision unidimensional	`col float8[]`	`ARRAY[1.0, 2.0, 3.0]`	`'{1.0, 2.0, 3.0}'`	`col[1]`	`col[1:2]`
boolean[]	Array booleano unidimensional	`col boolean[]`	`ARRAY[true, true, false]`	`'{true, true, false}'`	`col[1]`	`col[1:2]`
text[]	Array de texto unidimensional	`col text[]`	`ARRAY['foo1', 'foo2', 'foo3']`	`'{"foo1", "foo2", "foo3"}'`	`col[1]`	`col[1:2]`

Exemplo completo:

-- Declare
CREATE TABLE array_example(
  int4_array    int4[],
  int8_array    int8[],
  float4_array  float4[],
  float8_array  float8[],
  boolean_array boolean[],
  text_array    text[]
);

-- Insert using the ARRAY keyword
INSERT INTO array_example(int4_array, int8_array, float4_array, float8_array, boolean_array, text_array)
VALUES (
  ARRAY[1, 2, 3, 4],
  ARRAY[1, 2, 3, 4],
  ARRAY[1.0, 2.0],
  ARRAY[1.0, 2.0, 3.0],
  ARRAY[true, true, false],
  ARRAY['foo1', 'foo2', 'foo3']
);

-- Insert using the {} syntax
INSERT INTO array_example(int4_array, int8_array, float4_array, float8_array, boolean_array, text_array)
VALUES (
  '{1, 2, 3, 4}',
  '{1, 2, 3, 4}',
  '{1.0, 2.0}',
  '{1.0, 2.0, 3.0}',
  '{true, true, false}',
  '{"foo1", "foo2", "foo3"}'
);

-- Query a single element (1-based index)
SELECT int4_array[3] FROM array_example;

-- Query a range
SELECT int4_array[1:2] FROM array_example;

Mapeamento de tipos de dados entre MaxCompute e Hologres

A tabela a seguir mostra como os tipos do MaxCompute são mapeados para os tipos do Hologres ao criar uma tabela externa do MaxCompute.

Se uma tabela do MaxCompute contiver campos de tipos não suportados, você ainda poderá consultar os campos suportados, desde que a consulta não acesse os campos não suportados.

Tipo MaxCompute	Tipo Hologres	Disponível desde	Observações
JSON	JSONB	Hologres V4.1	—
STRING, VARCHAR	TEXT	Todas as versões	—
BIGINT	INT8	Todas as versões	—
INT	INT4, INT	Todas as versões	—
FLOAT	FLOAT4, REAL	Todas as versões	—
DOUBLE	FLOAT, FLOAT8	Todas as versões	—
BOOLEAN	BOOL	Todas as versões	—
DATETIME	TIMESTAMP WITH TIME ZONE	Todas as versões	O DATETIME do MaxCompute usa o Horário Padrão da China (UTC+8). Faixa: 1º de janeiro de 0000 a 31 de dezembro de 9999, com precisão de milissegundos.
DECIMAL	NUMERIC	Todas as versões	A precisão padrão é (38,18) quando não especificada. Ao usar IMPORT FOREIGN SCHEMA para criar uma tabela, o sistema converte automaticamente a precisão.
TIMESTAMP	TIMESTAMP WITH TIME ZONE	Hologres V0.8	Faixa do TIMESTAMP do MaxCompute: 0000-01-01 00:00:00.000000000 a 9999-12-31 23:59:59.999999999 (precisão de nanossegundos). O TIMESTAMPTZ do Hologres usa precisão de milissegundos; a precisão é convertida automaticamente durante as leituras.
CHAR(n)	CHAR(n) (padrão); TEXT (opcional)	Hologres V0.8	Tipo de caractere de comprimento fixo; n é o comprimento, máximo de 255. Preenchido com espaços se for menor que n. Para mapear para TEXT, defina `hg_enable_convert_type_for_foreign_table = true` e altere o tipo do campo para TEXT ao criar a tabela.
VARCHAR(n)	VARCHAR(n) (padrão); TEXT (opcional)	Hologres V0.8	Tipo de caractere de comprimento variável; n varia de 1 a 65.535. Para mapear para TEXT, defina `hg_enable_convert_type_for_foreign_table = true` e altere o tipo do campo para TEXT ao criar a tabela.
DATE	DATE	Hologres V0.8	—
SMALLINT	INT2 (padrão); INT8 (opcional)	Todas as versões (INT4 na V0.8, INT2 na V0.9)	Para mapear para INT8, defina `hg_enable_convert_type_for_foreign_table = true` e altere o tipo do campo para INT8 ao criar a tabela.
TINYINT	INT2 (padrão); INT8 (opcional)	Todas as versões (INT4 na V0.8, INT2 na V0.9)	Para mapear para INT8, defina `hg_enable_convert_type_for_foreign_table = true` e altere o tipo do campo para INT8 ao criar a tabela.
CHAR (sem comprimento)	Não suportado	Não suportado	—
ARRAY\<INT\>	INT4[]	Hologres V0.8	—
ARRAY\<BIGINT\>	INT8[]	Hologres V0.8	—
ARRAY\<FLOAT\>	FLOAT4[]	Hologres V0.8	—
ARRAY\<DOUBLE\>	FLOAT8[]	Hologres V0.8	—
ARRAY\<BOOLEAN\>	BOOLEAN[]	Hologres V0.8	—
ARRAY\<STRING\>	TEXT[]	Hologres V0.8	—
BINARY	BYTEA	Hologres V0.9	—
ARRAY\<TINYINT\>	Não suportado	Não suportado	—
ARRAY\<SMALLINT\>	Não suportado	Não suportado	—

Mapeamento de tipos de dados entre Blink/Flink e Hologres

A tabela a seguir mostra como os tipos do Flink são mapeados para os tipos do Hologres.

As tabelas de origem Binlog suportam apenas um subconjunto de tipos de dados. Para mais informações, consulte Consume Hologres Binlog in real time with Flink/Blink .

Tipo Flink	Tipo Hologres	Versão do Hologres suportada	Versão do Flink suportada
INT	INT4, INT	Todas as versões	Todas as versões
BIGINT	INT8	Todas as versões	Todas as versões
VARCHAR	TEXT	Todas as versões	Todas as versões
DOUBLE	FLOAT, FLOAT8, DOUBLE PRECISION	Todas as versões	Todas as versões
BOOLEAN	BOOL	Todas as versões	Todas as versões
DECIMAL	NUMERIC	Todas as versões	Todas as versões
DATE	DATE	Hologres V0.8	Todas as versões
TIMESTAMP	TIMESTAMP WITH TIME ZONE, TIMESTAMPTZ	Todas as versões	Todas as versões
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE, TIMESTAMP	Todas as versões	Todas as versões. Observação: O Fixed Plan não suporta atualmente o tipo TIME. Para mais detalhes, consulte Fixed Plan.
FLOAT	FLOAT4, REAL	Todas as versões	Todas as versões
TINYINT	SMALLINT	Todas as versões	Sink: VVR-4.0.13-Flink-1.13 e posterior. Modo RPC não suportado. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: VVR-4.0.13-Flink-1.13 e posterior. Modo RPC não suportado.
SMALLINT	SMALLINT	Todas as versões	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
TIME	TIME e TIMETZ	Todas as versões. A partir do Hologres V2.1.24, Fixed Plan suporta TIME e TIMETZ.	Sink: VVR-4.0.13-Flink-1.13 e posterior. Modo RPC não suportado. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: VVR-4.0.13-Flink-1.13 e posterior. Modo RPC não suportado. Nota O Fixed Plan não suporta o tipo TIME; evite este tipo sempre que possível. Para mais detalhes, consulte Fixed Plan.
VARCHAR	JSONB	Hologres V0.10	Sink: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado.
VARCHAR	JSON	Hologres V0.9	Sink: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado.
BYTES	RoaringBitmap	Hologres V0.10	Sink: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: VVR-4.0.12-Flink-1.13 e posterior. Modo RPC não suportado.
VARCHAR	GEOMETRY e GEOGRAPHY	Todas as versões. A partir do Hologres V2.1, Fixed Plan suporta a gravação de dados GEOMETRY e GEOGRAPHY.	Sink: VVR-4.0.13-Flink-1.13 e posterior. Modo RPC não suportado. source: Não suportado. Dimension: Não suportado.
ARRAY\<INT\>	int4[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<BIGINT\>	int8[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<FLOAT\>	float4[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<DOUBLE\>	float8[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<BOOLEAN\>	boolean[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<VARCHAR\>	TEXT[]	Hologres V0.8	Sink: Todas as versões. source: VVR-6.0.3-Flink-1.15 e posterior. Modo RPC não suportado. Dimension: Todas as versões.
ARRAY\<VARCHAR\>	VARCHAR[]	Hologres V0.8	Sink: Todas as versões. source: Hologres V4.0.19 e posterior, com mecanismo Flink VVR-11.6-JDK11-Flink-1.20. Dimension: Todas as versões.
CHAR	Não suportado	Não suportado	Não suportado
BINARY	Não suportado	Não suportado	Não suportado

Ao usar CTAS para sincronizar dados com o Hologres, as chaves primárias DECIMAL são mapeadas para TEXT, enquanto os campos DECIMAL que não são chave primária são mapeados para DECIMAL. Para mais informações, consulte Why does the primary key of a MySQL table with bigint unsigned become decimal when registering the Flink Catalog, but become text after synchronizing to Hologres using CTAS?

Mapeamento de tipos de dados entre MySQL e Hologres

Para um passo a passo de migração, consulte Migrate MySQL to Hologres.

Tipo MySQL	Tipo Hologres
BIGINT	BIGINT
BINARY(n)	BYTEA
BIT	BOOLEAN
CHAR(n), CHARACTER(n)	CHAR(n), CHARACTER(n)
DATE	DATE
DATETIME	TIMESTAMP WITHOUT TIME ZONE
DECIMAL(p,s), DEC(p,s)	DECIMAL(p,s), DEC(p,s)
DOUBLE	DOUBLE PRECISION
FLOAT	REAL
INT, INTEGER	INT, INTEGER
MEDIUMINT	INTEGER
NUMERIC(p,s)	NUMERIC(p,s)
SMALLINT	SMALLINT
TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB	BYTEA
TINYINT	SMALLINT
TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT	TEXT
TIME	TIME WITHOUT TIME ZONE
TIMESTAMP	TIMESTAMP WITH TIME ZONE
VARBINARY(n), VARBINARY(max)	BYTEA
VARCHAR(n)	VARCHAR(n)
VARCHAR(max)	TEXT

Mapeamento de tipos de dados entre DLF e Hologres

Tipo DLF	Tipo Hologres
TINYINT	SMALLINT
SMALLINT	SMALLINT
INT	INT
BIGINT	BIGINT
BOOLEAN	BOOLEAN
FLOAT	REAL
DOUBLE	DOUBLE PRECISION
DATE	DATE
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
STRING	TEXT
BINARY	BYTEA
DECIMAL(m,n)	NUMERIC(m,n)
VARCHAR(n)	CHARACTER VARYING(n)
CHAR(n)	CHAR(n)
ARRAY\<type\>	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE, STRING

Mapeamento de tipos de dados entre Hive e Hologres

Tipo Hive	Tipo Hologres
TINYINT	SMALLINT
SMALLINT	SMALLINT
INT	INT
BIGINT	BIGINT
FLOAT	REAL
DOUBLE	DOUBLE PRECISION
DECIMAL	NUMERIC
NUMERIC	NUMERIC
DATE	DATE
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
STRING	TEXT
VARCHAR	VARCHAR
CHAR	CHAR
BINARY	BYTEA
BOOL	BOOLEAN
ARRAY\<type\>	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING

Mapeamento de tipos de dados entre Hudi e Hologres

Este mapeamento é suportado no Hologres V1.3 e posterior.

Tipo Hudi	Tipo Hologres
IntegerType	INT
LongType	BIGINT
FloatType	REAL
DoubleType	DOUBLE PRECISION
DecimalType	NUMERIC
TimestampType	TIMESTAMP WITHOUT TIME ZONE
DateType	DATE
YearMonthIntervalType	Não suportado
DayTimeIntervalType	Não suportado
StringType	TEXT
VarcharType	Não suportado
CharType	Não suportado
BooleanType	BOOL
BinaryType	BYTEA
ByteType	Não suportado
ShortType	Não suportado
ArrayType(elementType, containsNull)	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING

Mapeamento de tipos de dados entre Delta Lake e Hologres

Este mapeamento é suportado no Hologres V1.3 e posterior.

Tipo Delta Lake	Tipo Hologres
TINYINT	SMALLINT
SMALLINT	SMALLINT
INT	INT
BIGINT	BIGINT
FLOAT	REAL
DOUBLE	DOUBLE PRECISION
DECIMAL(p,s)	NUMERIC
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
DATE	DATE
INTERVAL intervalQualifier	Não suportado
STRING	TEXT
BOOLEAN	BOOLEAN
BINARY	BYTEA
ARRAY\<elementType\>	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING

Mapeamento de tipos de dados entre Paimon e Hologres

Tipo Paimon	Tipo Hologres
TINYINT	SMALLINT
SMALLINT	SMALLINT
INT	INT
BIGINT	BIGINT
FLOAT	REAL
DOUBLE	DOUBLE PRECISION
DECIMAL(p,s)	DECIMAL
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
DATE	DATE
CHAR	CHAR
VARCHAR	VARCHAR
BINARY	BYTEA
BLOB	BYTES (suportado a partir da V4.2)
ARRAY	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING

Mapeamento de tipos de dados entre Iceberg e Hologres

Tipo Iceberg	Tipo Hologres
BOOLEAN	BOOLEAN
INT	INTEGER
LONG	BIGINT
FLOAT	REAL
DOUBLE	DOUBLE PRECISION
DECIMAL(P,S)	NUMERIC(P,S)
DATE	DATE
TIME	TEXT (O Spark não suporta o tipo TIME. O tipo TIME do Flink torna-se STRING quando gravado no DLF.)
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
TIMESTAMPTZ	Não suportado
STRING	TEXT
UUID	Não suportado (Flink e Spark não podem gravar este tipo.)
FIXED(L)	BYTEA
BINARY	BYTEA
LIST	ARRAY\<hologres_data_type\>. Tipos de elemento suportados: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING
STRUCT	Não suportado
MAP	Não suportado