Tous les produits
Search
Centre de documentation

MaxCompute:Fonctionnalité : Requête sans schéma

Dernière mise à jour :Sep 18, 2026

MaxCompute prend en charge les requêtes sans schéma sur les tables externes Parquet dans OSS. Exportez l'ensemble de données analysé vers OSS, écrivez-le dans une table interne ou intégrez-le en tant que sous-requête dans des opérations SQL pour un traitement flexible du data lake.

Informations générales

L'exploration ad hoc de données structurées avec Spark ne nécessite pas de modèle d'entrepôt de données fixe. Toutefois, définir les schémas de table et mapper manuellement les champs de fichier avant la lecture ou l'écriture dans OSS rend la gestion des partitions lourde et peu flexible.

Avec l'instruction LOAD, MaxCompute analyse automatiquement les fichiers Parquet et lit les données sous forme d'ensemble de données conscient du schéma. Sélectionnez directement des colonnes spécifiques à partir de cet ensemble de données pour un traitement similaire aux opérations de table. Utilisez la commande UNLOAD pour exporter les résultats vers OSS, ou CREATE TABLE AS pour les importer dans une table interne. L'ensemble de données peut également servir de sous-requête dans d'autres instructions SQL pour des opérations flexibles sur les données du data lake.

Applicabilité

  • La requête sans schéma ne prend pas en charge le traitement des sous-répertoires d'un bucket OSS en tant que partitions.

  • Seul le format JSONL est pris en charge pour les données au format JSON.

Syntaxe

SELECT *, <col_name>, <table_alias>.<col_name> 
FROM 
 LOCATION '<location_path>'  
 ('key'='value' [, 'key1'='value1', ...]) 
 [AS <table_alias>];

Descriptions des paramètres

Paramètre

Obligatoire

Description

*

Oui

Interroge tous les champs du fichier.

col_name

Oui

Interroge un champ par nom de colonne dans le fichier.

Le type DECIMAL prend uniquement en charge precision <=38 && scale<=18.

table_alias.col_name

Oui

Interroge un champ par nom de colonne en utilisant le chemin complet de l'alias de table et du nom de colonne.

table_alias

Non

Alias de table personnalisé.

location_path

Oui

  • Emplacement du fichier. Il doit s'agir d'un répertoire OSS au format oss://oss_endpoint/bucket_name/path/.

  • Le niveau inférieur sous path prend en charge les répertoires de partition au format partition_name=partition_value.

  • La requête sans schéma ne prend pas en charge le traitement des sous-répertoires de l'emplacement en tant que partitions ; l'élimination des partitions n'est donc pas prise en charge.

key&value

Oui

Paramètres et leurs valeurs pour l'instruction de requête. Consultez le tableau suivant pour plus de détails.

Tableau des paramètres clé-valeur

Clé

Obligatoire

Description

Valeur

Valeur par défaut

file_format

Oui

Format de fichier à l'emplacement. Seuls les formats Parquet et JSON sont pris en charge. Les autres formats renvoient une erreur.

parquet、json

parquet

rolearn

Non

RoleARN requis pour accéder à l'emplacement.

  • Connectez-vous à la console RAM.

  • Dans le volet de navigation de gauche, sélectionnez Identities > Roles.

  • Dans la section Basic Information, vous pouvez obtenir l'ARN.

Remarque

Si vous ne spécifiez pas de RoleARN dans l'instruction SQL, le système utilise l'ARN du rôle AliyunODPSDefaultRole.

acs:ram::xxxxxx:role/aliyunodpsdefaultrole

acs:ram::1234****:role/aliyunodpsdefaultrole

file_pattern_blacklist

Non

Liste de blocage des fichiers à exclure. Les fichiers dont les noms correspondent au modèle ne sont pas lus.

"._SUCCESS$,.\\.hive_staging.*"

Aucun

file_pattern_whitelist

Non

Liste d'autorisation des fichiers à inclure. Seuls les fichiers dont les noms correspondent au modèle sont lus.

"._20250124_..parquet"

.*

Exemples

