Gestione e risoluzione dei problemi di un cubo federato

Modella ed esegui il test dei cubi federati

Quando si progetta un cubo federato Essbase, seguire queste linee guida di progettazione e test per un approccio graduale alla risoluzione dei problemi o al monitoraggio delle prestazioni.

Avviare il progetto cubo federato in un ambiente di test.
Iniziare con modelli di cubo ASO o BSO di Essbase che hanno le caratteristiche seguenti:
- non hanno molti livelli
- non hanno molti membri o attributi condivisi

Quando si crea una partizione federata, è preferibile pianificare le operazioni non in linea quando le query sull'istanza in corso non sono consentite.
Disconnettere gradualmente le sessioni utente Essbase attive, utilizzando l'istruzione MaxL alter application disable commands e/o disable connects (per impedire qualsiasi nuova attività dell'utente), seguita dall'istruzione alter system logout session e/o kill request (se occorre terminare le sessioni attive che non devono essere completate). Tenere presente che MaxL non può interrompere le richieste in esecuzione in Autonomous AI Lakehouse. Se si disabilitano i comandi nell'applicazione, ricordarsi di riabilitarli dopo aver creato la partizione federata.

Per arrestare le richieste in esecuzione come sessioni SQL in Autonomous AI Lakehouse, sono necessari passi aggiuntivi. Vedere Annulla SQL con tempi di esecuzione lunghi su cubi federati.
Eseguire il tuning di timeout:
- Proxy HTTPS nella rete del cliente: regolare i timeout della rete del cliente
- Load balancer: aumentare il timeout LoadBalance portandolo a 1260 secondi (21 minuti)
- Aumentare il timeout HTTPD portandolo a 21 minuti
```
/etc/httpd/conf.d/00_base.conf:ProxyTimeout 1260
```
```
/etc/httpd/conf.d/00_base.conf:Timeout 1260
```
- Timeout APS/JAPI:
  - Nella pagina Console nell'interfaccia Web diEssbase, selezionare Configurazione e prendere nota del valore di olap.server.netSocketTimeOut. Il valore 200 millisecondi indica che ogni conteggio di 5 per queste proprietà genera 1 secondo di tempo di attesa.
  - Per impostare il limite di timeout APS/JAPI su 30 minuti, impostare olap.server.netRetryCount su 9000.
Creare la partizione federata.
Annullare le regolazioni di timeout effettuate nel passo 3.
Abilita di nuovo gli utenti per l'accesso al sistema mediante enable command con enable command e/o connect, se erano stati disabilitati in precedenza.
Per i report su un cubo federato, sottoporre a tuning QRYGOVEXECTIME in modo che sia più grande del tempo previsto per eseguire le query su partizioni federate. Tenere presente che QRYGOVEXECTIME non può interrompere le richieste in esecuzione in Autonomous AI Lakehouse.
Dopo il completamento dell'ambiente di sviluppo e il tuning, utilizzare i passaggi da 1 a 7 precedenti per implementare un ambiente di produzione.

Nota

Se viene visualizzato il messaggio di errore "Impossibile salvare il profilo" durante la creazione della partizione federata, attendere il completamento delle sessioni, quindi aggiornare il browser. Se è stata creata, convalidare la partizione federata in SQL Developer. Una volta convalidata in SQL Developer, il cubo federato è pronto per l'uso. In caso contrario, il modello deve essere corretto e sarà necessario eseguire l'ottimizzazione del timeout come descritto nel passo 3.

Precauzioni dei metadati per i cubi federati

Prestare attenzione quando si modifica il profilo per un cubo federato non gestito da Essbase. Se si aggiungono o vengono rinominati membri, accertarsi che le modifiche AI metadati siano rappresentate anche nella tabella fact in Autonomous AI Lakehouse.

Questo argomento non si applica ai cubi federati con memorizzazione dati gestita di Essbase.

Se il profilo Essbase non viene sincronizzato con la tabella fact in Autonomous AI Lakehouse, il cubo federato non sarà più valido o non funzionerà correttamente. Per risolvere il problema, è necessario eliminare la partizione federata, apportare modifiche al profilo e alla tabella fact, quindi ricreare la partizione federata.

