Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Dotyczy:
SQL Server Analysis Services Azure Analysis Services 
Fabric/Power BI Premium
Tworzenie złożonych obiektów usług Analysis Services jest proste i przejrzyste, ale wymaga uwagi na szczegóły. W tym temacie opisano szczegóły programowania podstawowych obiektów OLAP. Ten temat zawiera następujące sekcje:
Obiekty wymiarów
Aby administrować lub przetwarzać wymiar, programujesz obiekt Dimension.
Tworzenie, upuszczanie i znajdowanie wymiaru
Dimension Tworzenie obiektu odbywa się w czterech krokach:
Utwórz obiekt wymiaru i wypełnij podstawowe atrybuty.
Podstawowe atrybuty to Nazwa (Name), Dimension Type (typ wymiaru), Storage Mode (tryb przechowywania), Data Source Binding (połączenie źródła danych), Attribute All Member Name oraz inne atrybuty wymiaru.
Przed utworzeniem wymiaru należy sprawdzić, czy wymiar jeszcze nie istnieje. Jeśli wymiar istnieje, wymiar zostanie porzucony i utworzony ponownie.
Utwórz atrybuty definiujące wymiar.
Każdy atrybut musi zostać dodany indywidualnie do schematu przed jego użyciem (znajdź metodę CreateDataItem na końcu przykładowego kodu), a następnie można go dodać do kolekcji atrybutów wymiaru.
Kolumna Klucz i Nazwa musi być zdefiniowana we wszystkich atrybutach.
Atrybut klucza podstawowego wymiaru należy zdefiniować jako AttributeUsage.Key, aby wyjaśnić, że ten atrybut jest kluczem dostępu do wymiaru.
Utwórz hierarchie, do których użytkownik będzie uzyskiwał dostęp w celu nawigowania po wymiarze.
Podczas tworzenia hierarchii kolejność poziomów jest definiowana przez kolejność tworzenia poziomów od góry do dołu. Najwyższy poziom jest pierwszym dodanym do kolekcji poziomów hierarchii.
Zaktualizuj serwer przy użyciu metody Update aktualnego wymiaru.
Poniższy przykładowy kod tworzy wymiar Product z tabeli produktów Adventure Works w przykładowej bazie danych.
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
Przetwarzanie wymiaru jest tak proste, jak użycie metody Process obiektu Dimension.
Przetwarzanie wymiaru może mieć wpływ na wszystkie kostki używające tego wymiaru.
Poniższy kod wykonuje aktualizację przyrostową we wszystkich wymiarach dostarczonej bazy danych:
static void UpdateAllDimensions(Database db)
{
foreach (Dimension dim in db.Dimensions)
dim.Process(ProcessType.ProcessUpdate);
}
Obiekty modułu
Aby zarządzać lub przetwarzać kostkę Cube, programujesz obiekt.
Tworzenie, usuwanie i odnajdywanie kostki
Zarządzanie kostkami jest podobne do zarządzania wymiarami. Cube Tworzenie obiektu odbywa się w czterech krokach:
Utwórz obiekt sześcianu i wypełnij podstawowe atrybuty.
Atrybuty podstawowe to Nazwa, Tryb przechowywania, Powiązanie źródła danych, Miara domyślna i inne atrybuty kostki.
Przed utworzeniem kostki należy sprawdzić, czy kostka nie istnieje. W przykładzie, jeśli moduł istnieje, moduł zostanie porzucony, a następnie ponownie utworzony.
Dodaj wymiary kostki.
Wymiary są dodawane do bieżącej kolekcji wymiarów modułu z bazy danych; wymiary w module są odwołaniami do kolekcji wymiarów bazy danych. Każdy wymiar musi być mapowany indywidualnie na kostkę. W przykładowych wymiarach są mapowane: wewnętrzny identyfikator wymiaru bazy danych, nazwa wymiaru w kostce oraz identyfikator nazwanego wymiaru w kostce.
W przykładowym kodzie zwróć uwagę, że wymiar "Date" jest dodawany trzy razy, za każdym razem przy użyciu innej nazwy wymiaru modułu: Date (Data), Ship Date (Data wysyłki), Delivery Date (Data dostawy). Te wymiary są nazywane wymiarami "odgrywania ról". Wymiar podstawowy jest taki sam (Data), ale w tabeli faktów ten wymiar jest używany w różnych "rolach" (Data zamówienia, Data wysyłki, Data dostawy) - zobacz "Tworzenie, usuwanie i znajdowanie grupy miar" w dalszej części tego dokumentu, aby zrozumieć, jak definiowane są wymiary odgrywania ról.
Utwórz grupy miar, do których użytkownik będzie uzyskiwał dostęp w celu przeglądania danych modułu.
Tworzenie grupy miar zostanie wyjaśnione w sekcji "Tworzenie, upuszczanie i znajdowanie grupy miar" w dalszej części tego dokumentu. Przykład organizuje tworzenie grup miar przy użyciu różnych metod, każda dla jednej grupy miar.
Zaktualizuj serwer przy użyciu metody Update bieżącego modułu.
Metoda aktualizacji jest używana z opcją Update ExpandFull, aby upewnić się, że wszystkie obiekty są w pełni zaktualizowane na serwerze.
Poniższy fragment kodu tworzy elementy kostki Adventure Works. Przykładowy kod nie tworzy wszystkich wymiarów ani grup miar uwzględnionych w przykładzie projektu Adventure Works Analysis Services.
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 kostki
Przetwarzanie kostki jest tak proste, jak użycie metody Process obiektu Cube. Przetwarzanie kostki przetwarza również wszystkie grupy miar w kostce i wszystkie partycje w grupie miar. W obrębie kostki partycje są jedynymi elementami, które można przetwarzać; do celów przetwarzania grupy miar pełnią rolę jedynie kontenerów partycji. Określony typ przetwarzania kostki jest propagowany do partycji. Przetwarzanie kostki i grupy miar wewnętrznie sprowadza się do przetwarzania wymiarów i partycji.
Poniższy kod wykona pełny proces na wszystkich kostkach w określonej bazie danych.
foreach (Cube cube in db.Cubes)
cube.Process(ProcessType.ProcessFull);
}
Obiekty MeasureGroup
Aby administrować lub przetwarzać grupę miar, programujesz MeasureGroup obiekt.
Tworzenie, usuwanie i znajdowanie grupy miar
Zarządzanie grupami miar jest podobne do zarządzania wymiarami i modułami. MeasureGroup Tworzenie obiektu odbywa się w następujących krokach:
Utwórz obiekt grupy miar i wypełnij podstawowe atrybuty.
Podstawowe atrybuty to Nazwa, Tryb przechowywania, Tryb przetwarzania, Miara domyślna i inne atrybuty grupy miar.
Przed utworzeniem grupy miar sprawdź, czy grupa miar nie istnieje. W poniższym przykładowym kodzie, jeśli grupa miar istnieje, grupa miar zostanie porzucona i ponownie utworzona.
Utwórz miary grupy miar. Dla każdej utworzonej miary przypisywane są następujące atrybuty: nazwa, funkcja agregacji, kolumna źródłowa, ciąg formatu. Można również przypisać inne atrybuty. Zwróć uwagę, że w poniższym przykładowym kodzie metoda CreateDataItem dodaje kolumnę do schematu.
Dodaj wymiary grupy miar.
Wymiary są dodawane do kolekcji wymiarów bieżącej grupy miar z kolekcji wymiarów modułu nadrzędnego. Gdy tylko wymiar zostanie dodany do kolekcji wymiarów grupy miar, można zamapować kolumnę klucza z tabeli faktów do tego wymiaru, umożliwiając przeglądanie grupy miar przez wymiar.
W poniższym przykładowym kodzie zobacz wiersze w obszarze "Mapowanie wymiaru i kolumny klucza z tabeli faktów". Wymiary odgrywające rolę są implementowane przez łączenie różnych kluczy zastępczych z tym samym wymiarem pod różnymi nazwami. Dla każdego z wymiarów ról (Date, Ship Date, Delivery Date) jest połączony inny klucz zastępczy (OrderDateKey, ShipDateKey, DueDateKey). Wszystkie klucze pochodzą z tabeli faktów FactInternetSales.
Dodaj zaprojektowane partycje grupy miar.
W poniższym przykładowym kodzie tworzenie partycji jest opakowane w jedną metodę.
Zaktualizuj serwer, korzystając z metody Update bieżącej grupy miar.
W poniższym przykładowym kodzie wszystkie grupy miar są aktualizowane, kiedy kostka jest aktualizowana.
Poniższy przykładowy kod utworzy grupę miar InternetSales w przykładzie projektu Adventure Works Analysis Services.
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 grupy miar
Przetwarzanie grupy miar jest tak proste, jak użycie metody MeasureGroup Process obiektu. Przetwarzanie grupy miar spowoduje przetworzenie wszystkich partycji należących do grupy miar. Przetwarzanie grupy miar wewnętrznie sprowadza się do przetwarzania wymiarów i partycji. Zobacz Przetwarzanie partycji w tym dokumencie.
Poniższy kod wykona pełny proces we wszystkich grupach miar dostarczonej kostki.
static void FullProcessAllMeasureGroups(Cube cube)
{
foreach (MeasureGroup mg in cube.MeasureGroups)
mg.Process(ProcessType.ProcessFull);
}
Obiekty partycji
Aby administrować partycją lub przetwarzać go, programujesz Partition obiekt.
Tworzenie, usuwanie i znajdowanie partycji
Partycje to proste obiekty, które można utworzyć w dwóch krokach.
Utwórz obiekt partycji i wypełnij podstawowe atrybuty.
Atrybuty podstawowe to Name, Storage Mode, partition source, Slice, a także inne atrybuty grupy miar. Źródło partycji definiuje instrukcję select języka SQL dla bieżącej partycji. Slice to wyrażenie MDX określające krotkę lub zestaw, który rozdziela część wymiarów z nadrzędnej grupy miar, które znajdują się w bieżącej partycji. W przypadku partycji MOLAP fragmentowanie jest określane automatycznie za każdym razem, gdy partycja jest przetwarzana.
Przed utworzeniem partycji należy sprawdzić, czy partycja nie istnieje. W poniższym przykładowym kodzie, jeśli partycja istnieje, zostanie ona porzucona, a następnie ponownie utworzona.
Zaktualizuj serwer przy użyciu metody Update bieżącej partycji.
W poniższym przykładowym kodzie wszystkie partycje są aktualizowane po zaktualizowaniu modułu.
Poniższy przykładowy kod tworzy partycje dla grupy miar "InternetSales".
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");
}
Przetwarzanie partycji
Przetwarzanie partycji jest tak proste, jak użycie metody Partition Process obiektu.
Poniższy przykładowy kod wykonuje pełny proces we wszystkich partycjach określonej grupy miar.
static void FullProcessAllPartitions(MeasureGroup mg)
{
foreach (Partition part in mg.Partitions)
part.Process(ProcessType.ProcessFull);
}
Scalanie partycji
Scalanie partycji oznacza wykonanie dowolnej operacji, która powoduje, że co najmniej dwie partycje stają się jedną partycją.
Metodą obiektu Partition jest scalanie partycji. To polecenie scala dane co najmniej jednej partycji źródłowej z partycją docelową i usuwa partycje źródłowe.
Partycje można scalić tylko wtedy, gdy spełniają wszystkie następujące kryteria:
Partycje znajdują się w tej samej grupie miar.
Partycje są przechowywane w tym samym trybie (MOLAP, HOLAP i ROLAP).
Partycje znajdują się na tym samym serwerze; partycje zdalne znajdujące się na tym samym serwerze można scalić.
W przeciwieństwie do poprzednich wersji w usługach Analysis Services nie jest konieczne, aby wszystkie partycje źródłowe miały identyczny projekt agregacji.
Wynikowy zestaw agregacji dla partycji docelowej jest tym samym zestawem agregacji co stan przed uruchomieniem polecenia scalania.
Poniższy przykład kodu scala wszystkie partycje określonej grupy miar. Partycje są łączone w pierwszą partycję w grupie 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();
}
Obiekty agregacji
Aby zaprojektować agregację i zastosować ją do co najmniej jednej partycji, programujesz Aggregation obiekt.
Tworzenie i usuwanie agregacji
Agregacje można łatwo tworzyć i przypisywać do grup miar lub partycji przy użyciu metody DesignAggregations z AggregationDesign obiektu. Obiekt AggregationDesign jest oddzielnym obiektem od partycji, obiekt AggregationDesign jest zawarty w obiekcie MeasureGroup. Agregacje można zaprojektować do określonego poziomu optymalizacji (od 0 do 100) lub do określonego poziomu magazynu (bajtów). Wiele partycji może używać tego samego projektu agregacji.
Poniższy przykładowy kod tworzy agregacje dla wszystkich partycji podanej grupy miar. Wszelkie istniejące agregacje w partycjach są usuwane.
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;
}