Exemple 1 : Lire les données OSS à l'aide des paramètres de liste de blocage et de liste d'autorisation

  1. Préparez les données.

    1. Connectez-vous à la console OSS.

    2. Dans le volet de navigation de gauche, cliquez sur Buckets.

    3. Sur la page Buckets, cliquez sur Create Bucket.

    4. Créez le répertoire de bucket OSS object-table-test/schema/.

    5. Préparez un fichier Parquet pour la lecture et la validation de la liste d'autorisation. Exécutez le code Python suivant localement pour créer le fichier.

      import pandas as pd
      # Sample data
      data = [
          {'id': 3, 'name': 'Charlie', 'age': 35},
          {'id': 4, 'name': 'David', 'age': 40},
          {'id': 5, 'name': 'Eve', 'age': 28}
      ]
      df = pd.DataFrame(data)
      df['id'] = df['id'].astype('int32')
      df['name'] = df['name'].astype('str')
      df['age'] = df['age'].astype('int32')
      output_filename = 'sample_data.parquet'
      df.to_parquet(output_filename, index=False, engine='pyarrow')
      
    6. Téléchargez le fichier Parquet dans le répertoire de bucket OSS object-table-test/schema/.

      1. Connectez-vous à la console OSS.

      2. Dans le répertoire de bucket object-table-test/schema/, cliquez sur Upload File.

    7. Préparez un fichier CSV dans le répertoire de bucket OSS object-table-test/schema/ pour valider le paramètre de liste de blocage.

  2. Lisez le fichier Parquet.

    Connectez-vous au client MaxCompute (odpscmd) et exécutez les commandes SQL suivantes.

    • Ajoutez test_oss.csv à la liste de blocage et lisez le fichier Parquet depuis OSS.

      SELECT id, name, age 
      FROM location 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/'
      (
      'file_format'='parquet',
      'rolearn'='acs:ram::<uid>:role/aliyunodpsdefaultrole',
      'file_pattern_blacklist'='.*test_oss.*'
      );
    • Ajoutez sample_data à la liste d'autorisation et lisez le fichier Parquet depuis OSS.

      SELECT id, name, age 
      FROM location 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/'
      (
      'file_format'='parquet',
      'rolearn'='acs:ram::<uid>:role/aliyunodpsdefaultrole',
      'file_pattern_whitelist'='.*sample_data.*'
      );

    Dans les deux cas, le fichier sample_data est lu. Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+

Exemple 2 : Lire les données écrites par Spark

  1. Créez le répertoire de bucket OSS object-table-test/spark/.

  2. Générez des données Parquet à l'aide de Serverless Spark. Pour plus d'informations, consultez la rubrique Créer une tâche SQL. Ignorez cette étape si des fichiers Parquet écrits par Spark existent déjà dans le répertoire OSS.

    1. Connectez-vous à la console E-MapReduce et sélectionnez une région dans le coin supérieur gauche.

    2. Dans le volet de navigation de gauche, choisissez EMR Serverless > Spark.

    3. Sur la page Spark, cliquez sur le nom de votre espace de travail cible pour l'ouvrir. Vous pouvez également cliquer sur Create Workspace. Une fois le nouvel espace de travail créé, cliquez sur son nom pour l'ouvrir.

    4. Dans le volet de navigation de gauche, choisissez Data Development, puis créez un fichier Spark SQL pour exécuter les instructions SQL suivantes :

      CREATE TABLE example_table_parquet04 (
          id STRING,
          name STRING,
          age STRING,
          salary DOUBLE,
          is_active BOOLEAN,
          created_at TIMESTAMP,
          details STRUCT<department:STRING, position:STRING>
      )
      USING PARQUET;
      INSERT INTO example_table_parquet04 VALUES
      ('1', 'Alice', '30', 5000.50, TRUE, TIMESTAMP '2024-01-01 10:00:00', STRUCT('HR', 'Manager')),
      ('2', 'Bob', '25', 6000.75, FALSE, TIMESTAMP '2024-02-01 11:00:00', STRUCT('Engineering', 'Developer')),
      ('3', 'Charlie','35', 7000.00, TRUE, TIMESTAMP '2024-03-01 12:00:00', STRUCT('Marketing', 'Analyst')),
      ('4', 'David', '40', 8000.25, FALSE, TIMESTAMP '2024-04-01 13:00:00', STRUCT('Sales', 'Representative')),
      ('5', 'Eve', '28', 5500.50, TRUE, TIMESTAMP '2024-05-01 14:00:00', STRUCT('Support', 'Technician'));
      SELECT * FROM example_table_parquet04;
  3. Connectez-vous à la console OSS et affichez les fichiers de données générés dans le chemin de destination.

  4. Connectez-vous au client MaxCompute, ajoutez _SUCCESS à la liste de blocage et lisez le fichier Parquet depuis OSS.

    SELECT  *
    FROM location 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/spark/example_table_parquet04/'
    (
    'file_format'='parquet',
    'rolearn'='acs:ram::<uid>:role/aliyunodpsdefaultrole',
    'file_pattern_blacklist'='.*_SUCCESS.*'
    );

    Le résultat suivant est renvoyé :

    +----+---------+-----+------------+-----------+---------------------+----------------------------------------------+
    | id | name    | age | salary     | is_active | created_at          | details                                      |
    +----+---------+-----+------------+-----------+---------------------+----------------------------------------------+
    | 1  | Alice   | 30  | 5000.5     | true      | 2024-01-01 10:00:00 | {department:HR, position:Manager}            |
    | 2  | Bob     | 25  | 6000.75    | false     | 2024-02-01 11:00:00 | {department:Engineering, position:Developer} |
    | 3  | Charlie | 35  | 7000.0     | true      | 2024-03-01 12:00:00 | {department:Marketing, position:Analyst}     |
    | 4  | David   | 40  | 8000.25    | false     | 2024-04-01 13:00:00 | {department:Sales, position:Representative}  |
    | 5  | Eve     | 28  | 5500.5     | true      | 2024-05-01 14:00:00 | {department:Support, position:Technician}    |
    +----+---------+-----+------------+-----------+---------------------+----------------------------------------------+

