Table à partitionnement automatique basée sur une fonction de calcul temporel - MaxCompute

Avec les tables partitionnées classiques, vous devez créer chaque partition avant d'écrire les données et calculer manuellement la valeur de partition correcte pour chaque ligne. Les tables AUTO PARTITION éliminent cette contrainte : définissez une fonction de calcul temporel lors de la création de la table ; MaxCompute générera automatiquement la valeur de la colonne de partition pour chaque ligne selon cette fonction lors de l'écriture des données.

Cette rubrique décrit les tables à partitionnement automatique qui dérivent les valeurs de partition d'une fonction de calcul temporel appliquée à une colonne de date ou d'heure existante. Pour le partitionnement automatique basé sur l'heure d'écriture des données, consultez la section Tables à partitionnement automatique basées sur l'heure d'écriture des données. Pour un aperçu de tous les types de tables partitionnées, reportez-vous à la rubrique Présentation des tables partitionnées.

Limitations

Chaque table ne prend en charge qu'une seule colonne de partition. Le partitionnement multi-niveaux n'est pas pris en charge.
Le système génère la colonne de partition automatiquement selon l'expression de partition définie lors de la création de la table. Son type de données est toujours STRING et ne peut pas être modifié.
Le partitionnement automatique n'est pris en charge que lors de l'écriture des données avec MaxCompute SQL. D'autres méthodes d'écriture, telles que les connecteurs Flink, ne sont pas prises en charge.

Créer une table à partitionnement automatique

Syntaxe

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>]);

Paramètres

Paramètre	Obligatoire	Description
`table_name`	Oui	Nom de la table à créer.
`col_name`	Oui	Nom de la colonne.
`data_type`	Oui	Type de données de la colonne. Types de date/heure pris en charge pour la colonne source de partition : DATE, DATETIME, TIMESTAMP, TIMESTAMP_NTZ.
`table_comment`	Non	Commentaire associé à la table.
`auto_partition_expression`	Oui	Expression définissant le calcul des valeurs de la colonne de partition. Seule la fonction TRUNC_TIME est prise en charge. La colonne de partition résultante est toujours de type STRING et ses valeurs ne prennent pas en charge les opérations directes.
`auto_partition_column_name`	Non	Nom de la colonne de partition générée. Si ce paramètre est omis, le système utilise `_pt_col_0_` et incrémente le suffixe (`_pt_col_1_`, `_pt_col_2_`, etc.) jusqu'à trouver un nom disponible.

Exemples

Exemple 1 : Partitionnement par jour à l'aide d'une colonne TIMESTAMP (nom de colonne de partition par défaut)

Créez une table à partitionnement automatique sale_detail avec une colonne TIMESTAMP sale_time, partitionnée par jour :

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

La table contient quatre colonnes : shop_name, total_price, sale_time et _pt_col_0_. La colonne _pt_col_0_ est la colonne de partition générée automatiquement, de type STRING.

Exécutez DESC sale_detail; pour afficher la structure de la table :

+------------------------------------------------------------------------------------+
| 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     |                                                     |
+------------------------------------------------------------------------------------+

Pour afficher l'expression de génération de partition d'une colonne AUTO PARTITION, utilisez SHOW CREATE TABLE .

Exemple 2 : Partitionnement par jour avec un nom explicite de colonne de partition

Spécifiez un nom explicite pour la colonne de partition 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);

Exemple 3 : Syntaxe simplifiée pour les colonnes DATE

Lorsque la colonne source est de type DATE et que la granularité de troncature est day, vous pouvez omettre 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);

Important

La syntaxe simplifiée prend uniquement en charge le type DATE. Les types DATETIME, TIMESTAMP et TIMESTAMP_NTZ ne sont pas pris en charge.

Écrire des données dans une table à partitionnement automatique

Lorsque vous écrivez des données à l'aide de MaxCompute SQL, le système calcule la valeur de la colonne de partition pour chaque ligne selon l'expression de partition définie lors de la création de la table. Vous ne pouvez pas spécifier explicitement les valeurs de partition.

Exemple : Écriture de données dans 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');

Le tableau ci-dessous illustre la correspondance entre chaque valeur sale_time et sa partition après le calcul TRUNC_TIME :

`sale_time` (Asia/Shanghai, UTC+8)	Partition `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

Pour les colonnes DATETIME et TIMESTAMP, TRUNC_TIME convertit l'heure locale en UTC avant la troncature. Les lignes écrites près de minuit peuvent ainsi appartenir à une partition différente de celle suggérée par la date locale. Par exemple, 2025-02-04 01:15:30 en UTC+8 correspond à 2025-02-03 17:15:30 en UTC ; la ligne est donc assignée à la partition 2025-02-03 et non à 2025-02-04 .

Interroger une table à partitionnement automatique

**Exemple 1 : SELECT * n'inclut pas la colonne de partition par défaut**

-- 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 |
+------------+-------------+---------------------+

Exemple 2 : Inclure la colonne de partition dans le résultat

Référencez la colonne de partition par son nom pour l'inclure dans les résultats :

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 |
+------------+-------------+---------------------+------------+

Élagage des partitions

L'élagage des partitions réduit le coût des requêtes en analysant uniquement les partitions correspondant à la condition de filtre. Pour vérifier si l'élagage des partitions fonctionne, examinez le plan d'exécution SQL dans Logview ou utilisez la commande EXPLAIN. Pour plus de détails, consultez la section Évaluer l'efficacité de l'élagage des partitions.

L'élagage des partitions est pris en charge dans trois scénarios pour les tables à partitionnement automatique.

Filtrer sur la colonne de partition générée

Le filtrage direct sur la colonne de partition (sale_date) déclenche l'élagage des partitions :

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 |
+------------+-------------+---------------------+

Filtrer sur la colonne temporelle source (sans fonctions)

Le filtrage direct sur la colonne temporelle source (sale_time), sans l'envelopper dans une fonction, déclenche également l'élagage des partitions. Le système mappe la plage du filtre aux limites de partition correspondantes :

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 |
+------------+-------------+---------------------+

Filtrer à l'aide d'une fonction sur la colonne temporelle source

Lorsque vous appliquez une fonction à la colonne temporelle source dans la condition de filtre, l'élagage des partitions fonctionne uniquement si la granularité de troncature de la fonction correspond à celle utilisée lors de la création de la table. Cette condition est nécessaire car le système ne peut mapper une condition de filtre aux limites de partition que si les deux expriment le temps à la même résolution.

Fonction	Condition pour l'élagage des partitions
TRUNC_TIME	La granularité de troncature correspond à l'instruction de création de la table
DATETRUNC	La granularité de troncature correspond à l'instruction de création de la table
CAST AS DATE	La table a été créée avec une granularité `day`
TO_DATE	La table a été créée avec une granularité `day` ; aucun paramètre de fuseau horaire

Exemple 1 : Filtrer à l'aide de TRUNC_TIME ou DATETRUNC (sans paramètre de fuseau horaire)

Les deux requêtes déclenchent l'élagage des partitions car la granularité de troncature (day / dd) correspond à la granularité day utilisée pour créer sale_detail2, et aucune fonction n'est appelée avec un paramètre de fuseau horaire :

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 |
+------------+-------------+---------------------+

Exemple 2 : Filtrer à l'aide de CAST AS DATE ou TO_DATE (sans paramètre de fuseau horaire)

Les deux requêtes déclenchent l'élagage des partitions car sale_detail2 a été créée avec une granularité 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 |
+------------+-------------+---------------------+