Interroger les tables Iceberg d'Apache

• Iceberg natif Unity (REST) : Non pris en charge.

  Solution de rechange : Utilisez Delta + UniForm pour publier une vue lisible par Iceberg au moyen du point d'extrémité REST Iceberg du catalogue Unity.

• Catalogues REST certifiés : La base de données autonome est certifiée avec Snowflake Polaris et Databricks Unity Catalog (UniForm seulement) pour l'accès en lecture à Iceberg.

• Envoi de données d'identification de catalogue : Non pris en charge.

  La distribution en nuage native basée sur les rôles, telle que l'hypothèse de rôle automatique ou les données d'identification temporaires émises par STS, n'est pas prise en charge. Utiliser des clés d'accès/secret explicites ou des jetons statiques.)

• Données d'identification ARN AWS : Non prises en charge. Les numéros ARN du rôle IAM et AssumeRole par ARN ne sont pas acceptés.

• Les tables Iceberg partitionnées ne sont pas prises en charge; seules les tables non partitionnées sont autorisées.
• Mises à jour au niveau de la rangée (fusion en lecture) : Non prises en charge. Si les métadonnées Iceberg font référence à des fichiers de suppression, les interrogations échoueront.

• Le schéma d'une table externe fixe est déterminé lors de la création et doit être aligné avec la version du schéma Iceberg dans les métadonnées. Si le schéma Iceberg est mis à jour, la table externe doit être recréée.

• Aucun déplacement dans le temps d'interrogation : L'interrogation par instantané, version ou horodatage n'est pas prise en charge.
• Non_catalog seulement : Les nouveaux instantanés ne sont pas sélectionnés automatiquement. Pour lire un instantané spécifique, ciblez les données metadata.json de cet instantané et recréez la table externe.

• Alignement des données d'identification : Les mêmes données d'identification doivent être utilisées pour AWS S3 et AWS Glue.
• Co-emplacement de région : Les seaux S3 et le catalogue AWS Glue doivent se trouver dans la même région AWS.

• rest_auth_cred : S'authentifie avec le service de catalogue (par exemple, Unity ou Polaris).

• credential_name : S'authentifie auprès du magasin d'objets où résident les données et les métadonnées Iceberg.

• Une table Delta créée avec UniForm pour que les clients Iceberg puissent la lire.

• Fichiers de table dans Azure ADLS Gen2 ou AWS S3.

• Privilèges Unity Catalog pour l'accès externe (par exemple, l'accès aux données externes est activé); accordez EXTERNAL USE SCHEMA à votre principal).

• Auth : OAuth2 (recommandé) ou jeton d'accès personnel (pour les tests rapides).

• Configurer les listes de contrôle d'accès réseau : Avant de créer une table externe qui utilise le catalogue Unity de Databricks avec des données stockées dans le stockage BLOB Azure, vous devez accorder l'autorisation de schéma Oracle pour établir des connexions HTTPS sortantes aux services Azure requis. Comme Oracle Database bloque l'accès au réseau par défaut, vous devez mettre à jour la liste de contrôle d'accès au réseau (ACL) pour permettre au schéma d'atteindre :

  • Espace de travail Databricks, qui héberge les API du catalogue Unity et les points d'extrémité de jeton/authentification.

  • Le compte Azure Storage, qui stocke les métadonnées et les fichiers de données de la table Iceberg.

  Exemple pour configurer des listes de contrôle d'accès réseau

  BEGIN
     -- Databricks workspace (Unity Catalog and token endpoint)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<workspace>.azuredatabricks.net',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
     -- Azure Storage (metadata and data files)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<storage-account>.blob.core.windows.net',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  END;
  /

  Remplacez les paramètres fictifs suivants :

  • <workspace> : Nom de l'espace de travail Databricks utilisé dans votre URL Azure Databricks.
  • <storage-account> : Nom du compte de stockage Azure qui contient les métadonnées et les fichiers de données Iceberg.
  • <schema> : Schéma Oracle qui exécutera DBMS_CLOUD.CREATE_EXTERNAL_TABLE et nécessite un accès HTTPS.

USE CATALOG <your_catalog>;
USE SCHEMA  <your_schema>;

CREATE TABLE customers_iceberg (
  id   INT,
  name STRING
)
TBLPROPERTIES(
  'delta.columnMapping.mode'='name',
  'delta.enableIcebergCompatV2'='true',
  'delta.universalFormat.enabledFormats'='iceberg'
);