Se un cubo federato diventa non valido, è possibile che si verifichi un errore che inizia con Essbase Error(1040235): Remote warning from federated partition.

I seguenti tipi di modifiche del profilo di Essbase renderanno non valido un cubo federato (non gestito da Essbase):

aggiunta, ridenominazione o rimozione di dimensioni;
aggiunta, ridenominazione o rimozione di membri memorizzati nella dimensione pivot;
modifica di qualsiasi membro da memorizzato a dinamico.

Per altri tipi di modifiche al profilo Essbase non indicate in precedenza, ad esempio l'aggiunta o la ridenominazione di un membro di dimensione non pivot, è necessario apportare la modifica corrispondente alla riga di dati interessata nella tabella fact. In caso contrario, il cubo federato potrebbe non funzionare correttamente.

Se si sa in anticipo che i metadati del profilo Essbase verranno modificati, è preferibile rimuovere prima la partizione federata, apportare le modifiche al profilo, aggiornare la tabella fact, quindi ricreare la partizione federata.

Tuttavia, se i metadati Essbase sono stati modificati rendendo la partizione federata non più valida, attenersi alla procedura riportata di seguito.

Rimuovere la partizione federata e la connessione ad essa associata (se non utilizzata), come descritto in Rimuovi una partizione federata.

Dallo schema utente di Autonomous AI Lakehouse eliminare manualmente le tabelle generate da Essbase e gli altri oggetti che non è stato possibile rimuovere con la partizione federata.
Assicurarsi che le modifiche apportate al profilo siano state completate nel cubo Essbase.
Creare di nuovo la tabella fact. Vedere Creazione della tabella fact.
Ricreare la connessione a Autonomous AI Lakehouse. Può trattarsi di una connessione globale (sotto l'icona principale Origini nell'interfaccia Web di Essbase) oppure può trovarsi nelle origini definite solo per l'applicazione. Seguire le istruzioni riportate in Crea una connessione per cubi federati.
Ricreare la partizione federata, come descritto in Create a Federated Partition.

Annulla SQL con tempi di esecuzione lunghi su cubi federati

È possibile annullare le sessioni SQL in esecuzione sui cubi federati di Essbase. L'annullamento SQL può essere necessario se un calcolo richiede troppo tempo o se il cubo federato richiede backup o recupero.

Se i calcoli, i caricamenti di dati o le aggregazioni di Essbase in esecuzione su cubi federati generano istruzioni SQL con tempi di esecuzione lunghi, è possibile annullare le sessioni, anche se sono in esecuzione su Autonomous AI Lakehouse.

Prima che l'annullamento della sessione SQL tramite Essbase possa diventare disponibile, è necessario completare un breve flusso di lavoro di passi per abilitare SQL Session Governor in Essbase.

Gli utenti con i seguenti tipi di accesso sono coinvolti nei passi di preparazione.

Tipo di utente	Ruolo nel workflow
Amministratore DB	Conosce il nome e la password dello schema di amministratore per Autonomous AI Lakehouse. Può creare procedure PL/SQL memorizzate in Autonomous AI Lakehouse e concedere privilegi ad altri utenti.
Utente DB Indicata anche come utente partizione federata	Conosce il nome e la password dello schema Autonomous AI Lakehouse, lo stesso schema e la stessa password utilizzati per creare la connessione Essbase a Oracle Database (un prerequisito necessario prima di creare la partizione federata).
Manager applicazioni Essbase	Manager/proprietario di un'applicazione Essbase utilizzata per un cubo federato.

Per abilitare SQL Session Governor è necessario completare il workflow dei passi riportato di seguito.

Amministratore DB: creare le stored procedure PL/SQL seguenti in Autonomous AI Lakehouse e concedere il privilegio EXECUTE all'utente DB:

Nota

Le stored procedure devono essere create nello schema utente del database.

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

Per creare la routine, utilizzare l'istruzione seguente:

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 in VARCHAR2, app_name in VARCHAR2, db_name in VARCHAR2, req_id in VARCHAR2)

