Programming AMO OLAP Basic Objects

Tworzenie Dimension obiekt jest wykonywane w czterech krokach:

1. Tworzenie obiektu wymiaru i Wypełnij podstawowe atrybuty.

   Podstawowe atrybuty są nazwa, typ wymiaru, tryb magazynu, wiązanie urządzenie źródłowe danych, nazwa składnika wszystkich atrybut i innych atrybut wymiaru.

   Przed utworzeniem wymiaru, należy upewnić się, że wymiar nie istnieje.Jeśli istnieje wymiar, wymiar jest usunięty i utworzony ponownie.

2. Utwórz atrybuty, które definiują wymiar.

   Każdy atrybut musi być dodana indywidualnie w schemacie przed jej użyciem (znaleźć metoda CreateDataItem na końcu przykładowy kod) i mogą być dodane do kolekcja atrybutów wymiaru.

   Kolumna klucz i nazwa musi być zdefiniowana w wszystkie atrybuty.

   Podstawowy atrybut klucza wymiaru powinna być określona jako AttributeUsage.Key wyjaśnienie, że dany atrybut jest klucz dostępu do wymiaru.

3. Tworzenie hierarchii, które użytkownik będzie posiadał dostęp do nawigacji w wymiarze.

   Podczas tworzenia hierarchii poziom kolejność jest określona przez kolejność, w których poziomy są tworzone od góry do dołu.Na najwyższym poziomie jest pierwszą dodawane do kolekcja poziomów w hierarchii.

4. Zaktualizuj serwera za pomocą metoda Update bieżący wymiar.

Następujący przykładowy kod powoduje utworzenie wymiaru produktu w celu Magazyn danych AdventureWorks przykładowe.

        static void CreateProductDimension(Database db, string datasourceName)
        {
            // Create the Product dimension
            Dimension dim = db.Dimensions.FindByName("Product");
            if ( dim != null)
               dim.Drop();
            dim = db.Dimensions.Add("Product");
            dim.Type = DimensionType.Products;
            dim.UnknownMember = UnknownMemberBehavior.Hidden;
            dim.AttributeAllMemberName = "All Products";
            dim.Source = new DataSourceViewBinding(datasourceName);
            dim.StorageMode = DimensionStorageMode.Molap;

            #region Create attributes

            DimensionAttribute attr;

            attr = dim.Attributes.Add("Product Name");
            attr.Usage = AttributeUsage.Key;
            attr.Type = AttributeType.Product;
            attr.OrderBy = OrderBy.Name;
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "ProductKey"));
            attr.NameColumn = CreateDataItem(db.DataSourceViews[0], "DimProduct", "EnglishProductName");

            attr = dim.Attributes.Add("Product Line");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "ProductLine"));
            attr.NameColumn = CreateDataItem(db.DataSourceViews[0], "DimProduct", "ProductLineName");

            attr = dim.Attributes.Add("Model Name");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "ModelName"));
            attr.AttributeRelationships.Add(new AttributeRelationship("Product Line"));
            attr.AttributeRelationships.Add(new AttributeRelationship("Subcategory"));

            attr = dim.Attributes.Add("Subcategory");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProductSubcategory", "ProductSubcategoryKey"));
            attr.KeyColumns[0].NullProcessing = NullProcessing.UnknownMember;
            attr.NameColumn = CreateDataItem(db.DataSourceViews[0], "DimProductSubcategory", "EnglishProductSubcategoryName");
            attr.AttributeRelationships.Add(new AttributeRelationship("Category"));

            attr = dim.Attributes.Add("Category");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProductCategory", "ProductCategoryKey"));
            attr.NameColumn = CreateDataItem(db.DataSourceViews[0], "DimProductCategory", "EnglishProductCategoryName");

            attr = dim.Attributes.Add("List Price");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "ListPrice"));
            attr.AttributeHierarchyEnabled = false;

            attr = dim.Attributes.Add("Size");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "Size"));
            attr.AttributeHierarchyEnabled = false;

            attr = dim.Attributes.Add("Weight");
            attr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "DimProduct", "Weight"));
            attr.AttributeHierarchyEnabled = false;

            #endregion

            #region Create hierarchies

            Hierarchy hier;

            hier = dim.Hierarchies.Add("Product Model Categories");
            hier.AllMemberName = "All Products";
            hier.Levels.Add("Category").SourceAttributeID = "Category";
            hier.Levels.Add("Subcategory").SourceAttributeID = "Subcategory";
            hier.Levels.Add("Model Name").SourceAttributeID = "Model Name";

            hier = dim.Hierarchies.Add("Product Categories");
            hier.AllMemberName = "All Products";
            hier.Levels.Add("Category").SourceAttributeID = "Category";
            hier.Levels.Add("Subcategory").SourceAttributeID = "Subcategory";
            hier.Levels.Add("Model Name").SourceAttributeID = "Product Name";

            hier = dim.Hierarchies.Add("Product Model Lines");
            hier.AllMemberName = "All Products";
            hier.Levels.Add("Subcategory").SourceAttributeID = "Product Line";
            hier.Levels.Add("Model Name").SourceAttributeID = "Model Name";

            #endregion

            dim.Update();
        }

        static DataItem CreateDataItem(DataSourceView dsv, string tableName, string columnName)
        {
            DataTable dataTable = ((DataSourceView)dsv).Schema.Tables[tableName];
            DataColumn dataColumn = dataTable.Columns[columnName];
            return new DataItem(tableName, columnName,
                OleDbTypeConverter.GetRestrictedOleDbType(dataColumn.DataType));
        }