INSERT INTO customers_iceberg (id, name) VALUES
  (1,'Alice'), (2,'Bob'), (3,'Carol');

BEGIN
  BEGIN DBMS_CLOUD.DROP_CREDENTIAL('AZURE_BLOB_CRED'); EXCEPTION WHEN OTHERS THEN NULL; END;
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'AZURE_BLOB_CRED',
    username        => '<storage-account-or-sas-username>',
    password        => '<storage-key-or-sas-token>'
  );
END;
/

-- Databricks service principal (client_id / client_secret)
BEGIN
  BEGIN DBMS_CLOUD.DROP_CREDENTIAL('UNITY_OAUTH'); EXCEPTION WHEN OTHERS THEN NULL; END;
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'UNITY_OAUTH',
    username        => '<client_id>',
    password        => '<client_secret>'
  );
END;
/

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE(
    table_name      => 'CUSTOMERS_ICEBERG',
    credential_name => 'AZURE_BLOB_CRED',
    format          => '{
      "access_protocol": {
        "protocol_type": "iceberg-rest",
        "protocol_config": {
          "iceberg_catalog_type": "unity",
          "rest_catalog_endpoint": "https://<workspace-host>/api/2.1/unity-catalog/iceberg",
          "rest_authentication": {
            "rest_auth_cred": "UNITY_OAUTH",
            "rest_auth_endpoint": "https://<workspace-host>/oidc/v1/token"
          },
          "table_path": ["<your_catalog>","<your_schema>","customers_iceberg"]
        }
      }
    }'
  );
END;
/
SELECT COUNT(*) FROM CUSTOMERS_ICEBERG;

BEGIN
  BEGIN DBMS_CLOUD.DROP_CREDENTIAL('UNITY_PAT'); EXCEPTION WHEN OTHERS THEN NULL; END;
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'UNITY_PAT',
    username        => 'token',
    password        => '<dapiXXXXXXXXXXXXXXXXXXXXXXXX>'
  );
END;
/

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE(
    table_name      => 'CUSTOMERS_ICEBERG',
    credential_name => 'AZURE_BLOB_CRED',
    format          => '{
      "access_protocol": {
        "protocol_type": "iceberg-rest",
        "protocol_config": {
          "iceberg_catalog_type": "unity",
          "rest_catalog_endpoint": "https://<workspace-host>/api/2.1/unity-catalog/iceberg",
          "rest_authentication": { "rest_auth_cred": "UNITY_PAT" },
          "table_path": ["<your_catalog>","<your_schema>","customers_iceberg"]
        }
      }
    }'
  );
END;
/
SELECT COUNT(*) FROM CUSTOMERS_ICEBERG;

• Catalogue et point d'extrémité Polaris Iceberg disponibles pour votre compte.

• Fichiers de table accessibles dans votre magasin d'objets (S3/ADLS selon le cas).

• Auth : OAuth2 recommandé (données d'identification du client) ou un autre mécanisme de jeton pris en charge par Polaris.

• Avant de créer une table externe qui accède à un catalogue Iceberg stocké dans Snowflake et Amazon S3, le schéma de base de données doit être autorisé à établir des connexions HTTPS sortantes à ces services. Oracle Database restreint l'accès au réseau par défaut. Vous devez donc mettre à jour la liste de contrôle d'accès au réseau (ACL) pour permettre au schéma d'atteindre :

  • Points d'extrémité de votre compte Snowflake, utilisés pour l'accès au catalogue, l'authentification et l'échange de jetons

  • Point d'extrémité régional Amazon S3 où les métadonnées et les fichiers de données Iceberg sont stockés

  • (Facultatif) Point d'extrémité S3 non régional, requis par certaines API AWS et opérations de consultation de région

  Exemple pour configurer des listes de contrôle d'accès réseau

  BEGIN
  
     -- Allow HTTPS access to your Snowflake account (Polaris and token endpoints)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<account>.snowflakecomputing.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
     -- Allow HTTPS access to the S3 bucket (regional endpoint for data/metadata)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<bucket>.s3.<region>.amazonaws.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
     -- Optional: non-regional S3 endpoint (used for some APIs/region lookup)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<bucket>.s3.amazonaws.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
  END;
  /

  Remplacez les paramètres fictifs suivants :

  • <account> : Identificateur de votre compte Snowflake.

  • <schema> : Schéma qui nécessite un accès HTTPS sortant.

  • <bucket> : Nom du seau Amazon S3 contenant les données et métadonnées Iceberg.

  • <region> : Région AWS dans laquelle le seau S3 est hébergé.

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE(
    table_name      => 'SALES_POLARIS',
    credential_name => 'S3_CRED',
    format          => '{
      "access_protocol": {
        "protocol_type": "iceberg-rest",
        "protocol_config": {
          "iceberg_catalog_type": "polaris",
          "rest_catalog_endpoint": "<https://<your-polaris-endpoint>/...>",
          "rest_authentication": {
            "rest_auth_cred": "POLARIS_OAUTH",
            "rest_auth_endpoint": "<https://<your-oauth-token-endpoint>>"
          },
          "table_path": ["<db>","<schema>","<table>"]
        }
      }
    }'
  );
