Mantenimiento y solución de problemas de cubos federados

Modelado y prueba de cubos federados

Al diseñar un cubo federado de Essbase, siga estas directrices de diseño y prueba para obtener un enfoque por fases para solucionar problemas o supervisar el rendimiento.

Inicie el proyecto de cubo federado en un entorno de prueba.
Comience con modelos del cubo ASO o BSO de Essbase que tengan las siguientes características:
- que no tengan demasiados niveles
- que no tengan demasiados miembros o atributos compartidos

Al crear una partición federada, programe operaciones fuera de línea cuando no estén permitidas las consultas en la instancia.
Gradually disconnect active Essbase user sessions, using MaxL alter application disable commands and/or disable connects (to prevent any new user activity), followed by alter system logout session and/or kill request (if you need to terminate any active sessions that don't need to complete). Ten en cuenta que MaxL no puede terminar ninguna petición que se pueda estar ejecutando en Autonomous AI Lakehouse. Si desactiva comandos en la aplicación, no olvide volver a activar los comandos después de crear la partición federada.

Para terminar las solicitudes que se ejecutan como sesiones SQL en Autonomous AI Lakehouse, se necesitan pasos adicionales. Consulte Cancelar SQL de ejecución larga en cubos federados.
Realice un ajuste de timeout:
- Proxy HTTPS en la red del cliente: ajuste los timeouts de la red del cliente
- Equilibrador de carga: aumente el timeout del equilibrador de carga a 1260 segundos (21 minutos)
- Aumente los timeouts de HTTPD a 21 minutos
```
/etc/httpd/conf.d/00_base.conf:ProxyTimeout 1260
```
```
/etc/httpd/conf.d/00_base.conf:Timeout 1260
```
- Timeout de APS/JAPI:
  - En la página Consola de la interfaz web deEssbase, seleccione Configuración y observe el valor de olap.server.netSocketTimeOut. Un valor de 200 ms implica que cada recuento de 5 de estas propiedades conlleva un tiempo de espera de 1 segundo.
  - Para configurar el límite de timeout de APS/JAPI en 30 minutos, defina el valor olap.server.netRetryCount en 9000.
Cree la partición federada.
Revierta los ajustes de timeout del paso 3.
Enable users back onto the system using alter application enable commands and/or connects, if these were disabled previously.
Para los informes de un cubo federado, ajuste QRYGOVEXECTIME para que sea mayor que el tiempo esperado para ejecutar consultas en particiones federadas. Tenga En cuenta que QRYGOVEXECTIME no puede terminar ninguna petición que se pueda estar ejecutando en Autonomous AI Lakehouse.
Una vez que se haya completado el ajuste y la prueba del entorno del desarrollo, utilice los pasos de 1 al 7 anteriores para implantar un entorno en producción.

Note:

Si aparece el error "Fallo al guardar el esquema" al crear la partición federada, espere a que la sesión se complete y, a continuación, refresque el explorador. Si se ha creado la partición federada, valídela en SQL Developer. Si se valida en SQL Developer, el cubo federado estará listo para usar. De lo contrario, será necesario corregir el modelo y ajustar su timeout como se describe en el paso 3.

Precauciones sobre metadatos para cubos federados

Tenga cuidado al editar el esquema para un cubo federado no gestionado por Essbase. Si agrega o renombra miembros, asegúrese de que los cambios de metadatos también se representen en su tabla del hecho en Autonomous AI Lakehouse.

Este tema no se aplica a los cubos federados con almacenamiento de datos gestionado de Essbase.

Si el esquema deEssbase deja de estar sincronizado con la tabla del hecho en Autonomous AI Lakehouse, el cubo federado no será válido o no funcionará correctamente. Para corregirlo, deberá borrar la partición federada, realizar cambios en el esquema y la tabla de hechos y, a continuación, volver a crear la partición federada.

Si un cubo federado deja de ser válido, es posible que obtenga un error que empiece con Essbase Error(1040235): Remote warning from federated partition.

Los siguientes tipos de cambios de esquema de Essbase provocarán que un cubo federado (no gestionado por Essbase) no sea válido:

Adición, renombrado y eliminación de dimensiones
Adición, renombrado y eliminación de miembros almacenados en la dimensión de giro
Cambio de cualquier miembro de almacenado a dinámico

En el caso de otros tipos de cambios de esquema de Essbase no indicados anteriormente (por ejemplo, agregar o renombrar un miembro de dimensión de tabla no dinámica), debe realizar el cambio correspondiente en la fila de datos afectada de la tabla de hechos. De lo contrario, es posible que el cubo federado no funcione correctamente.

Si sabe con antelación que van a cambiar los metadatos del esquema de Essbase, es mejor eliminar primero la partición federada, realizar los cambios de esquema, actualizar la tabla de hechos y, a continuación, volver a crear la partición de federación.

Sin embargo, si los metadatos de Essbase han cambiado y esto ha provocado que la partición federada deje de ser válida, realice la siguiente acción:

Elimine la partición federada y la conexión asociada a esta (si no la utiliza de otro modo), como se describe en Eliminar una partición federada.

En el esquema del usuario de Autonomous AI Lakehouse, suprima manualmente todas las tablas generadas porEssbase y otros objetos que no se hayan eliminado con la partición federada.
Asegúrese de que los cambios del esquema se hayan completado en el cubo de Essbase.
Vuelva a crear la tabla de hechos. Consulte Creación de la tabla de hechos.
Vuelva a crear la conexión a Autonomous AI Lakehouse. Esta puede ser una conexión global (bajo el icono principal Orígenes en la interfaz web de Essbase), o puede estar en los Orígenes que se han definido solo para la aplicación. Siga las instrucciones de Creación de una conexión para cubos federados.
Vuelva a crear la partición federada, como se describe en Crear una partición federada.

Cancelar SQL de larga ejecución en cubos federados

Puede cancelar las sesiones SQL que se ejecutan en cubos federados de Essbase. La cancelación de SQL puede ser necesaria si un cálculo está tardando demasiado o si el cubo federado necesita copia de seguridad o recuperación.

Si los cálculos, las cargas de datos o las agregaciones de Essbase que se ejecutan en cubos federados generan sentencias SQL de larga ejecución, es posible cancelar las sesiones, aunque se estén ejecutando en Autonomous AI Lakehouse.

Antes de que la cancelación de sesión SQL mediante Essbase esté disponible, se debe completar un breve flujo de trabajo de pasos para activar SQL Session Governor en Essbase.

Los usuarios con los siguientes tipos de acceso participan en los pasos de preparación.

Tipo de usuario	Rol en el flujo de trabajo
Administrador de base de datos	Conoce el nombre y la contraseña del esquema de administrador para Autonomous AI Lakehouse. Puede crear procedimientos PL/SQL almacenados en Autonomous AI Lakehouse y otorgar privilegios a otros usuarios.
Usuario de Base de Datos También denominado usuario de partición federada	Conoce el nombre y contraseña de esquema de la instancia de Autonomous AI Lakehouse, el mismo esquema y contraseña que se utilizan para crear la conexión de la instancia de Essbase a Oracle Database (un requisito necesario antes de crear la partición federada).
Gestor de aplicaciones de Essbase	Gestor/propietario de una aplicación de Essbase utilizada para un cubo federado.

Se debe completar el siguiente flujo de trabajo de pasos para activar SQL Session Governor:

Administrador de base de datos: cree los siguientes procedimientos almacenados PL/SQL en Autonomous AI Lakehouse y otorgue el privilegio EXECUTE al usuario de base de datos:

Note:

Los procedimientos almacenados se deben crear en el esquema de usuario de la base de datos.

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

Utilice la siguiente sentencia para crear el procedimiento:

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

Utilice la siguiente sentencia para crear el procedimiento:

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;

Otorgue privilegios EXECUTE para los procedimientos almacenados anteriores al usuario de base de datos.

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;

Usuario de base de datos: en el esquema de Autonomous AI Lakehouse, confirme que tiene acceso a los siguientes procedimientos almacenados en Sinónimos:
- ESS_SESSION_SET_MODULE
- ESS_SESSION_CANCEL
Si se cumplen estos requisitos, las solicitudes SQL de larga ejecución en el cubo federado se pueden cancelar de la misma forma que otras solicitudes de Essbase. Las solicitudes se pueden cancelar en la interfaz web de Essbase desde el área Sesiones de la consola. Si utiliza MaxL, puede cancelar solicitudes mediante la sentencia alter system kill request. Consulte Model and Test Federated Partition Cubes (Modelo y prueba de cubos de partición federados) para obtener directrices sobre la terminación de sesiones.

Qué hacer si los detalles de conexión a base de datos han cambiado

Si han cambiado los detalles de conexión de Autonomous AI Lakehouse que Essbase utiliza para un cubo federado, deberá borrar y volver a crear la partición federada y limpiar los objetos y las tablas de metadatos asociados del esquema de base de datos.

Este tema no se aplica a los cubos federados con almacenamiento de datos gestionado de Essbase.

Debe borrar y volver a crear la partición federada si uno de los siguientes eventos se produce después de su creación:

Cambios en el puerto de Autonomous AI Lakehouse
El nombre de la conexión cambia
La conexión utiliza una cartera y cambia de nombre de servicio a otro (para realizar cambios en rendimiento o simultaneidad)
Una actualización de esquema cambia la asignación de miembros a la tabla de hechos, lo que provoca que la partición federada quede desincronizada. Consulte Metadata Precautions for Federated Cubes para obtener detalles.

Si sabe con antelación que van a cambiar los detalles de conexión, es mejor eliminar la partición federada antes de que se produzca el cambio y volver crearla. Sin embargo, si la conexión ha cambiado y ha provocado que el cubo federado no sea válido, siga los pasos que se indican a continuación.

Borrar la partición federada

Elimine la partición federada y la conexión asociada a esta (si no la utiliza de otro modo), como se describe en Eliminar una partición federada.

Limpiar las tablas de metadatos y los objetos relacionados con la partición federada

En el esquema del usuario de Autonomous AI Lakehouse, suprima de forma manual todas las tablas generadas por la Essbase y otros objetos que no se hayan eliminado con la partición federada.

Utilice ssh para conectarse al host del servidor de Essbase como usuario opc.
```
ssh -i MPOCI_KEY.pem opc@100.xxx.xxx.xxx
```
Cambie al usuario oracle (y vaya a su directorio de inicio).
```
sudo su - oracle
```
Vaya hasta el directorio de aplicaciones.
```
cd /u01/data/essbase/app
```
Mediante la aplicación de Essbase y el nombre de cubo, identifique el prefijo único asociado a los objetos y los metadatos de su partición federada.
1. Obtenga el nombre de la aplicación (AppName). El nombre distingue entre mayúsculas y minúsculas, por lo que debe utilizar las mayúsculas/minúsculas exactas. En este ejemplo, AppName = Muestra.
```
ls
Sample
```
2. Vaya al directorio del cubo y obtenga el nombre del cubo (DbName). El nombre distingue entre mayúsculas y minúsculas, por lo que debe utilizar las mayúsculas/minúsculas exactas. En este ejemplo, DbName = Básico.
```
cd /Sample
ls
Basic
```
3. Mediante SQL Developer u otra herramienta, conéctese a Autonomous AI Database como usuario del esquema al que está (o estaba) conectado el cubo federado.
4. En SQL Developer, ejecute una sentencia SELECT para obtener el valor de OTL_ID y OTL_STATUS.
  
  El formato de la sentencia SELECT es el siguiente:
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION where APPNAME ='<AppName>';
```
  Ejemplo
  
  Sustituya Sample por AppName.
```
SELECT OTL_ID, OTL_STATUS, TRC_HOST FROM ESSAV_OTL_MTD_VERSION WHERE APPNAME='Sample';
```
  La consulta anterior debe devolver el valor OTL_ID; por ejemplo,
```
987
```
  Note:
  Si se devuelve alguna fila en la que OTL_STATUS sea ACTIVE, debe intentar borrar la aplicación de la instancia TRC_HOST antes de continuar con el siguiente paso.
5. Cree el archivo Prefix como:
```
ESSAV_<OTL_ID>_
```
  Por ejemplo:
```
<Prefix> = ESSAV_987_
```
Ejecute una sentencia SELECT para crear una lista de objetos asociados al cubo federado. Estos son los objetos que limpiará en el siguiente paso.

El formato de la sentencia SELECT es el siguiente:
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE '<Prefix>%' ESCAPE '\';
```
Por ejemplo:
```
SELECT * FROM user_OBJECTS WHERE OBJECT_NAME LIKE 'ESSAV_987_%' ESCAPE '\';
```

Ejecute un procedimiento PL/SQL almacenado que limpie todas las vistas analíticas, paquetes, jerarquías, tablas y otros objetos asociados a Prefix.

Ejemplo

Sustituya ESSAV_987_ por 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;
/

Borre y actualice las tablas relacionadas con los metadatos asociados.

Ejecute un procedimiento PL/SQL almacenado para borrar las tablas relacionadas con metadatos asociadas a OTL_ID.

Ejemplo

Sustituya 987 por 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;
/

Ejecute una sentencia UPDATE para definir la tabla ESSAV_OTL_MTD_VERSION en el estado inactivo.

Ejemplo

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

Note:

Como solo una instancia de Essbase debe utilizar el esquema de base de datos de IA autónoma, no es necesario especificar ESSBASE_INSTANCE_UNIQUE_ID al realizar las tareas de limpieza. Consulte Restricciones para cubos federados.

Volver a crear la conexión y la partición federada

Vuelva a crear la conexión a Autonomous AI Lakehouse. Esta puede ser una conexión global (bajo el icono principal Orígenes en la interfaz web de Essbase), o puede estar en los Orígenes que se han definido solo para la aplicación. Siga las instrucciones de connection. Asegúrese de Probar y Guardar la conexión.
Vuelva a crear la partición federada, como se describe en Crear una partición federada.
Si sigue apareciendo un error de conexión como Essbase Error(1350012): Attempt to connect to OCI failed, compruebe https://support.oracle.com/rs?type=doc&id=2925030.1.

Realizar copias de seguridad y restaurar un cubo federado

Las particiones federadas no se migran con las aplicaciones de Essbase. Durante la preparación para mover el cubo federado a otro servidor o para migrar a otra versión de Essbase, tendrá que suprimir la partición federada y volver a crear la partición en el nuevo entorno.

Para hacer una copia de seguridad del cubo federado,

Realice una copia de seguridad de la aplicación, sin los datos, pero incluyendo todo lo que necesite (como las propiedades de configuración, los filtros, las variables, los scripts de cálculo y otros artefactos). Para ello, utilice LcmExport (o el trabajo Exportar LCM en la interfaz web de Essbase).
Realice una copia de seguridad de la tabla de hechos. Consulte Copia de seguridad y restauración de Autonomous Database.
Suprima la definición de partición federada del cubo, siguiendo los pasos de Eliminación de una partición federada.

Para restaurar el cubo federado a partir de la copia de seguridad,

Vuelva a crear la aplicación mediante LcmImport (o el trabajo Importar LCM en la interfaz web de Essbase).
Si es necesario, restaure la tabla de resultados en Autonomous AI Lakehouse.
Vuelva a crear la conexión a Autonomous AI Lakehouse. Se recomienda utilizar un nuevo nombre de conexión para evitar que se produzcan errores.
Volver a crear la partición federada.

Mantenimiento y resolución de problemas de cubo federado

Modelado y prueba de cubos federados

Precauciones sobre metadatos para cubos federados

Cancelar SQL de larga ejecución en cubos federados

Qué hacer si los detalles de conexión a base de datos han cambiado

Realizar copias de seguridad y restaurar un cubo federado