Utilizzare l'istruzione seguente per creare la routine:

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;

Concedere i privilegi EXECUTE per le stored procedure precedenti all'utente DB.

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;

Utente DB: nello schema Autonomous AI Lakehouse, confermare di avere accesso alle stored procedure riportate di seguito in Sinonimi:
- ESS_SESSION_SET_MODULE
- ESS_SESSIONE_CANCELLA
Se questi prerequisiti vengono soddisfatti, le richieste SQL con tempi di esecuzione lunghi nel cubo federato possono essere annullate allo stesso modo di altre richieste Essbase. Le richieste possono essere annullate nell'interfaccia Web Essbase dall'area Sessioni della console. Se si utilizza MaxL, è possibile annullare le richieste utilizzando l'istruzione alter system kill request. Per informazioni sull'interruzione della sessione, vedere Model and Test Federated Partition Cubes.

Cosa fare se i dettagli di connessione al database sono stati modificati

Se i dettagli di connessione Autonomous AI Lakehouse utilizzati da Essbase per un cubo federato sono stati modificati, sarà necessario eliminare e ricreare la partizione federata ed eseguire il cleanup degli oggetti e delle tabelle di metadati associati dallo schema di database.

Questo argomento non si applica ai cubi federati con memorizzazione dati gestita di Essbase.

Se dopo la creazione della partizione federata si verifica uno o più degli eventi riportati di seguito, sarà necessario eliminare e ricreare la partizione federata.