END;
/

SELECT COUNT(*) FROM SALES_POLARIS;

• Collez le catalogue de données avec la table Iceberg enregistrée (S3 objets accessibles).

  Nom de région de la colle (par exemple, us-east-1).

• Auth : Clé/secret d'accès pour S3; accès de colle au moyen de la configuration de catalogue.

• La transmission de données d'identification au moyen du numéro ARN AWS n'est pas prise en charge. Les données d'identification explicites doivent être fournies.

• Avant de créer une table externe qui utilise AWS Glue comme catalogue Iceberg et Amazon S3 comme couche de stockage, le schéma Oracle doit avoir l'autorisation d'effectuer des demandes HTTPS sortantes vers ces services AWS. Oracle Database restreint l'accès au réseau par défaut. Vous devez donc mettre à jour la liste de contrôle d'accès au réseau (ACL) pour permettre au schéma d'atteindre :

  • AWS Glue, qui fournit l'API de catalogue Iceberg

  • Point d'extrémité régional S3, où les métadonnées et les fichiers de données Iceberg sont stockés

  • Point d'extrémité S3 non régional, requis pour certaines API AWS et opérations de consultation de région

  Exemple pour configurer des listes de contrôle d'accès réseau

  BEGIN
  
     -- AWS Glue (catalog API)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => 'glue.<region>.amazonaws.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
     -- S3 bucket (regional endpoint for data and metadata files)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<bucket>.s3.<region>.amazonaws.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
     -- Optional: non-regional S3 endpoint (used for some APIs or region lookup)
     DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
        host           => '<bucket>.s3.amazonaws.com',
        lower_port     => 443,
        upper_port     => 443,
        ace            => xs$ace_type(
                             privilege_list => xs$name_list('http'),
                             principal_name => '<schema>',
                             principal_type => xs_acl.ptype_db
                          )
     );
  
  END;
  /

  Remplacez les paramètres fictifs suivants :

  • <region> : Région AWS où se trouvent Glue et le seau S3.

  • <bucket> : Nom du seau S3 qui stocke les fichiers de données et de métadonnées Iceberg.

  • <schema> : Schéma Oracle qui exécute DBMS_CLOUD.CREATE_EXTERNAL_TABLE et nécessite un accès HTTPS.

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE(
    table_name      => 'ORDERS_GLUE',
    credential_name => 'S3_CRED',
    format          => '{
      "access_protocol": {
        "protocol_type": "iceberg",
        "protocol_config": {
          "iceberg_catalog_type": "aws_glue",
          "iceberg_glue_region": "us-east-1",
          "table_path": ["<database>","<table>"]
        }
      }
    }'
  );
END;
/

SELECT COUNT(*) FROM ORDERS_GLUE;

• Vous pouvez accéder au manifeste racine (metadata.json) Iceberg de la table dans votre magasin d'objets (ADLS/S3/OCI).
• Ce chemin est un point dans le temps. Pour suivre les nouveaux instantanés, recréez la table externe.

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE(
    table_name      => 'CUSTOMERS_META',
    credential_name => 'STORE_CRED',
    file_uri_list   => 'https://<bucket-or-container>/<path>/metadata.json',
    format          => '{"access_protocol":{"protocol_type":"iceberg"}}'
  );
END;
/

BEGIN
  DBMS_CLOUD.CREATE_EXTERNAL_TABLE (
    table_name       => 'iceberg_parquet_time_dim3',
    credential_name  => 'OCI_CRED',
    format           => '{
      "access_protocol": {
        "protocol_type": "iceberg",
        "protocol_config": {
          "iceberg_catalog_type": "hadoop",
          "iceberg_lakehouse": "https://objectstorage.uk-cardiff-1.oraclecloud.com/n/my-tenancy/b/my-iceberg-bucket/o/iceberg",
          "iceberg_table_path": "db.icebergTablePy"
        }
      }
    }'
  );
END;
/