Przetwarzanie wymiaru jest równie proste, jak za pomocą metoda process Dimension obiekt.

Przetwarzanie wymiaru może mieć wpływ na wszystkie moduły, które należy użyć wymiarów.Aby uzyskać więcej informacji na temat opcji przetwarzania zobacz Processing Objects (XMLA) i Processing Analysis Services Objects.

Następujący kod powoduje aktualizacja przyrostowa we wszystkich wymiarach podanych bazy danych:

        static void UpdateAllDimensions(Database db)
        {
            foreach (Dimension dim in db.Dimensions)
                dim.Process(ProcessType.ProcessUpdate);
        }

Zarządzanie modułami jest podobna do zarządzania wymiarami.Tworzenie Cube obiekt jest wykonywane w czterech krokach:

1. Tworzenie obiektu moduł i wypełnić podstawowych atrybutów.

   Podstawowe atrybuty są nazwa, tryb pamięci masowej, wiązanie urządzenie źródłowe danych, domyślnej miara i inne atrybuty moduł.

   Przed utworzeniem modułu należy upewnić się, że moduł nie istnieje.W próbce istnienie moduł moduł są opuszczane, a następnie ponownie utworzony.

2. Dodaj żądane wymiary moduł.

   Wymiary są dodawane do bieżącej kolekcja wymiary moduł w bazie danych; wymiarami w module są odwołaniami do kolekcja wymiarów bazy danych.Każdy wymiar musi być mapowane do moduł oddzielnie.W próbce wymiary są mapowane, zapewniając: Baza danych wymiaru wewnętrzny identyfikator, nazwę wymiaru w module oraz identyfikator o nazwie wymiaru moduł.

   Kod przykładowy należy zauważyć, że wymiar "Data" jest dodawany trzy razy, za każdym razem, jest dodawany przy użyciu innego moduł Nazwa wymiaru: Data, data dostawy, data dostawy. Wymiary te są nazywane wymiarami “ roli odtwarzanie ”.Wymiar podstawowej jest ten sam (Data), ale w tabela fakt wymiar jest używany w różnych “ role ” (Data zamówienia, datę wysyłki, data dostawy) — zobacz temat „ Tworzenie, upuszczania i znajdowanie MeasureGroup „ w dalszej części tego dokumentu, aby zrozumieć, jak „ rola odtwarzanie „ wymiarów są definiowane.

3. Tworzenie grup miar, które użytkownik będzie posiadał dostęp do przeglądania danych moduł.

   Tworzenie grupy miara będzie się wyjaśniono w „ tworzenie, upuszczania i znajdowanie MeasureGroup „ w dalszej części tego dokumentu.Tworzenie próbki otacza miara grupy w różnych metod, jeden dla każdej grupa miar.

4. Zaktualizuj serwera za pomocą metoda Update bieżącej kostki.

   Metoda aktualizacji jest używana z opcją Aktualizacja ExpandFull aby upewnić się, że wszystkie obiekty są w pełni zaktualizowany na serwerze.

