Maintenance et dépannage des cubes fédérés

Modélisation et test de cubes fédérés

Lors de la conception d'un cube fédéré Essbase, suivez ces directives de conception et de test pour une approche progressive de la résolution des problèmes ou de la surveillance des performances.

Lancez le projet de cube fédéré sur un environnement de test.
Commencez par les modèles Essbase de cube ASO ou BSO qui présentent les caractéristiques suivantes :
- Peu de niveaux
- Peu d'attributs ou de membres partagés

Lors de la création d'une partition fédérée, planifiez des opérations hors ligne lorsque les requêtes portant sur l'instance ne sont pas autorisées.
Déconnectez progressivement les sessions utilisateur Essbase actives, à l'aide des instructionsMaxL altérer l'application disable commands et/ou disable connects (pour éviter toute nouvelle activité utilisateur), suivies de alter system logout session et/ou kill request (si vous devez mettre fin à des sessions actives qui n'ont pas besoin d'être terminées). MaxL ne peut pas mettre fin aux demandes qui sont éventuellement en cours d'exécution dans Autonomous AI Lakehouse. Si vous désactivez les commandes dans l'application, n'oubliez pas de les réactiver après la création de la partition fédérée.

Pour mettre fin aux demandes en cours d'exécution en tant que sessions SQL dans Autonomous AI Lakehouse, des étapes supplémentaires sont requises. Reportez-vous à Annulation du code SQL à longue durée d'exécution sur les cubes fédérés.
Ajustez les délais d'expiration :
- Proxy HTTPS sur réseau client : ajustez les délais d'expiration du réseau client.
- Equilibreur de charge : augmentez le délai d'expiration LoadBalance jusqu'à 1 260 secondes (21 minutes).
- Augmentez les délais d'expiration HTTPD jusqu'à 21 minutes :
```
/etc/httpd/conf.d/00_base.conf:ProxyTimeout 1260
```
```
/etc/httpd/conf.d/00_base.conf:Timeout 1260
```
- Délai d'expiration APS/JAPI :
  - Sur la page Console de l'interface Web Essbase, sélectionnez Configuration et notez la valeur de olap.server.netSocketTimeOut. Une valeur de 200 ms correspond à 1 seconde d'attente toutes les 5 propriétés.
  - Pour fixer la limite du délai d'expiration APS/JAPI à 30 minutes, définissez olap.server.netRetryCount sur 9000.
Créez la partition fédérée.
Rétablissez les ajustements de délai d'expiration de l'étape 3.
Autorisez les utilisateurs de revenir dans le système à l'aide des instructions alter application enable commands et/ou connects, si les fonctions ont été désactivées précédemment.
Pour les rapports sur un cube fédéré, réglez QRYGOVEXECTIME pour qu'il soit plus long que le temps attendu pour exécuter des requêtes sur les partitions fédérées. QRYGOVEXECTIME ne peut pas mettre fin aux demandes qui sont éventuellement en cours d'exécution dans Autonomous AI Lakehouse.
Une fois l'environnement de développement testé et ajusté, suivez les étapes 1 à 7 ci-dessus pour implémenter un environnement de production.

Remarques :

Si le message d'erreur Echec de l'enregistrement de l'outline s'affiche lors de la création de la partition fédérée, attendez la fin des sessions, puis actualisez le navigateur. Si la partition fédérée a été créée, validez-la dans SQL Developer. Si la validation est effectuée dans SQL Developer, le cube fédéré est prêt à être utilisé. Sinon, le modèle doit être corrigé et le réglage du délai comme décrit à l'étape 3 ci-dessus est nécessaire.

Précautions relatives aux métadonnées pour les cubes fédérés

Soyez prudent lorsque vous modifiez l'outline d'un cube fédéré non géré par Essbase. Si vous ajoutez ou renommez les membres, assurez-vous que les modifications des métadonnées sont également représentées dans le tableau de faits dans Autonomous AI Lakehouse.

Cette rubrique ne s'applique pas aux cubes fédérés avec le stockage de données géré Essbase.

