Programar clases y métodos complementarios de AMO

Este tema contiene las siguientes secciones:

Clase de ensamblado
Copias de seguridad y restauración
Clase de seguimiento
Clase CaptureLog y atributo CaptureXML

Clase de ensamblado

Mediante los ensamblados los usuarios pueden extender la funcionalidad de Microsoft SQL Server Analysis Services agregando nuevos procedimientos almacenados o funciones de expresiones multidimensionales (MDX). Para obtener más información, vea Otras clases y métodos de AMO.

Agregar y quitar ensamblados es sencillo y se puede realizar en línea. Debe ser un administrador de bases de datos para agregar un ensamblado a la base de datos o bien un administrador del servidor para agregar el ensamblado al objeto de servidor.

En el ejemplo siguiente se agrega un ensamblado a la base de datos que se proporciona y se asigna la cuenta de servicio para ejecutar el ensamblado. Si el ensamblado existe en la base de datos, se quita antes de intentar agregarlo.

        static public void CreateStoredProcedures(Database db)
        {
            ClrAssembly clrAssembly;

            // Verify That assembly exist in database and drop it
            if (db.Assemblies.ContainsName("StoredProcedures"))
            {
                clrAssembly = db.Assemblies.FindByName("StoredProcedures");
                clrAssembly.Drop();
            }

            // Create the CLR assembly
            clrAssembly = db.Assemblies.Add("StoredProcedures");
            clrAssembly.ImpersonationInfo = new ImpersonationInfo(
                ImpersonationMode.ImpersonateServiceAccount);
            clrAssembly.PermissionSet = PermissionSet.Unrestricted;

            // Load the assembly files
            clrAssembly.LoadFiles(Environment.CurrentDirectory
                + @"\StoredProcedures2.dll", false);

            clrAssembly.Update();
        }

Métodos de copias de seguridad y restauración

Los métodos de copias de seguridad y restauración permiten a los administradores realizar copias de seguridad y restaurar bases de datos.

En el ejemplo siguiente se crean copias de seguridad para todas las bases de datos del servidor especificado. Si un archivo de copia de seguridad ya existe, se sobrescribe. Los archivos de copia de seguridad se guardan en la carpeta de copia de seguridad de la carpeta de datos de Analysis Services.

        static public void BackUpAllDatabases(Server svr)
        {
            string fileName;
            if ((svr != null) && ( svr.Connected))
                foreach (Database db in svr.Databases)
                {
                    fileName = db.Name + "_" + ((Int64)(DateTime.Today.Year * 10000 + DateTime.Today.Month * 100 + DateTime.Today.Day)).ToString()+ ".abf";
                    db.Backup(fileName, true);
                }
        }

En el ejemplo siguiente se restaura la copia de seguridad de "AdventureWorks" a partir del ejemplo anterior. Si la base de datos "My Adventure WorksDW" ya existe, se sobrescribe.

        static public void RestoreAdventureWorks(Server svr)
        {
            svr.Restore("Adventure Works DW_20051025.abf", "My Adventure WorksDW", true);
        }

Clase de seguimiento

Al supervisar la actividad del servidor, se deben usar dos tipos de seguimientos: seguimientos de sesión y seguimientos del servidor. Realizar un seguimiento del servidor le puede indicar cómo se está realizando su tarea actual en el servidor (seguimientos de sesión) o le puede indicar el estado de la actividad total en el servidor, incluso sin estar conectado al servidor (seguimientos del servidor).

Al realizar un seguimiento de la actividad actual (seguimientos de sesión), el servidor envía notificaciones a la aplicación actual acerca de los eventos que provoca la aplicación y que se están produciendo en el servidor. Los eventos se capturan mediante controladores de eventos en la aplicación actual. En primer lugar, asigne las rutinas de control de eventos al objeto SessionTrace y, a continuación, inicie el seguimiento de sesión.