Poniższy przykładowy kod tworzy części moduł Adventure Works.Przykładowy kod nie powoduje utworzenia wszystkich wymiarów lub miara grup, które znajdują się przykładowe AdventureWorks Analysis Services w programie Project.Aby uzyskać więcej informacji na temat instalowania próbki zobacz AdventureWorks Sample Databases.

        static void CreateAdventureWorksCube(Database db, string datasourceName)
        {
            // Create the Adventure Works cube
            Cube cube = db.Cubes.FindByName("Adventure Works");
            if ( cube != null)
               cube.Drop();
            db.Cubes.Add("Adventure Works");
            cube.DefaultMeasure = "[Reseller Sales Amount]";
            cube.Source = new DataSourceViewBinding(datasourceName);
            cube.StorageMode = StorageMode.Molap;

            #region Create cube dimensions

            Dimension dim;

            dim = db.Dimensions.GetByName("Date");
            cube.Dimensions.Add(dim.ID, "Date", "Order Date Key - Dim Time");
            cube.Dimensions.Add(dim.ID, "Ship Date",
                "Ship Date Key - Dim Time");
            cube.Dimensions.Add(dim.ID, "Delivery Date",
                "Delivery Date Key - Dim Time");

            dim = db.Dimensions.GetByName("Customer");
            cube.Dimensions.Add(dim.ID);

            dim = db.Dimensions.GetByName("Reseller");
            cube.Dimensions.Add(dim.ID);
            #endregion

            #region Create measure groups

            CreateSalesReasonsMeasureGroup(cube);
            CreateInternetSalesMeasureGroup(cube);
            CreateResellerSalesMeasureGroup(cube);
            CreateCustomersMeasureGroup(cube);
            CreateCurrencyRatesMeasureGroup(cube);

            #endregion

            cube.Update(UpdateOptions.ExpandFull);
        }

Przetwarzanie moduł jest równie proste, jak za pomocą metoda process Cube obiekt. Przetwarzanie moduł również przetwarza wszystkie s grupa miar w module, a wszystkie partycje w grupa miar.W module partycje są tylko obiekty, które mogą być przetwarzane; w celu jej przetwarzania, miara grupy są tylko pojemniki partycji.Określony typ przetwarzania moduł Propaguj do partycji.Przetwarzanie moduł i grupa miar wewnętrznie jest tłumaczona na przetwarzanie wymiarów i partycji.

Aby uzyskać więcej informacji na temat opcji przetwarzania zobacz Processing Objects (XMLA), a Processing Analysis Services Objects.

Poniższy kod będzie wykonywać pełne procesu na wszystkich modułów w określonej bazie danych:

   foreach (Cube cube in db.Cubes)
                cube.Process(ProcessType.ProcessFull);
        }

Zarządzanie grupami miara jest podobna do zarządzania wymiary i moduły.Tworzenie MeasureGroup obiekt jest wykonywane w następujących etapach:

1. Tworzenie grupa miar obiektów i wypełnić podstawowych atrybutów.

   Podstawowe atrybutów należą nazwa, tryb pamięci masowej, tryb przetwarzania, domyślnej miara i inne atrybuty grupa miar.

   Przed utworzeniem grupa miar, sprawdź, czy grupa miar nie istnieje.W polu kod przykładowy, w którym następuje, jeśli grupa miar istnieje, a następnie grupa miar jest usunięty i utworzony ponownie.

2. Tworzenie środków grupa miar.Dla każdego miara tworzone są przypisywane następujące atrybuty: Nazwa, funkcja agregacja urządzenie źródłowe kolumna, ciąg formatu. Można przypisać również inne atrybuty.Należy zauważyć, że w przykładowy kod, który następuje, metoda CreateDataItem doda tę kolumna w schemacie.

3. Dodaj wymiara grupa miar.