Si l'outline Essbase n'est plus synchronisée avec la table de faits dans Autonomous AI Lakehouse, le cube fédéré devient non valide ou ne fonctionne pas correctement. Pour résoudre ce problème, vous devrez supprimer la partition fédérée, apporter des modifications à l'outline et à la table de faits, puis recréer la partition fédérée.

Si un cube fédéré n'est plus valide, vous risquez de rencontrer une erreur commençant par Essbase Error(1040235): Remote warning from federated partition.

Les types de modification suivants de l'outline Essbase entraîneront la non-validation d'un cube fédéré (non géré par Essbase) :

Ajout, changement de nom ou suppression de dimensions
Ajout, changement de nom ou suppression de membres stockés dans la dimension de pivot
Définition d'un membre stocké en tant que membre dynamique

Pour les autres types de modification d'outline Essbase non indiqués ci-dessus (par exemple, ajout ou changement de nom d'un membre d'une dimension autre que de pivot), vous devez modifier en conséquence la ligne de données concernée dans la table de faits. Sinon, le cube fédéré risque de ne pas fonctionner correctement.

Si vous savez à l'avance que les métadonnées de l'outline Essbase seront modifiées, il est préférable de commencer par enlever la partition fédérée, d'apporter les modifications à l'outline, de mettre à jour la table de faits, puis de recréer la partition fédérée.

Toutefois, si les métadonnées Essbase sont modifiées et rendent la partition fédérée non valide, procédez comme suit :

