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 com suporte no Hologres. Os nomes de tipos e aliases não diferenciam maiúsculas de minúsculas em SQL, mas aparecem 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 PRECISION (total de dígitos, 0–38) e SCALE (dígitos após a vírgula decimal, 0–PRECISION). A partir da V4.2, o modo de alta precisão aceita 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, aceita 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 obter detalhes, consulte .	Nenhum	Nenhum
JSONB	—	Variável	Tipo JSON binário. Para obter detalhes, consulte .	Nenhum	Nenhum
BYTEA	—	Variável	String binária de comprimento variável. O tamanho de armazenamento não excede 1 GB. Para obter 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 obter detalhes, consulte Network address types.	Nenhum	192.168.100.128/25
MONEY	—	8 bytes	Valor monetário com precisão fracionária fixa. Para obter 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 têm suporte 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 obter detalhes, consulte Sequência de incremento automático.	Nenhum	Nenhum
RoaringBitmap	—	Variável	Array INT eficiente que aceita operações de bitmap de array constante. Para obter detalhes, consulte Funções RoaringBitmap.	Nenhum	Nenhum
RoaringBitmap64	—	Variável	Array BIGINT eficiente que aceita operações de bitmap de array constante. Para obter detalhes, consulte Funções RoaringBitmap.	Nenhum	Nenhum
GEOMETRY e GEOGRAPHY	—	Variável. Para obter detalhes, consulte Análise geográfica baseada em PostGIS.	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 melhorou a partir da V1.3.	Nenhum	Nenhum

Disponibilidade por versão: Os tipos indisponí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
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 tem suporte apenas no Hologres V4.2 e posteriores.
Não use DECIMAL256 como chave de distribuição, chave de clustering, chave de partição, chave de segmento, índice bitmap ou coluna de codificação de dicionário.
Compatível com instruções CREATE TABLE e CREATE DYNAMIC TABLE (atualização completa e incremental).
Tem suporte em armazenamento orientado a linhas, orientado a colunas e híbrido linha-coluna.
Funções com suporte: 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 aceita apenas arrays unidimensionais. A tabela a seguir mostra os tipos de array com suporte, incluindo 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 sem suporte, ainda será possível consultar os campos com suporte, desde que a consulta não acesse os campos sem suporte.

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 de 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 de 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 de 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 de campo para INT8 ao criar a tabela.
CHAR (sem comprimento)	Sem suporte	Sem suporte	—
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\>	Sem suporte	Sem suporte	—
ARRAY\<SMALLINT\>	Sem suporte	Sem suporte	—

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 source Binlog aceitam apenas um subconjunto de tipos de dados. Para obter mais informações, consulte Consumir Binlog do Hologres em tempo real com Flink/Blink .

Tipo Flink	Tipo Hologres	Versão do Hologres com suporte	Versão do Flink com suporte
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 aceita atualmente o tipo TIME. Para obter 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 posteriores. Modo RPC sem suporte. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: VVR-4.0.13-Flink-1.13 e posteriores. Modo RPC sem suporte.
SMALLINT	SMALLINT	Todas as versões	Sink: Todas as versões. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: Todas as versões.
TIME	TIME e TIMETZ	Todas as versões. A partir do Hologres V2.1.24, o Fixed Plan aceita TIME e TIMETZ.	Sink: VVR-4.0.13-Flink-1.13 e posteriores. Modo RPC sem suporte. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: VVR-4.0.13-Flink-1.13 e posteriores. Modo RPC sem suporte. Nota O Fixed Plan não aceita o tipo TIME; evite este tipo sempre que possível. Para obter detalhes, consulte Fixed Plan.
VARCHAR	JSONB	Hologres V0.10	Sink: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte.
VARCHAR	JSON	Hologres V0.9	Sink: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte.
BYTES	RoaringBitmap	Hologres V0.10	Sink: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. Dimension: VVR-4.0.12-Flink-1.13 e posteriores. Modo RPC sem suporte.
VARCHAR	GEOMETRY e GEOGRAPHY	Todas as versões. A partir do Hologres V2.1, o Fixed Plan aceita a gravação de dados GEOMETRY e GEOGRAPHY.	Sink: VVR-4.0.13-Flink-1.13 e posteriores. Modo RPC sem suporte. Source: Sem suporte. Dimension: Sem suporte.
ARRAY\<INT\>	int4[]	Hologres V0.8	Sink: Todas as versões. Source: VVR-6.0.3-Flink-1.15 e posteriores. Modo RPC sem suporte. 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 posteriores. Modo RPC sem suporte. 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 posteriores. Modo RPC sem suporte. 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 posteriores. Modo RPC sem suporte. 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 posteriores. Modo RPC sem suporte. 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 posteriores. Modo RPC sem suporte. Dimension: Todas as versões.
ARRAY\<VARCHAR\>	VARCHAR[]	Hologres V0.8	Sink: Todas as versões. Source: Hologres V4.0.19 e posteriores, com mecanismo Flink VVR-11,6-JDK11-Flink-1.20. Dimension: Todas as versões.
CHAR	Sem suporte	Sem suporte	Sem suporte
BINARY	Sem suporte	Sem suporte	Sem suporte

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 obter mais informações, consulte Por que a chave primária de uma tabela MySQL com bigint unsigned se torna decimal ao registrar o Catálogo Flink, mas vira text após a sincronização com o Hologres usando CTAS?

Mapeamento de tipos de dados entre MySQL e Hologres

Para um tutorial de migração, consulte Migrar MySQL para 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 elementos com suporte: 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 elementos com suporte: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING

Mapeamento de tipos de dados entre Hudi e Hologres

Este mapeamento tem suporte no Hologres V1.3 e posteriores.

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

Mapeamento de tipos de dados entre Delta Lake e Hologres

Este mapeamento tem suporte no Hologres V1.3 e posteriores.

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	Sem suporte
STRING	TEXT
BOOLEAN	BOOLEAN
BINARY	BYTEA
ARRAY\<elementType\>	ARRAY\<hologres_data_type\>. Tipos de elementos com suporte: 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 (com suporte a partir da V4.2)
ARRAY	ARRAY\<hologres_data_type\>. Tipos de elementos com suporte: 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 aceita o tipo TIME. O tipo TIME do Flink torna-se STRING quando gravado no DLF.)
TIMESTAMP	TIMESTAMP WITHOUT TIME ZONE
TIMESTAMPTZ	Sem suporte
STRING	TEXT
UUID	Sem suporte (Flink e Spark não podem gravar este tipo.)
FIXED(L)	BYTEA
BINARY	BYTEA
LIST	ARRAY\<hologres_data_type\>. Tipos de elementos com suporte: INT, BIGINT, FLOAT, BOOLEAN, DOUBLE PRECISION, STRING
STRUCT	Sem suporte
MAP	Sem suporte