En el ejemplo siguiente se muestra cómo configurar un seguimiento de sesión para realizar un seguimiento a las actividades actuales. Las rutinas de controlador de eventos se encuentran al final del ejemplo y generarán toda la información de seguimiento al objeto System.Console. Para generar eventos de seguimiento, el cubo de ejemplo "Adventure Works" se procesará totalmente una vez que se inicie el seguimiento.

        static public void TestSessionTraces(Server svr)
        {
            // Start the default trace
            
            svr.SessionTrace.OnEvent
                += new TraceEventHandler(DefaultTrace_OnEvent);
            svr.SessionTrace.Stopped
                += new TraceStoppedEventHandler(DefaultTrace_Stopped);
            svr.SessionTrace.Start();


            // Process the databases
            // The trace handlers will output all progress notifications 
            // to the console
            Database db = svr.Databases.FindByName("Adventure Works DW Multidimensional 2012");
            Cube cube = db.Cubes.FindByName("Adventure Works");
            cube.Process(ProcessType.ProcessFull);

            // Stop the default trace
            svr.SessionTrace.Stop();

        }
        static public void DefaultTrace_OnEvent(object sender, TraceEventArgs e)
        {
            Console.WriteLine("{0}", e.TextData);
        }

        static public void DefaultTrace_Stopped(ITrace sender, TraceStoppedEventArgs e)
        {
            switch (e.StopCause)
            {
                case TraceStopCause.StoppedByUser:
                case TraceStopCause.Finished:
                    Console.WriteLine("Processing completed successfully");
                    break;

                case TraceStopCause.StoppedByException:
                    Console.WriteLine("Processing failed: {0}",
                        e.Exception.Message);
                    break;
            }
        }

Los seguimientos del servidor se pueden configurar para registrar todo en un archivo de seguimiento y se pueden reiniciar automáticamente al reiniciar el servicio.

Para establecer un seguimiento del servidor, primero debe definir los eventos que se supervisan en el servidor y los datos del evento que se deberían guardar en el archivo de seguimiento. Para cada evento, debe definir las columnas de datos que se van a guardar en el archivo de seguimiento.

Para crear un seguimiento del servidor, es necesario realizar cuatro pasos:

Cree el objeto de seguimiento del servidor y rellene los atributos comunes básicos.

LogFileSize define el tamaño máximo del archivo de seguimiento y se define en megabytes; LogFileRollOver habilita al archivo de registro para que se inicie en un archivo distinto si se alcanza el límite de LogFileSize, cuando se habilita el nombre de archivo se anexa con un número de secuencia; AutoRestart permite que el seguimiento se inicie de nuevo si se reinicia el servicio.
Cree los eventos y las columnas de datos correspondientes.
Inicie y detenga el seguimiento según sea necesario.

Incluso una vez que se ha detenido el seguimiento, éste existe en el servidor y se debería iniciar de nuevo si el seguimiento estuviera definido como AutoRestart=true.
Quite el seguimiento cuando ya no sea necesario.