Modifiche alla porta Autonomous AI Lakehouse
Modifica del nome della connessione
La connessione utilizza un wallet e si passa da una denominazione di servizio a un altro (per apportare modifiche alla prestazioni o all'accesso concorrente)
Un aggiornamento del profilo modifica il mapping dei membri nella tabella fact, rendendo la partizione federata non sincronizzata. Per informazioni dettagliate, vedere Precauzioni metadati per cubi federati.

Se si sa in anticipo che i dettagli della connessione verranno modificati, è preferibile rimuovere la partizione federata prima che si verifichi la modifica e crearla di nuovo in seguito. Tuttavia, se la connessione è stata modificata e il cubo federato non è più valido, procedere come segue.

Eliminare la partizione federata

Rimuovere la partizione federata e la connessione ad essa associata (se non utilizzata), come descritto in Rimuovi una partizione federata.

Eseguire il cleanup degli oggetti e delle tabelle di metadati correlati alla partizione federata

Dallo schema utente di Autonomous AI Lakehouse eliminare tutte le tabelle generate da Essbase e gli altri oggetti che non è stato possibile rimuovere con la partizione federata.

Collegarsi tramite SSH all'host del server Essbase come utente opc.
```
ssh -i MPOCI_KEY.pem opc@100.xxx.xxx.xxx
```
Passare all'utente oracle e andare alla relativa directory home.
```
sudo su - oracle
```
Andare alla directory delle applicazioni.
```
cd /u01/data/essbase/app
```
Utilizzando il nome dell'applicazione e del cubo Essbase, identificare il prefisso univoco associato agli oggetti e ai metadati della partizione federata.
1. Consente di ottenere il nome dell'applicazione (AppName). Il nome fa distinzione tra maiuscole e minuscole, pertanto acquisire la forma esatta. In questo esempio, AppName = Esempio.
```
ls
Sample
```
2. Passare alla directory del cubo e ottenere il nome del cubo (DbName). Il nome fa distinzione tra maiuscole e minuscole, pertanto acquisire la forma esatta. In questo esempio, DbName = Basic.
```
cd /Sample
ls
Basic
```
3. Utilizzando SQL Developer o un altro strumento, connettersi a Autonomous AI Database come utente dello schema al quale è (o era) connesso il cubo federato.
4. In SQL Developer eseguire un'istruzione SELECT per ottenere il valore OTL_ID e OTL_STATUS.
  
  Formato dell'istruzione SELECT:
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION where APPNAME ='<AppName>';
```
  Esempio
  
  Sostituire Sample con AppName.
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION WHERE APPNAME='Sample';
```
  La query precedente deve restituire il valore di OTL_ID; ad esempio,
```
987
```
  Nota
  Se vengono restituite righe in cui OTL_STATUS è ACTIVE, è necessario tentare di eliminare l'applicazione dall'istanza TRC_HOST prima di continuare con il passo successivo.
5. Creare Prefix come indicato di seguito.
```
ESSAV_<OTL_ID>_
```
  Esempio:
```
<Prefix> = ESSAV_987_
```
Eseguire un'istruzione SELECT per creare una lista di oggetti associati al cubo federato. Si tratta degli oggetti di cui verrà eseguito il cleanup nel passo successivo.

Formato dell'istruzione SELECT:
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE '<Prefix>%' ESCAPE '\';
```
Esempio:
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE 'ESSAV_987_%' ESCAPE '\';
```

Eseguire una procedura PL/SQL memorizzata per eseguire il cleanup di tutte le viste analitiche, i pacchetti, le gerarchie, le tabelle e gli altri oggetti associati a Prefix.

Esempio

Sostituire ESSAV_987_ con 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;
/

Eliminare e aggiornare le tabelle associate relative ai metadati.

Eseguire una procedura PL/SQL memorizzata per eliminare le tabelle correlate ai metadati associate a OTL_ID.

Esempio

Sostituire 987 con 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;
/

Eseguire un'istruzione UPDATE per impostare la tabella ESSAV_OTL_MTD_VERSION sullo stato inattivo.

Esempio

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

Nota

Poiché solo un'istanza di Essbase deve utilizzare lo schema di Autonomous AI Database, non è necessario specificare ESSBASE_INSTANCE_UNIQUE_ID quando si eseguono i task di cleanup. Vedere Limitazioni per i cubi federati.

Ricreare la connessione e la partizione federata

Ricreare la connessione a Autonomous AI Lakehouse. Può trattarsi di una connessione globale (sotto l'icona principale Origini nell'interfaccia Web di Essbase) oppure può trovarsi nelle origini definite solo per l'applicazione. Seguire le istruzioni nella connessione. Accertarsi di eseguire il test della connessione e di salvarla.
Ricreare la partizione federata, come descritto in Create a Federated Partition.
Se si continua a visualizzare un errore di connessione, ad esempio Essbase Error(1350012): Attempt to connect to OCI failed, selezionare https://support.oracle.com/rs?type=doc&id=2925030.1.

Eseguire il backup e il backup di un cubo federato

Le partizioni federate non vengono migrate con le applicazioni Essbase. Quando si prepara lo spostamento del cubo federato in un altro server o la migrazione a un'altra versione di Essbase, è necessario eliminare la partizione federata e ricrearla nel nuovo ambiente.

Per eseguire il back up del cubo federato,

Eseguire il backup dell'applicazione, senza i dati, ma includendo qualsiasi altro elemento che potrebbe essere necessario (ad esempio, proprietà di configurazione, filtri, variabili, script di calcolo e altri artifact). A tale scopo, utilizzare LcmExport (o il job Esporta LCM nell'interfaccia Web di Essbase).
Eseguire il backup della tabella fact. Vedere Backup e ripristino di Autonomous Database.
Eliminare la definizione di partizione federata dal cubo, attenendosi alla procedura descritta in Rimuovi una partizione federata.

Per ripristinare il cubo federato dal backup,

Ricreare l'applicazione utilizzando LcmImport (o il job Importa LCM nell'interfaccia Web Essbase).
Se necessario, ripristinare la tabella fact in Autonomous AI Lakehouse.
Ricreare la connessione ad Autonomous AI Lakehouse. Si consiglia di utilizzare un nuovo nome di connessione per evitare che si verifichino errori.
Creare di nuovo la partizione federata.

Gestione e risoluzione dei problemi del cubo federato

Modella ed esegui il test dei cubi federati

Precauzioni dei metadati per i cubi federati

Annulla SQL con tempi di esecuzione lunghi su cubi federati

Cosa fare se i dettagli di connessione al database sono stati modificati

Eseguire il backup e il backup di un cubo federato