Tabela com partição automática baseada em função de cálculo de tempo - MaxCompute: Central de Documentação do Alibaba Cloud

Em tabelas particionadas convencionais, é necessário criar cada partição antes de gravar dados e calcular manualmente o valor correto da partição para cada linha. As tabelas AUTO PARTITION eliminam essa sobrecarga: você define uma função de cálculo de tempo na criação da tabela e o MaxCompute gera automaticamente o valor da coluna de partição para cada linha com base nessa função durante a gravação dos dados.

Este documento aborda tabelas com partição automática que derivam valores de partição de uma função de cálculo de tempo aplicada a uma coluna de data/hora existente. Para partição automática baseada no horário de gravação dos dados, consulte Tabelas com partição automática baseadas no horário de gravação de dados. Para obter uma visão geral de todos os tipos de tabelas particionadas, consulte Visão geral de tabelas particionadas.

Limitações

O sistema aceita apenas uma coluna de partição por tabela. Não há suporte para particionamento multinível.
A coluna de partição é gerada automaticamente com base na expressão de partição definida na criação da tabela. Seu tipo de dado é sempre STRING e não pode ser alterado.
O particionamento automático funciona apenas ao gravar dados com MaxCompute SQL. Outros métodos de gravação, como conectores Flink, não são compatíveis.

Crie uma tabela com partição automática

Sintaxe

CREATE [OR REPLACE] TABLE [IF NOT EXISTS] <table_name> (<col_name> <data_type>, ...)
[COMMENT <table_comment>]
AUTO PARTITIONED BY (<auto_partition_expression> [AS <auto_partition_column_name>]);

Parâmetros

Parâmetro	Obrigatório	Descrição
`table_name`	Sim	Nome da tabela a ser criada.
`col_name`	Sim	Nome da coluna.
`data_type`	Sim	Tipo de dado da coluna. Tipos de data/hora compatíveis para a coluna source de partição: DATE, DATETIME, TIMESTAMP, TIMESTAMP_NTZ.
`table_comment`	Não	Comentário descritivo da tabela.
`auto_partition_expression`	Sim	Expressão que define como os valores da coluna de partição são calculados. Apenas a função TRUNC_TIME é compatível. A coluna de partição resultante é sempre do tipo STRING e seus valores não aceitam operações diretas.
`auto_partition_column_name`	Não	Nome da coluna de partição gerada. Se omitido, o sistema utiliza `_pt_col_0_` e incrementa o sufixo (`_pt_col_1_`, `_pt_col_2_` e assim por diante) até encontrar um nome não utilizado.

Exemplos

Exemplo 1: Particionamento por dia usando uma coluna TIMESTAMP (nome padrão da coluna de partição)

Crie uma tabela com partição automática chamada sale_detail com uma coluna TIMESTAMP sale_time, particionada por dia:

CREATE TABLE IF NOT EXISTS sale_detail(
  shop_name    STRING,
  total_price  DOUBLE,
  sale_time    TIMESTAMP)
AUTO PARTITIONED BY (TRUNC_TIME(sale_time, 'day'));

A tabela contém quatro colunas: shop_name, total_price, sale_time e _pt_col_0_. A coluna _pt_col_0_ é a coluna de partição gerada automaticamente com o tipo STRING.

Execute DESC sale_detail; para visualizar a estrutura da tabela:

+------------------------------------------------------------------------------------+
| Owner:                    ALIYUN$***                             |
| Project:                  ***                                    |
| TableComment:                                                                      |
+------------------------------------------------------------------------------------+
| CreateTime:               2025-06-26 11:21:55                                      |
| LastDDLTime:              2025-06-26 11:21:55                                      |
| LastModifiedTime:         2025-06-26 11:21:55                                      |
+------------------------------------------------------------------------------------+
| InternalTable: YES      | Size: 0                                                  |
+------------------------------------------------------------------------------------+
| Native Columns:                                                                    |
+------------------------------------------------------------------------------------+
| Field           | Type       | Label | Comment                                     |
+------------------------------------------------------------------------------------+
| shop_name       | string     |       |                                             |
| total_price     | double     |       |                                             |
| sale_time       | timestamp  |       |                                             |
+------------------------------------------------------------------------------------+
| Partition Columns:                                                                 |
+------------------------------------------------------------------------------------+
| _pt_col_0_      | string     |                                                     |
+------------------------------------------------------------------------------------+