Pour plus d'informations sur les opérations de requête sans schéma, consultez la rubrique Lire des données Parquet d'un data lake à l'aide d'une requête sans schéma.

Exemple 3 : Utiliser une requête sans schéma dans une sous-requête

  1. Préparez les données.

    Connectez-vous à la console OSS et téléchargez le fichier de test part-00001.snappy.parquet dans le répertoire de bucket OSS object-table-test/schema/. Pour plus d'informations, consultez la rubrique Télécharger des fichiers OSS.

  2. Connectez-vous au client MaxCompute et créez une table interne pour stocker les données découvertes automatiquement depuis OSS.

    CREATE TABLE ow_test (
        id INT,
        name STRING,
        age INT
    );
  3. Utilisez une requête sans schéma pour lire les données depuis OSS.

    SELECT * FROM 
    LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
    (
      'file_format'='parquet'
    );

    Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+
  4. Utilisez les données OSS comme sous-requête dans une instruction SQL externe pour les insérer dans la table ow_test.

    INSERT OVERWRITE TABLE ow_test
    SELECT id,name,age FROM 
    (
        SELECT * FROM 
        LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
        (
          'file_format'='parquet'
        )
    );
    SELECT * FROM ow_test;

    Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+

Exemple 4 : Enregistrer les résultats d'une requête sans schéma dans une table d'entrepôt de données interne

  1. Préparez les données.

    Connectez-vous à la console OSS et téléchargez le fichier de test part-00001.snappy.parquet dans le répertoire de bucket OSS object-table-test/schema/. Pour plus d'informations, consultez la rubrique Télécharger des fichiers OSS.

  2. Connectez-vous au client MaxCompute et utilisez une requête sans schéma pour lire les données depuis OSS.

    SELECT * FROM 
    LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
    (
      'file_format'='parquet'
    );

    Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+
  3. Utilisez l'instruction CREATE TABLE AS pour copier les données OSS découvertes automatiquement dans une table interne, puis interrogez la table pour afficher le résultat.

    CREATE TABLE ow_test_2 AS 
      SELECT * FROM 
      LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
      (
        'file_format'='parquet'
       );
    -- Query the result table ow_test_2
    SELECT * FROM ow_test_2;

    Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+

Exemple 5 : Exporter les résultats d'une requête sans schéma vers le data lake à l'aide de la commande UNLOAD

  1. Préparez les données.

    Connectez-vous à la console OSS et téléchargez le fichier de test part-00001.snappy.parquet dans le répertoire de bucket OSS object-table-test/schema/. Pour plus d'informations, consultez la rubrique Télécharger des fichiers OSS.

  2. Connectez-vous au client MaxCompute et utilisez une requête sans schéma pour lire les données depuis OSS.

    SELECT * FROM 
    LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
    (
      'file_format'='parquet'
    );

    Le résultat suivant est renvoyé :

    +------------+------------+------------+
    | id         | name       | age        |
    +------------+------------+------------+
    | 3          | Charlie    | 35         |
    | 4          | David      | 40         |
    | 5          | Eve        | 28         |
    +------------+------------+------------+
  3. Utilisez la commande UNLOAD pour exporter les résultats découverts automatiquement vers OSS. Pour plus d'informations, consultez la rubrique UNLOAD.

    UNLOAD FROM (
      SELECT * FROM 
      LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/schema/' 
      ('file_format'='parquet')
    ) 
    INTO 
    LOCATION 'oss://oss-cn-hangzhou-internal.aliyuncs.com/object-table-test/unload/ow_test_3/'
    ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
    WITH SERDEPROPERTIES ('odps.external.data.enable.extension'='true')
    STORED AS PARQUET;

    Affichez le fichier généré dans le répertoire OSS : après l'exécution réussie de la commande, le fichier Parquet 20250715070650775g0etr15glr2_M1_1_0_0-0_TableSink1.parquet est généré dans le chemin OSS unload/ow_test_3/. La taille du fichier est de 0,449 Ko et la classe de stockage est Standard.

Exemple 6 : Lire des données au format JSON

Seuls les fichiers JSONL sont pris en charge.

  1. Téléchargez les données de test JSONL vers OSS. sample_data.jsonl

  2. Lisez sample_data.jsonl à l'aide d'une requête sans schéma.

    SELECT  *
    FROM location 'oss://oss-<region>-internal.aliyuncs.com/<path>'
    (
        'file_format'='json',
        'rolearn'='acs:ram::<uid>:role/aliyunodpsdefaultrole'
    );