Erstellen von Tabellen, Partitionen und Spalten in einem tabellarischen Modell
Gilt für:
SQL Server 2016 und höher analysis Services Azure Analysis Services Fabric/Power BI Premium
In einem tabellarischen Modell besteht eine Tabelle aus Zeilen und Spalten. Zeilen werden in Partitionen organisiert, um die inkrementelle Datenaktualisierung zu unterstützen. Eine tabellarische Lösung kann verschiedene Arten von Tabellen unterstützen, je nachdem, wo die Daten stammen:
Reguläre Tabellen, bei denen Daten aus einer relationalen Datenquelle stammen, über den Datenanbieter.
Pushtabellen, bei denen Daten programmgesteuert in die Tabelle "gepusht" werden.
Berechnete Tabellen, bei denen Daten aus einem DAX-Ausdruck stammen, der für seine Daten auf ein anderes Objekt innerhalb des Modells verweist.
Im folgenden Codebeispiel definieren wir eine reguläre Tabelle.
Erforderliche Elemente
Eine Tabelle muss mindestens eine Partition aufweisen. Für eine reguläre Tabelle muss außerdem mindestens eine Spalte definiert sein.
Jede Partition muss über eine Quelle verfügen, die den Ursprung der Daten angibt, aber quelle kann auf NULL festgelegt werden. In der Regel ist die Quelle ein Abfrageausdruck, der einen Datenschnitt in der relevanten Datenbankabfragesprache definiert.
Codebeispiel: Erstellen einer Tabelle, Spalte, Partition
Tabellen werden durch die Table-Klasse (im Microsoft.AnalysisServices.Tabular-Namespace) dargestellt.
Im folgenden Beispiel definieren wir eine reguläre Tabelle mit einer Partition, die mit einer relationalen Datenquelle und einigen regulären Spalten verknüpft ist. Außerdem übermitteln wir die Änderungen an den Server und lösen eine Datenaktualisierung aus, die die Daten in das Modell einführt. Dies stellt das typischste Szenario dar, wenn Sie Daten aus einer SQL Server relationalen Datenbank in eine tabellarische Lösung laden möchten.
using System;
using Microsoft.AnalysisServices;
using Microsoft.AnalysisServices.Tabular;
namespace TOMSamples
{
class Program
{
static void Main(string[] args)
{
//
// Connect to the local default instance of Analysis Services
//
string ConnectionString = "DataSource=localhost";
//
// The using syntax ensures the correct use of the
// Microsoft.AnalysisServices.Tabular.Server object.
//
using (Server server = new Server())
{
server.Connect(ConnectionString);
//
// Generate a new database name and use GetNewName
// to ensure the database name is unique.
//
string newDatabaseName =
server.Databases.GetNewName("Database with a Table Definition");
//
// Instantiate a new
// Microsoft.AnalysisServices.Tabular.Database object.
//
var dbWithTable = new Database()
{
Name = newDatabaseName,
ID = newDatabaseName,
CompatibilityLevel = 1200,
StorageEngineUsed = StorageEngineUsed.TabularMetadata,
};
//
// Add a Microsoft.AnalysisServices.Tabular.Model object to the
// database, which acts as a root for all other Tabular metadata objects.
//
dbWithTable.Model = new Model()
{
Name = "Tabular Data Model",
Description = "A Tabular data model at the 1200 compatibility level."
};
//
// Add a Microsoft.AnalysisServices.Tabular.ProviderDataSource object
// to the data Model object created in the previous step. The connection
// string of the data source object in this example
// points to an instance of the AdventureWorks2014 SQL Server database.
//
string dataSourceName = "SQL Server Data Source Example";
dbWithTable.Model.DataSources.Add(new ProviderDataSource()
{
Name = dataSourceName,
Description = "A data source definition that uses explicit Windows credentials for authentication against SQL Server.",
ConnectionString = "Provider=SQLNCLI11;Data Source=localhost;Initial Catalog=AdventureWorks2014;Integrated Security=SSPI;Persist Security Info=false",
ImpersonationMode = Microsoft.AnalysisServices.Tabular.ImpersonationMode.ImpersonateAccount,
Account = @".\Administrator",
Password = "P@ssw0rd",
});
//
// Add a table called Individual Customers to the data model
// with a partition that points to a [Sales].[vIndividualCustomer] view
// in the underlying data source.
//
dbWithTable.Model.Tables.Add(new Table()
{
Name = dbWithTable.Model.Tables.GetNewName("Individual Customers"),
Description = "Individual customers (names and email addresses) that purchase Adventure Works Cycles products online.",
Partitions = {
//
// Create a single partition with a QueryPartitionSource for a query
// that imports all customer rows from the underlying data source.
//
new Partition() {
Name = "All Customers",
Source = new QueryPartitionSource() {
DataSource = dbWithTable.Model.DataSources[dataSourceName],
Query = @"SELECT [FirstName]
,[MiddleName]
,[LastName]
,[PhoneNumber]
,[EmailAddress]
,[City]
FROM [Sales].[vIndividualCustomer]",
}
}
},
Columns =
{
//
// DataColumn objects refer to regular table columns.
// Each DataColumn object corresponds to a column in the underlying data source query.
//
new DataColumn() {
Name = "FirstName",
DataType = DataType.String,
SourceColumn = "FirstName",
},
new DataColumn() {
Name = "MiddleName",
DataType = DataType.String,
SourceColumn = "MiddleName",
},
new DataColumn() {
Name = "LastName",
DataType = DataType.String,
SourceColumn = "LastName",
},
new DataColumn() {
Name = "PhoneNumber",
DataType = DataType.String,
SourceColumn = "PhoneNumber",
},
new DataColumn() {
Name = "EmailAddress",
DataType = DataType.String,
SourceColumn = "EmailAddress",
},
new DataColumn() {
Name = "City",
DataType = DataType.String,
SourceColumn = "City",
},
}
});
//
// Add the new database object to the server's
// Databases connection and submit the changes
// with full expansion to the server.
//
server.Databases.Add(dbWithTable);
//
// Request a full refresh to import the data from the data source and
// and perform any necessary recalculations.
// The refresh operation will be performed with the next
// invocation of Model.SaveChanges() or Database.Update(UpdateOptions.ExpandFull).
dbWithTable.Model.RequestRefresh(Microsoft.AnalysisServices.Tabular.RefreshType.Full);
dbWithTable.Update(UpdateOptions.ExpandFull);
Console.Write("Database ");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(dbWithTable.Name);
Console.ResetColor();
Console.WriteLine(" created successfully.");
Console.WriteLine("The data model includes the following table definitions:");
Console.ForegroundColor = ConsoleColor.Yellow;
foreach (Table tbl in dbWithTable.Model.Tables)
{
Console.WriteLine("\tTable name:\t\t{0}", tbl.Name);
Console.WriteLine("\ttbl description:\t{0}", tbl.Description);
}
Console.ResetColor();
Console.WriteLine();
}
Console.WriteLine("Press Enter to close this console window.");
Console.ReadLine();
}
}
}
Partitionen in einer Tabelle
Partitionen werden durch eine Partitionsklasse (im Microsoft.AnalysisServices.Tabular-Namespace) dargestellt. Die Partition-Klasse macht eine Source-Eigenschaft vom Typ PartitionSource verfügbar, die eine Abstraktion über die verschiedenen Ansätze zum Erfassen von Daten in der Partition bereitstellt. Ein Partitions-instance kann eine Source-Eigenschaft als NULL aufweisen, die angibt, dass Daten in die Partition gepusht werden, indem Datenblöcke im Rahmen der Von Analysis Services verfügbar gemachten Pushdaten-API an den Server gesendet werden. In SQL Server 2016 verfügt die PartitionSource-Klasse über zwei abgeleitete Klassen, die Möglichkeiten zum Binden von Daten an eine Partition darstellen: QueryPartitionSource und CalculatedPartitionSource.
Spalten in einer Tabelle
Spalten werden durch mehrere Klassen dargestellt, die von der Column-Basisklasse (im Microsoft.AnalysisServices.Tabular-Namespace) abgeleitet sind:
- DataColumn (für reguläre Spalten in regulären Tabellen)
- CalculatedColumn (für Spalten, die vom DAX-Ausdruck unterstützt werden)
- CalculatedTableColumn (für reguläre Spalten in berechneten Tabellen)
- RowNumberColumn (spezieller Spaltentyp, der von SSAS für jede Tabelle erstellt wird).
Zeilennummern in einer Tabelle
Jedes Table-Objekt auf einem Server verfügt über eine RowNumberColumn, die zu Indizierungszwecken verwendet wird. Sie können sie nicht explizit erstellen oder hinzufügen. Die Spalte wird automatisch erstellt, wenn Sie das Objekt speichern oder aktualisieren:
Db. Savechanges
Db. Update(ExpandFull)
Beim Aufrufen einer der Methoden erstellt der Server automatisch eine Zeilennummernspalte, die als RowNumberColumn für die Columns-Auflistung der Tabelle sichtbar ist.
Berechnete Tabellen
Berechnete Tabellen stammen aus einem DAX-Ausdruck, der Daten aus vorhandenen Datenstrukturen im Modell oder out-of-line-Bindungen neu verwendet. Gehen Sie wie folgt vor, um eine berechnete Tabelle programmgesteuert zu erstellen:
Erstellen Sie eine generische Tabelle.
Fügen Sie ihr eine Partition mit Source vom Typ CalculatedPartitionSource hinzu, wobei die Quelle ein DAX-Ausdruck ist. Die Quelle der Partition unterscheidet eine reguläre Tabelle von einer berechneten Tabelle.
Wenn Sie die Änderungen auf dem Server speichern, gibt der Server die abgeleitete Liste der CalculatedTableColumns zurück (berechnete Tabellen bestehen aus berechneten Tabellenspalten), die über die Columns-Auflistung der Tabelle sichtbar ist.
Nächster Schritt
Überprüfen Sie die Klassen, die für die Behandlung von Ausnahmen in TOM: Behandeln von Fehlern in TOM verwendet werden.