Para visualizar a expressão de geração de partição de uma coluna AUTO PARTITION, utilize SHOW CREATE TABLE .

Exemplo 2: Particionamento por dia com nome explícito da coluna de partição

Especifique um nome explícito para a coluna de partição chamado sale_date:

CREATE TABLE IF NOT EXISTS sale_detail2(
  shop_name    STRING,
  total_price  DOUBLE,
  sale_time    TIMESTAMP)
AUTO PARTITIONED BY (TRUNC_TIME(sale_time, 'day') AS sale_date);

Exemplo 3: Sintaxe simplificada para colunas DATE

Quando a coluna source for do tipo DATE e a granularidade de truncamento for day, é possível omitir TRUNC_TIME:

-- Full syntax
CREATE TABLE IF NOT EXISTS sale_detail3(
  shop_name   STRING,
  total_price DOUBLE,
  sale_date   DATE)
AUTO PARTITIONED BY (TRUNC_TIME(sale_date, 'day'));

-- Simplified syntax (equivalent)
CREATE TABLE IF NOT EXISTS sale_detail3(
  shop_name   STRING,
  total_price DOUBLE,
  sale_date   DATE)
AUTO PARTITIONED BY (sale_date);

Importante

A sintaxe simplificada aceita apenas o tipo DATE. Os tipos DATETIME, TIMESTAMP e TIMESTAMP_NTZ não são compatíveis.

Gravar dados em uma tabela com partição automática

Ao gravar dados usando MaxCompute SQL, o sistema calcula o valor da coluna de partição para cada linha com base na expressão de partição definida na criação da tabela. Não é possível especificar valores de partição explicitamente.

Exemplo: Gravar dados em sale_detail2

-- Set the project time zone to UTC+8 (Asia/Shanghai)
SET odps.sql.timezone=Asia/Shanghai;

-- Create the table (same as Example 2 above)
CREATE TABLE IF NOT EXISTS sale_detail2(
  shop_name    STRING,
  total_price  DOUBLE,
  sale_time    TIMESTAMP)
AUTO PARTITIONED BY (TRUNC_TIME(sale_time, 'day') AS sale_date);

-- Insert data
INSERT INTO sale_detail2 VALUES
  ('chongqin_shop', 101101, TIMESTAMP '2025-02-04 01:15:30'),
  ('shenzhen_shop', 202202, TIMESTAMP '2024-03-29 15:30:30'),
  ('hangzhou_shop', 303303, TIMESTAMP '2025-02-04 08:30:30'),
  ('shanghai_shop', 404404, TIMESTAMP '2025-02-28 01:50:30');

A tabela abaixo mostra como cada valor de sale_time é mapeado para uma partição após o cálculo da função TRUNC_TIME:

`sale_time` (Asia/Shanghai, UTC+8)	Partição `sale_date` (UTC)
2025-02-04 01:15:30	2025-02-03
2024-03-29 15:30:30	2024-03-29
2025-02-04 08:30:30	2025-02-04
2025-02-28 01:50:30	2025-02-27

Para colunas DATETIME e TIMESTAMP, a função TRUNC_TIME converte o horário local para UTC antes de realizar o truncamento. Linhas gravadas próximas à meia-noite podem ser alocadas em uma partição diferente daquela sugerida pela data local. Por exemplo, 2025-02-04 01:15:30 em UTC+8 corresponde a 2025-02-03 17:15:30 em UTC, sendo portanto atribuída à partição 2025-02-03 , e não à 2025-02-04 .

Consultar uma tabela com partição automática

**Exemplo 1: SELECT * não inclui a coluna de partição por padrão**

-- Enable full table scan
SET odps.sql.allow.fullscan=true;

SELECT * FROM sale_detail2;

-- Result
+------------+-------------+---------------------+
| shop_name  | total_price | sale_time           |
+------------+-------------+---------------------+
| hangzhou_shop | 303303.0 | 2025-02-04 08:30:30 |
| shanghai_shop | 404404.0 | 2025-02-28 01:50:30 |
| shenzhen_shop | 202202.0 | 2024-03-29 15:30:30 |
| chongqin_shop | 101101.0 | 2025-02-04 01:15:30 |
+------------+-------------+---------------------+

Exemplo 2: Incluir a coluna de partição na saída

Referencie a coluna de partição pelo nome para incluí-la nos resultados:

SELECT *, sale_date FROM sale_detail2;