Enlevez la partition fédérée et la connexion qui lui est associée (si elle n'est employée à aucun autre niveau), comme décrit dans Suppression d'une partition fédérée.

A partir du schéma utilisateur dans Autonomous AI Lakehouse, supprimez manuellement les tables générées par Essbase et les autres objets qui n'ont pas été enlevés avec la partition fédérée.
Vérifiez que les modifications d'outline sont effectuées dans le cube Essbase.
Créez de nouveau la table de faits. Reportez-vous à Création de la table de faits.
Recréez la connexion à Autonomous AI Lakehouse. Cette connexion peut être globale (sous l'icône Sources principale dans l'interface Web Essbase) ou elle peut se trouver dans les sources définies uniquement pour l'application. Suivez les instructions fournies dans Création d'une connexion pour les cubes fédérés.
Recréez la partition fédérée, comme décrit dans Création d'une partition fédérée.

Annuler le code SQL à longue durée d'exécution sur les cubes fédérés

Vous pouvez annuler les sessions SQL en cours d'exécution sur les cubes fédérés Essbase. L'annulation SQL peut être nécessaire si un calcul prend trop de temps ou si le cube fédéré nécessite une sauvegarde ou une récupération.

Si les calculs, chargements de données ou agrégations Essbase exécutés sur des cubes fédérés génèrent des instructions SQL à longue durée d'exécution, il est possible d'annuler les sessions, même si elles sont exécutées sur Autonomous AI Lakehouse.

Pour que l'annulation de session SQL via Essbase puisse être disponible, vous devez exécuter un bref workflow d'étapes afin d'activer SQL Session Governor dans Essbase.

Les utilisateurs disposant des types d'accès suivants sont impliqués dans les étapes de préparation.

Type d'utilisateur	Rôle dans le workflow
Administrateur de base de données	Connaît le nom et le mot de passe du schéma d'administrateur pour Autonomous AI Lakehouse. Peut créer des procédures PL/SQL stockées sur Autonomous AI Lakehouse et accorder des privilèges à d'autres utilisateurs.
Utilisateur de base de données Egalement appelé utilisateur de partition fédérée	Connaît le nom du schéma Autonomous AI Lakehouse, le même schéma et mot de travail que celui utilisé pour créer la connexion Essbase à Oracle Database (un prérequis requis avant de créer la partition fédérée).
Gestionnaire d'applications Essbase	Gestionnaire/propriétaire d'une application Essbase utilisée pour un cube fédéré.

Pour activer SQL Session Governor, vous devez effectuer les étapes suivantes :

Administrateur de base de données : créez les procédures stockées PL/SQL suivantes dans Autonomous AI Lakehouse et accordez le privilège EXECUTE à l'utilisateur de base de données :

Remarques :

Les procédures stockées doivent être créées sur le schéma utilisateur de base de données.

ESS_SESSION_SET_MODULE (jagent_id dans VARCHAR2,app_name dans VARCHAR2, db_name dans VARCHAR2, req_id dans VARCHAR2)

Pour créer une procédure, utilisez l'instruction suivante :

CREATE OR REPLACE NONEDITIONABLE PROCEDURE "ESS_SESSION_SET_MODULE" (jagent_id in VARCHAR2, app_name in VARCHAR2, db_name in VARCHAR2, req_id in VARCHAR2) AS
    ess_jagentid VARCHAR2(256);
    ess_appname VARCHAR2(256);
    ess_dbname VARCHAR2(256);
    ess_reqid VARCHAR2(256);
    hash_str VARCHAR2(100);
BEGIN
    IF jagent_id is not NULL AND app_name is not NULL AND db_name is not NULL AND req_id is not NULL THEN
        -- add prefixes to identify essbase sessions
        ess_jagentid := CONCAT('ess_jagentid_', jagent_id);
        ess_appname := CONCAT('ess_appname_', app_name);
        ess_dbname := CONCAT('ess_dbname_', db_name);
        ess_reqid := CONCAT('ess_reqid_', req_id);

        -- ess_jagentid is stored in client_info
        dbms_application_info.set_client_info(ess_jagentid);

        -- create hash out of CONCAT(ess_jagentid, ess_appname, ess_dbname)
        -- the hash identifies the fed partition
        -- store the hash as the module
        -- store the ess_reqid as the action
        SELECT TO_CHAR(ORA_HASH(CONCAT(CONCAT(ess_jagentid, ess_appname), ess_dbname))) INTO hash_str from dual;
        dbms_application_info.set_module(module_name => hash_str, action_name => ess_reqid);
        
    ELSIF jagent_id is NULL AND app_name is NULL AND db_name is NULL AND req_id is NULL THEN
        -- reset session
        dbms_application_info.set_module(null,null);
        dbms_application_info.set_client_info(null);
    END IF;
END ESS_SESSION_SET_MODULE;

ESS_SESSION_CANCEL (jagent_id dans VARCHAR2, app_name dans VARCHAR2, db_name dans VARCHAR2, req_id dans VARCHAR2)

Pour créer une procédure, utilisez l'instruction suivante :

CREATE OR REPLACE NONEDITIONABLE PROCEDURE "ESS_SESSION_CANCEL" (jagent_id in VARCHAR2, app_name in VARCHAR2, db_name in VARCHAR2, req_id in VARCHAR2) AS
    ess_jagentid VARCHAR2(256);
    ess_appname VARCHAR2(256);
    ess_dbname VARCHAR2(256);
    ess_reqid VARCHAR2(256);
    uname VARCHAR2(100);
    hash_str VARCHAR2(100);
    sessionid VARCHAR2(100);
    killcmd VARCHAR2(1000);
    XCP_MARKED_FOR_TERMINATION exception;
    pragma exception_init (XCP_MARKED_FOR_TERMINATION, -00031);
BEGIN
    -- add prefixes to identify Essbase sessions
    ess_jagentid := CONCAT('ess_jagentid_', jagent_id);
    ess_appname := CONCAT('ess_appname_', app_name);
    ess_dbname := CONCAT('ess_dbname_', db_name);
    ess_reqid := CONCAT('ess_reqid_', req_id);

    -- create hash out of CONCAT(ess_jagentid, ess_appname, ess_dbname)
    -- the hash identifies the federated partition
    SELECT TO_CHAR(ORA_HASH(CONCAT(CONCAT(ess_jagentid, ess_appname), ess_dbname))) INTO hash_str from dual;
    uname := SYS_CONTEXT('USERENV', 'SESSION_USER');

    IF jagent_id is not NULL AND app_name is not NULL AND db_name is not NULL AND req_id is not NULL THEN
        -- valid jagent_id, app_name, db_name, req_id
        -- kill sessions associated with the given federated cube and request id
        FOR r IN (select sid,serial# from v$session where username=uname AND module=hash_str AND action=ess_reqid)
        LOOP
            BEGIN
                sessionid := DBMS_ASSERT.ENQUOTE_LITERAL(r.sid || ',' || r.serial#);
                killcmd:='ALTER SYSTEM KILL SESSION ' || sessionid || ' IMMEDIATE';
                EXECUTE IMMEDIATE killcmd;
            EXCEPTION
                WHEN XCP_MARKED_FOR_TERMINATION THEN
                    -- ignore - the session could not be terminated immediately, but is marked for termination.
                    NULL;
            END;
        END LOOP;
    ELSIF jagent_id is not NULL AND app_name is not NULL AND db_name is not NULL AND req_id is NULL THEN
        -- null req_id
        -- kill all sessions for the given federated cube - invoked at app startup
        FOR r IN (select sid,serial# from v$session where username=uname AND module=hash_str)
        LOOP
            BEGIN
                sessionid := DBMS_ASSERT.ENQUOTE_LITERAL(r.sid || ',' || r.serial#);
                killcmd:='ALTER SYSTEM KILL SESSION ' || sessionid || ' IMMEDIATE';
                EXECUTE IMMEDIATE killcmd;
            EXCEPTION
                WHEN XCP_MARKED_FOR_TERMINATION THEN
                    -- ignore - the session could not be terminated immediately, but is marked for termination.
                    NULL;
            END;
        END LOOP;
    END IF;

    EXCEPTION
        WHEN OTHERS THEN
            RAISE;
END ESS_SESSION_CANCEL;

Accordez les privilèges EXECUTE pour les procédures stockées ci-dessus à l'utilisateur de base de données.

GRANT EXECUTE on ESS_SESSION_SET_MODULE TO "DB User";
GRANT EXECUTE on ESS_SESSION_CANCEL TO "DB User";
CREATE OR REPLACE SYNONYM "DB User".ESS_SESSION_SET_MODULE FOR ESS_SESSION_SET_MODULE;
CREATE OR REPLACE SYNONYM "DB User".ESS_SESSION_CANCEL FOR ESS_SESSION_CANCEL;

Utilisateur de base de données : dans votre schéma Autonomous AI Lakehouse, vérifiez que vous avez accès aux procédures stockées suivantes sous Synonymes :
- MODULE ESS_SESSION_SET
- ANNULATIONS DE SESSION
Lorsque ces prérequis sont remplis, les demandes SQL à longue durée d'exécution sur le cube fédéré peuvent être annulées de la même manière que les autres demandes Essbase. Vous pouvez annuler les demandes dans l'interface Web Essbase à partir de la zone Sessions de la console. Si vous utilisez MaxL, vous pouvez annuler des demandes à l'aide de l'instruction altérer le système kill request. Reportez-vous à Modèle et test des cubes de partition fédérés pour obtenir des instructions sur la terminaison de session.

Procédure à suivre en cas de modification des détails de connexion à la base de données

Si les détails de connexion Autonomous AI Lakehouse utilisés par Essbase pour un cube fédéré ont été modifiés, vous devrez supprimer et recréer la partition fédérée, et nettoyer les objets et les tables de métadonnées associés à partir du schéma de base de données.

Cette rubrique ne s'applique pas aux cubes fédérés avec le stockage de données géré Essbase.

Vous devrez supprimer et recréer la partition fédérée si l'un des événements suivants survient après sa création :

Le port Autonomous AI Lakehouse change
Modification du nom de la connexion
La connexion utilise un portefeuille et vous basculez d'un nom de service à l'autre (pour apporter des modifications à la simultanéité ou aux performances).
Une mise à jour d'outline modifie le mapping de membres avec la table de faits, entraînant la désynchronisation de la partition fédérée. Pour plus d'informations, reportez-vous à Précautions relatives aux métadonnées pour les cubes fédérés.

Si vous savez à l'avance que les détails de connexion seront modifiés, il est préférable d'enlever la partition fédérée avant que la modification n'ait lieu, puis de la recréer après. Toutefois, si la connexion a changé et a rendu le cube fédéré non valide, suivez les étapes ci-dessous.

Suppression de la partition fédérée

Enlevez la partition fédérée et la connexion qui lui est associée (si elle n'est pas utilisée), comme décrit dans Enlèvement d'une partition fédérée.

Nettoyage des tables de métadonnées et objets associés à la partition fédérée

A partir du schéma utilisateur de Autonomous AI Lakehouse, supprimez toutes les tables générées par Essbase et autres objets qui n'ont pas été enlevés avec la partition fédérée.

Connectez-vous via SSH à l'hôte du serveur Essbase en tant qu'utilisateur opc.
```
ssh -i MPOCI_KEY.pem opc@100.xxx.xxx.xxx
```
Remplacez-le par l'utilisateur oracle (et accédez à son répertoire de base).
```
sudo su - oracle
```
Accédez au répertoire d'applications.
```
cd /u01/data/essbase/app
```
Servez-vous du nom du cube et de l'application Essbase pour identifier le préfixe unique associé aux objets et métadonnées de partition fédérée.
1. Permet d'obtenir le nom d'application (AppName). Le nom respecte la casse. Veillez donc à respecter strictement les majuscules et minuscules. Dans cet exemple, AppName = Sample.
```
ls
Sample
```
2. Accédez au répertoire de cube et obtenez le nom du cube (DbName). Le nom respecte la casse. Veillez donc à respecter strictement les majuscules et minuscules. Dans cet exemple, DbName = Basic.
```
cd /Sample
ls
Basic
```
3. A l'aide de SQL Developer ou d'un autre outil, connectez-vous à Autonomous AI Database en tant qu'utilisateur du schéma auquel le cube fédéré est (ou a été) connecté.
4. Dans SQL Developer, exécutez une instruction SELECT pour obtenir la valeur de OTL_ID et OTL_STATUS.
  
  Le format de l'instruction SELECT est le suivant :
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION where APPNAME ='<AppName>';
```
  Exemple
  
  Remplacez Sample par AppName.
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION WHERE APPNAME='Sample';
```
  La requête ci-dessus doit renvoyer la valeur de OTL_ID ; par exemple,
```
987
```
  Remarques :
  Si des lignes sont renvoyées où OTL_STATUS est ACTIVE, vous devez essayer de supprimer l'application de l'instance TRC_HOST avant de passer à l'étape suivante.
5. Créez le fichier Prefix comme suit :
```
ESSAV_<OTL_ID>_
```
  Par exemple :
```
<Prefix> = ESSAV_987_
```
Exécutez une instruction SELECT pour créer la liste des objets associés à votre cube fédéré. Ce sont ces objets que vous allez nettoyer lors de la prochaine étape.

Le format de l'instruction SELECT est le suivant :
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE '<Prefix>%' ESCAPE '\';
```
Par exemple :
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE 'ESSAV_987_%' ESCAPE '\';
```

Exécutez une procédure PL/SQL stockée qui nettoie l'ensemble des vues, des packages, des hiérarchies, des tables et d'autres objets analytiques associés à Prefix.

Exemple

Remplacez ESSAV_987_ par Prefix.

SET SERVEROUTPUT ON;

declare
  prefix_str varchar2(70) := 'ESSAV_987_';

BEGIN

  FOR c IN ( SELECT ANALYTIC_VIEW_NAME FROM user_analytic_views WHERE ANALYTIC_VIEW_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP ANALYTIC VIEW "' || c.ANALYTIC_VIEW_NAME || '" ';
    DBMS_OUTPUT.PUT_LINE('ANALYTIC VIEW ' || c.ANALYTIC_VIEW_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct OBJECT_NAME FROM USER_PROCEDURES WHERE OBJECT_TYPE='PACKAGE' and OBJECT_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP PACKAGE "' || c.OBJECT_NAME || '" ';
    DBMS_OUTPUT.PUT_LINE('PACKAGE ' || c.OBJECT_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct HIER_NAME FROM USER_HIERARCHIES WHERE HIER_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP HIERARCHY "' || c.HIER_NAME || '" ';
    DBMS_OUTPUT.PUT_LINE('HIERARCHY ' || c.HIER_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct DIMENSION_NAME FROM USER_ATTRIBUTE_DIM_TABLES_AE WHERE DIMENSION_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP ATTRIBUTE DIMENSION "' || c.DIMENSION_NAME || '" ';
    DBMS_OUTPUT.PUT_LINE('ATTRIBUTE DIMENSION ' || c.DIMENSION_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct VIEW_NAME FROM USER_VIEWS WHERE VIEW_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP VIEW "' || c.VIEW_NAME || '" ';
    DBMS_OUTPUT.PUT_LINE('VIEW ' || c.VIEW_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct TABLE_NAME FROM USER_TABLES WHERE TABLE_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP TABLE "' || c.TABLE_NAME || '" purge';
    DBMS_OUTPUT.PUT_LINE('TABLE ' || c.TABLE_NAME || ' dropped successfully.');
  END LOOP;

  FOR c IN ( SELECT distinct TYPE_NAME FROM USER_TYPES WHERE TYPE_NAME like prefix_str || '%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP TYPE "' || c.TYPE_NAME || '" FORCE';
    DBMS_OUTPUT.PUT_LINE('TYPE ' || c.TYPE_NAME || ' dropped successfully.');
  END LOOP;

END;
/

Supprimez et mettez à jour les tables liées aux métadonnées associées.

Exécutez une procédure PL/SQL stockée pour supprimer les tables liées aux métadonnées associées à OTL_ID.

Exemple

Remplacez 987 par OTL_ID.

SET SERVEROUTPUT ON;
BEGIN
  FOR c IN ( SELECT distinct TABLE_NAME FROM USER_TABLES WHERE TABLE_NAME like 'ESSAV_MTD_987_%' )
  LOOP
    EXECUTE IMMEDIATE 'DROP TABLE "' || c.TABLE_NAME || '" purge';
    DBMS_OUTPUT.PUT_LINE('TABLE ' || c.TABLE_NAME || ' dropped successfully.');
  END LOOP;
END;
/

Exécutez une instruction UPDATE pour définir la table ESSAV_OTL_MTD_VERSION sur le statut inactif.

Exemple

Remplacez Sample par AppName.
```
UPDATE "ESSAV_OTL_MTD_VERSION" SET  "OTL_STATUS" = 'INACTIVE'  where APPNAME ='Sample';
commit;
```

Remarques :

Etant donné qu'une seule instance Essbase doit utiliser le schéma Base de données AI autonome, vous n'avez pas besoin d'indiquer ESSBASE_INSTANCE_UNIQUE_ID lorsque vous effectuez les tâches de nettoyage. Reportez-vous à Restrictions pour les cubes fédérés.

Recréation de la connexion et de la partition fédérée

Recréez la connexion à Autonomous AI Lakehouse. Cette connexion peut être globale (sous l'icône Sources principale dans l'interface Web Essbase) ou elle peut se trouver dans les sources définies uniquement pour l'application. Suivez les instructions de la section connection. Veillez à tester et à enregistrer la connexion.
Recréez la partition fédérée, comme décrit dans Création d'une partition fédérée.
Si vous continuez à voir une erreur de connexion telle que Essbase Error(1350012): Attempt to connect to OCI failed, vérifiez https://support.oracle.com/rs?type=doc&id=2925030.1.

Sauvegarde et récupération d'un cube fédéré

Les partitions fédérées ne sont pas migrées avec les applications Essbase. Lorsque vous préparez le déplacement du cube fédéré vers un autre serveur ou la migration vers une autre version d'Essbase, vous devez supprimer la partition fédérée et le recréer dans le nouvel environnement.

Pour sauvegarder le cube fédéré,

Sauvegardez l'application, sans les données, mais en incluant tout ce dont vous pouvez avoir besoin (comme les propriétés de configuration, les filtres, les variables, les scripts de calcul et les autres artefacts). Pour ce faire, utilisez LcmExport (ou le travail Exporter LCM dans l'interface Web Essbase).
Sauvegardez la table de faits. Reportez-vous à Sauvegarde et restauration d'Autonomous Database.
Supprimez la définition de partition fédérée du cube, en suivant les étapes décrites dans Enlever une partition fédérée.

Pour restaurer un cube fédéré à partir d'une sauvegarde,

Recréez l'application à l'aide de LcmImport (ou du travail Importer LCM dans l'interface Web Essbase).
Si nécessaire, restaurez la table des faits sur Autonomous AI Lakehouse.
Recréez la connexion à Autonomous AI Lakehouse. Il est recommandé d'utiliser un nouveau nom de connexion pour éviter de rencontrer des erreurs.
Recréez la partition fédérée.