En el ejemplo siguiente, si el seguimiento ya existe, se quita y, a continuación, se vuelve a crear. Los archivos de seguimiento se guardan en la carpeta de registro de las carpetas de datos de Analysis Services.

        static public void TestServerTraces(Server svr)
        {
            Trace trc;
            TraceEvent te;

                trc = svr.Traces.FindByName("TestServerTraces");
                if (trc != null)
                    trc.Drop();
                trc = svr.Traces.Add("TestServerTraces", "TestServerTraces");
                trc.LogFileName = ("TestServerTraces_" +((Int64)(DateTime.Now.Year * 10000 + DateTime.Now.Month * 100 + DateTime.Now.Day)).ToString() + "_" +
                        ((Int64)(DateTime.Now.Hour * 10000 + DateTime.Now.Minute * 100 + DateTime.Now.Second)).ToString() + ".trc");
                trc.LogFileSize = 100;
                trc.LogFileRollover = true;
                trc.AutoRestart = false;

                #region Define Events to trace & data columns per event
                te = trc.Events.Add(TraceEventClass.ProgressReportBegin);
                te.Columns.Add(TraceColumn.TextData);
                te.Columns.Add(TraceColumn.StartTime);
                te.Columns.Add(TraceColumn.ObjectName);
                te.Columns.Add(TraceColumn.ObjectPath);
                te.Columns.Add(TraceColumn.DatabaseName);
                te.Columns.Add(TraceColumn.NTCanonicalUserName);

                te = trc.Events.Add(TraceEventClass.ProgressReportCurrent);
                te.Columns.Add(TraceColumn.TextData);
                te.Columns.Add(TraceColumn.CurrentTime);
                te.Columns.Add(TraceColumn.ObjectName);
                te.Columns.Add(TraceColumn.ObjectPath);
                te.Columns.Add(TraceColumn.DatabaseName);


                te = trc.Events.Add(TraceEventClass.ProgressReportEnd);
                te.Columns.Add(TraceColumn.TextData);
                te.Columns.Add(TraceColumn.StartTime);
                te.Columns.Add(TraceColumn.CurrentTime);
                te.Columns.Add(TraceColumn.EndTime);
                te.Columns.Add(TraceColumn.Success);
                te.Columns.Add(TraceColumn.Error);
                te.Columns.Add(TraceColumn.ObjectName);
                te.Columns.Add(TraceColumn.ObjectPath);
                te.Columns.Add(TraceColumn.DatabaseName);
                te.Columns.Add(TraceColumn.NTCanonicalUserName);
                #endregion

                trc.Update();
                trc.Start();

                #region Process the Adventure Works Cube
                // The trace settings will output all progress notifications 
                // to the trace file
                Database db = svr.Databases.FindByName("Adventure Works DW Multidimensional 2012");
                Cube cube = db.Cubes.FindByName("Adventure Works");
                cube.Process(ProcessType.ProcessFull);
                #endregion

                trc.Stop();
                trc.Drop();
            
        }

Atributos CaptureLog y CaptureXml

El atributo CaptureLog le habilita para crear archivos por lotes XMLA a partir de sus operaciones AMO. CaptureLog le habilita para crear un script para objetos de servidor como bases de datos, cubos, dimensiones, estructuras de minería de datos, etc.

Para crear CaptureLog, es necesario realizar los pasos siguientes:

Inicie la captura del registro XMLA estableciendo el atributo de servidor CaptureXml en true.

Esta opción empezará a guardar todas las operaciones AMO en una colección de cadenas en lugar de enviarlas al servidor.
Inicie la actividad AMO de la manera habitual, pero recuerde que no se envía ninguna acción al servidor. La actividad puede ser cualquier operación como procesar, crear, eliminar, actualizar o cualquier otra acción sobre un objeto.
Detenga la captura del registro XMLA restableciendo CaptureXml a false.
Revise el XMLA capturado, revisando cada una de las cadenas de la colección de cadenas CaptureLog o bien generando una cadena completa con el método ConcatenateCaptureLog. ConcatenateCaptureLog le habilita para generar el lote XMLA como una transacción única y agregar la opción de proceso paralela al lote.

En el ejemplo siguiente se devuelve una cadena con los comandos de proceso por lotes necesarios para realizar un proceso completo en todas las dimensiones y en todos los cubos de la base de datos [Adventure Works DW Multidimensional 2012].

        static public string TestCaptureLog(Server svr)
        {
            String capturedXmla = "";
            if ((svr != null) && (svr.Connected))
            {
                svr.CaptureXml = true;

                #region Actions to be captured to an XMLA file
                //No action is executed during CaptureXml = true
                Database db = svr.Databases.FindByName("Adventure Works DW Multidimensional 2012");
                foreach (Dimension dim in db.Dimensions)
                    dim.Process(ProcessType.ProcessFull);
                foreach (Cube cube in db.Cubes)
                    cube.Process(ProcessType.ProcessFull);
                #endregion

                svr.CaptureXml = false;

                capturedXmla = svr.ConcatenateCaptureLog(true, true);

            }

            return capturedXmla;
        }