4. Wymiara są dodawane do bieżącego grupa miar kolekcja wymiarów z moduł nadrzędnego wymiara kolekcja.Natychmiast po wymiar znajduje się w kolekcja wymiara grupa miara, kolumna klucz z tabela fakt mogą być mapowane do wymiaru tak, aby grupa miar może być przeglądany za pomocą wymiaru.

   Przykładowy kod, który następuje, zawiera wiersze, w obszarze „ mapowania wymiarów i kolumna klucz z tabela fakt ".Roli odtwarzanego wymiary są implementowane przez połączenie surogatu różne klucze do tego samego wymiaru, pod różnymi nazwami.Dla każdej z ról, odtwarzanie wymiarów (Data, data dostawy, data dostawy) klucz różne zastępcza jest połączony z jego (OrderDateKey, ShipDateKey DueDateKey).Wszystkie klucze są z tabela fakt FactInternetSales.

5. Dodawanie zaprojektowane partycje o grupa miar.

   W przykładowy kod, który następuje, zapakowane jest utworzenie partycji w jedną z tych metod.

6. Aktualizuj na serwerze za pomocą metoda aktualizacji bieżącego grupa miar.

   W polu kod przykładowy, w którym następuje wszystkie miara grupy są aktualizowane po zaktualizowaniu moduł.

Następujący przykładowy kod powoduje utworzenie InternetSales grupa miar próbki AdventureWorks Analysis Services w programie Project.Aby uzyskać więcej informacji na temat instalowania próbki zobacz AdventureWorks Sample Databases.

        static void CreateInternetSalesMeasureGroup(Cube cube)
        {
            // Create the Internet Sales measure group
            Database db = cube.Parent;
            MeasureGroup mg = cube.MeasureGroups.FindByName("Internet Sales");
            if ( mg != null)
               mg.Drop();
            mg = cube.MeasureGroups.Add("Internet Sales");
            mg.StorageMode = StorageMode.Molap;
            mg.ProcessingMode = ProcessingMode.LazyAggregations;
            mg.Type = MeasureGroupType.Sales;

            #region Create measures

            Measure meas;

            meas = mg.Measures.Add("Internet Sales Amount");
            meas.AggregateFunction = AggregationFunction.Sum;
            meas.FormatString = "Currency";
            meas.Source = CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "SalesAmount");

            meas = mg.Measures.Add("Internet Order Quantity");
            meas.AggregateFunction = AggregationFunction.Sum;
            meas.FormatString = "#,#";
            meas.Source = CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "OrderQuantity");

            meas = mg.Measures.Add("Internet Unit Price");
            meas.AggregateFunction = AggregationFunction.Sum;
            meas.FormatString = "Currency";
            meas.Visible = false;
            meas.Source = CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "UnitPrice");

            meas = mg.Measures.Add("Internet Total Product Cost");
            meas.AggregateFunction = AggregationFunction.Sum;
            //meas.MeasureExpression = "[Internet Total Product Cost] * [Average Rate]";
            meas.FormatString = "Currency";
            meas.Source = CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "TotalProductCost");

            meas = mg.Measures.Add("Internet Order Count");
            meas.AggregateFunction = AggregationFunction.Count;
            meas.FormatString = "#,#";
            meas.Source = CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "ProductKey");

            #endregion

            #region Create measure group dimensions

            CubeDimension cubeDim;
            RegularMeasureGroupDimension regMgDim;
            ManyToManyMeasureGroupDimension mmMgDim;
            MeasureGroupAttribute mgAttr;

            //   Mapping dimension and key column from fact table
            //      > select dimension and add it to the measure group
            cubeDim = cube.Dimensions.GetByName("Date");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);

            //      > add key column from dimension and map it with 
            //        the surrogate key in the fact table
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Date").ID);   // this is dimension key column
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "OrderDateKey"));   // this surrogate key in fact table

            cubeDim = cube.Dimensions.GetByName("Ship Date");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Date").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "ShipDateKey"));

            cubeDim = cube.Dimensions.GetByName("Delivery Date");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Date").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "DueDateKey"));

            cubeDim = cube.Dimensions.GetByName("Customer");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Full Name").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "CustomerKey"));

            cubeDim = cube.Dimensions.GetByName("Product");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Product Name").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "ProductKey"));

            cubeDim = cube.Dimensions.GetByName("Source Currency");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Currency").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "CurrencyKey"));

            cubeDim = cube.Dimensions.GetByName("Sales Reason");
            mmMgDim = new ManyToManyMeasureGroupDimension();
            mmMgDim.CubeDimensionID = cubeDim.ID;
            mmMgDim.MeasureGroupID = cube.MeasureGroups.GetByName("Sales Reasons").ID;
            mg.Dimensions.Add(mmMgDim);

            cubeDim = cube.Dimensions.GetByName("Internet Sales Order Details");
            regMgDim = new RegularMeasureGroupDimension(cubeDim.ID);
            mg.Dimensions.Add(regMgDim);
            mgAttr = regMgDim.Attributes.Add(cubeDim.Dimension.Attributes.GetByName("Sales Order Key").ID);
            mgAttr.Type = MeasureGroupAttributeType.Granularity;
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "SalesOrderNumber"));
            mgAttr.KeyColumns.Add(CreateDataItem(db.DataSourceViews[0], "FactInternetSales", "SalesOrderLineNumber"));

            #endregion

            #region Create partitions

            CreateInternetSalesMeasureGroupPartitions( mg)

            #endregion
        }