-- Result
+------------+-------------+---------------------+------------+
| shop_name  | total_price | sale_time           | sale_date  |
+------------+-------------+---------------------+------------+
| shanghai_shop | 404404.0 | 2025-02-28 01:50:30 | 2025-02-27 |
| hangzhou_shop | 303303.0 | 2025-02-04 08:30:30 | 2025-02-04 |
| shenzhen_shop | 202202.0 | 2024-03-29 15:30:30 | 2024-03-29 |
| chongqin_shop | 101101.0 | 2025-02-04 01:15:30 | 2025-02-03 |
+------------+-------------+---------------------+------------+

Partition pruning

O partition pruning reduz o custo da consulta ao examinar apenas as partições que correspondem à condição de filtro. Para verifique se o partition pruning está funcionando, analise o plano de execução SQL no Logview ou utilize o comando EXPLAIN. Para mais detalhes, consulte Avaliar a eficácia do partition pruning.

O partition pruning é compatível em três cenários para tabelas com partição automática.

Filtro na coluna de partição gerada

Aplicar um filtro diretamente na coluna de partição (sale_date) aciona o partition pruning:

SELECT * FROM sale_detail2 WHERE sale_date > '2025-02-03';

-- Result: only partitions where sale_date > '2025-02-03' are scanned
+------------+-------------+---------------------+
| shop_name  | total_price | sale_time           |
+------------+-------------+---------------------+
| shanghai_shop | 404404.0 | 2025-02-28 01:50:30 |
| hangzhou_shop | 303303.0 | 2025-02-04 08:30:30 |
+------------+-------------+---------------------+

Filtro na coluna de tempo source (sem funções)

Filtrar diretamente na coluna de tempo source (sale_time), sem envolvê-la em uma função, também aciona o partition pruning. O sistema mapeia o intervalo do filtro para os limites de partição correspondentes:

SELECT * FROM sale_detail2 WHERE sale_time > '2025-02-04 08:00:00';

-- Result: only partitions containing matching sale_time values are scanned
+------------+-------------+---------------------+
| shop_name  | total_price | sale_time           |
+------------+-------------+---------------------+
| shanghai_shop | 404404.0 | 2025-02-28 01:50:30 |
| hangzhou_shop | 303303.0 | 2025-02-04 08:30:30 |
+------------+-------------+---------------------+

Filtro usando uma função na coluna de tempo source

Ao aplicar uma função à coluna de tempo source na condição de filtro, o partition pruning funciona apenas se a granularidade de truncamento da função corresponder à granularidade usada na criação da tabela. Isso é necessário porque o sistema só consegue mapear uma condição de filtro para os limites de partição quando ambas expressam o tempo na mesma resolução.

Função	Condição para partition pruning
TRUNC_TIME	A granularidade de truncamento corresponde à instrução de criação da tabela
DATETRUNC	A granularidade de truncamento corresponde à instrução de criação da tabela
CAST AS DATE	A tabela foi criada com granularidade `day`
TO_DATE	A tabela foi criada com granularidade `day`; sem parâmetro de fuso horário

Exemplo 1: Filtro usando TRUNC_TIME ou DATETRUNC (sem parâmetro de fuso horário)

Ambas as consultas acionam o partition pruning porque a granularidade de truncamento (day / dd) corresponde à granularidade day usada para criar sale_detail2, e nenhuma das funções é chamada com um parâmetro de fuso horário:

SELECT * FROM sale_detail2 WHERE TRUNC_TIME(sale_time, 'day') > '2025-02-04';

SELECT * FROM sale_detail2 WHERE DATETRUNC(sale_time, 'dd') > '2025-02-04 00:00:00';

-- Result
+------------+-------------+---------------------+
| shop_name  | total_price | sale_time           |
+------------+-------------+---------------------+
| shanghai_shop | 404404.0 | 2025-02-28 01:50:30 |
+------------+-------------+---------------------+

Exemplo 2: Filtro usando CAST AS DATE ou TO_DATE (sem parâmetro de fuso horário)

Essas consultas acionam o partition pruning porque sale_detail2 foi criada com granularidade day:

SELECT * FROM sale_detail2 WHERE CAST(sale_time AS DATE) = '2025-02-04';

SELECT * FROM sale_detail2 WHERE TO_DATE(sale_time) = '2025-02-04';

-- Result
+------------+-------------+---------------------+
| shop_name  | total_price | sale_time           |
+------------+-------------+---------------------+
| hangzhou_shop | 303303.0 | 2025-02-04 08:30:30 |
+------------+-------------+---------------------+