Przetwarzanie grupa miar jest równie proste, jak za pomocą metoda process MeasureGroup obiekt. Przetwarzanie grupa miar przetworzy wszystkie partycje, które należą do grupa miar.Przetwarzanie grupa miar wewnętrznie jest tłumaczona na przetwarzania partycji i wymiary.Zobacz Przetwarzania partycji w tym dokumencie.

Aby uzyskać więcej informacji na temat opcji przetwarzania zobacz Processing Objects (XMLA), a Processing Analysis Services Objects.

Poniższy kod będzie wykonywać pełne procesu we wszystkich miara grup dostarczonego moduł.

        static void FullProcessAllMeasureGroups(Cube cube)
        {
            foreach (MeasureGroup mg in cube.MeasureGroups)
                mg.Process(ProcessType.ProcessFull);
        }

Partycje są proste obiektów, które mogą być tworzone w dwóch etapach.

1. Tworzenie obiektu partycji i wypełnić podstawowych atrybutów.

   Podstawowe atrybuty są nazwa, tryb pamięci masowej, urządzenie źródłowe partycji, fragmentu, a także inne grupa miar atrybutów.urządzenie źródłowe partycji definiuje zaznacz instrukcję SQL dla bieżącej partycji.Wycinek jest wyrażenie MDX określające spójna kolekcja lub zestaw, który rozgranicza część wymiary z obiektu nadrzędnego grupa miar zawartych w bieżącej partycji.W przypadku partycji MOLAP Cięcie jest określana automatycznie za każdym razem przetwarzania partycji.

   Przed utworzeniem partycji, należy upewnić się, że partycja nie istnieje.W próbce kodem że następuje, jeśli istnieje partycja, jest usunięty, a następnie ponownie utworzony.

2. Zaktualizuj serwera za pomocą metoda Update bieżącej partycji.

   W przykładowy kod, który następuje wszystkie partycje są aktualizowane po zaktualizowaniu moduł.

Poniższy przykładowy kod tworzy partycji dla "InternetSales" grupa miar.

        static void CreateInternetSalesMeasureGroupPartitions(MeasureGroup mg)
        {
            Partition part;
            part = mg.Partitions.FindByName("Internet_Sales_184");
            if ( part != null)
               part.Drop();
            part = mg.Partitions.Add("Internet_Sales_184");
            part.StorageMode = StorageMode.Molap;
            part.Source = new QueryBinding(db.DataSources[0].ID, "SELECT * FROM [dbo].[FactInternetSales] WHERE OrderDateKey <= '184'");
            part.Slice = "[Date].[Calendar Year].&[2001]";
            part.Annotations.Add("LastOrderDateKey", "184");

            part = mg.Partitions.FindByName("Internet_Sales_549");
            if ( part != null)
               part.Drop();
            part = mg.Partitions.Add("Internet_Sales_549");
            part.StorageMode = StorageMode.Molap;
            part.Source = new QueryBinding(db.DataSources[0].ID, "SELECT * FROM [dbo].[FactInternetSales] WHERE OrderDateKey > '184' AND OrderDateKey <= '549'");
            part.Slice = "[Date].[Calendar Year].&[2002]";
            part.Annotations.Add("LastOrderDateKey", "549");

            part = mg.Partitions.FindByName("Internet_Sales_914");
            if ( part != null)
               part.Drop();
            part = mg.Partitions.Add("Internet_Sales_914");
            part.StorageMode = StorageMode.Molap;
            part.Source = new QueryBinding(db.DataSources[0].ID, "SELECT * FROM [dbo].[FactInternetSales] WHERE OrderDateKey > '549' AND OrderDateKey <= '914'");
            part.Slice = "[Date].[Calendar Year].&[2003]";
            part.Annotations.Add("LastOrderDateKey", "914");
        }

Przetwarzania partycji jest równie proste, jak za pomocą metoda process Partition obiekt.

Aby uzyskać więcej informacji na temat opcji przetwarzania zobacz Processing Objects (XMLA) i Processing Analysis Services Objects.

Poniższy przykładowy kod powoduje pełnego procesu na wszystkich partycjach z określonym grupa miar.

        static void FullProcessAllPartitions(MeasureGroup mg)
        {
            foreach (Partition part in mg.Partitions)
                part.Process(ProcessType.ProcessFull);
        }

Scalanie oznacza partycje wykonaniem każdej operacji w dwóch lub więcej partycji, stając się jedna partycja.

Scalanie partycji jest metoda Partition obiekt. Tego polecenia scalania danych z jednej lub kilku partycji urządzenie źródłowe do partycja docelowa i usuwa partycje urządzenie źródłowe.

Partycje mogą być scalane, jedynie wówczas, gdy spełniają następujące kryteria:

• Partycje są w tym samym grupa miar.

• Partycje są przechowywane w ten sam tryb (MOLAP HOLAP i ROLAP).

• Partycje znajdują się na tym samym serwerze; zdalnego partycje mogą być scalane, jeśli na tym samym serwerze.

Unlike previous versions, in Microsoft SQL Server Analysis Services it is not necessary that all source partitions have identical aggregations design.

Wynikowy zestaw agregacji dla partycji miejsce docelowe jest ten sam zestaw agregacji w stanie przed uruchomieniem polecenia korespondencji seryjnej.

Poniższy przykładowy kod łączy wszystkie partycje z określonym grupa miar.Partycje są scalane w pierwszej partycji z grupa miar.

        static void MergeAllPartitions(MeasureGroup mg)
        {
            if (mg.Partitions.Count > 1)
            {
                Partition[] partArray = new Partition[mg.Partitions.Count - 1];
                for (int i = 1; i < mg.Partitions.Count; i++)
                    partArray[i - 1] = mg.Partitions[i];
                mg.Partitions[0].Merge(partArray);
                //To have last changes in the server reflected in AMO
                mg.Refresh();
            }

Można łatwo agregacji utworzone i przypisany do miara grupy lub na partycje przy użyciu metoda DesignAggregations z AggregationDesign obiekt. The AggregationDesign object is a separate object from partition, the AggregationDesign object is contained in the MeasureGroup object.Można zaprojektować agregacji, do określonego poziom optymalizacji (od 0 do 100) lub do określonego poziom składowania (bajtów).Wiele partycji, można użyć tego samego projektu agregacja.

Poniższy przykładowy kod tworzy agregacji dla wszystkich partycji podany grupa miar.Wszelkie istniejące agregacji w partycjach są odrzucane.

        static public String DesignAggregationsOnPartitions(MeasureGroup mg, double optimizationWanted, double maxStorageBytes)
        {
            double optimization = 0;
            double storage = 0;
            long aggCount = 0;
            bool finished = false;
            AggregationDesign ad = null;
            String aggDesignName;
            String AggregationsDesigned = "";
            aggDesignName = mg.AggregationPrefix + "_" + mg.Name;
            ad = mg.AggregationDesigns.Add();
            ad.Name = aggDesignName;
            ad.InitializeDesign();
            while ((!finished) && (optimization < optimizationWanted) && (storage < maxStorageBytes))
            {
                ad.DesignAggregations(out optimization, out storage, out aggCount, out finished);
            }
            ad.FinalizeDesign();
            foreach (Partition part in mg.Partitions)
            {
                part.AggregationDesignID = ad.ID;
                AggregationsDesigned += aggDesignName + " = " + aggCount.ToString() + " aggregations designed\r\n\tOptimization: " + optimization.ToString() + "/" + optimizationWanted.ToString() + "\n\r\tStorage: " + storage.ToString() + "/" + maxStorageBytes.ToString() + " ]\n\r";
             }
             return AggregationsDesigned;
        }