Créer des tables, des partitions et des colonnes dans un modèle tabulaire
S’applique à :
SQL Server 2016 et versions ultérieures Analysis Services Azure Analysis Services Fabric/Power BI Premium
Dans un modèle tabulaire, une table se compose de lignes et de colonnes. Les lignes sont organisées en partitions pour prendre en charge l’actualisation incrémentielle des données. Une solution tabulaire peut prendre en charge plusieurs types de tables, selon l’endroit d’où proviennent les données :
Tables régulières, où les données proviennent d’une source de données relationnelle, via le fournisseur de données.
Tables push, où les données sont « envoyées » à la table par programmation.
Tables calculées, où les données proviennent d’une expression DAX qui référence un autre objet au sein du modèle pour ses données.
Dans l’exemple de code ci-dessous, nous allons définir une table régulière.
Éléments obligatoires
Une table doit avoir au moins une partition. Une table régulière doit également avoir au moins une colonne définie.
Chaque partition doit avoir une source spécifiant l’origine des données, mais la source peut être définie sur null. En règle générale, la source est une expression de requête qui définit une tranche de données dans le langage de requête de base de données approprié.
Exemple de code : créer une table, une colonne, une partition
Les tables sont représentées par la classe Table (dans l’espace de noms Microsoft.AnalysisServices.Tabular).
Dans l’exemple ci-dessous, nous allons définir une table régulière avec une partition liée à une source de données relationnelle et à quelques colonnes régulières. Nous soumettons également les modifications au serveur et déclencherons une actualisation des données qui les intègre dans le modèle. Cela représente le scénario le plus classique lorsque vous souhaitez charger des données à partir d’une base de données relationnelle SQL Server dans une solution tabulaire.
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();
}
}
}
Partitions dans une table
Les partitions sont représentées par une classe Partition (dans l’espace de noms Microsoft.AnalysisServices.Tabular). La classe Partition expose une propriété Source de type PartitionSource , qui fournit une abstraction sur les différentes approches d’ingestion de données dans la partition. Une partition instance peut avoir une propriété Source comme null, ce qui indique que les données seront envoyées dans la partition en envoyant des blocs de données au serveur dans le cadre de l’API de données push exposée par Analysis Services. Dans SQL Server 2016, la classe PartitionSource a deux classes dérivées qui représentent des façons de lier des données à une partition : QueryPartitionSource et CalculatedPartitionSource.
Colonnes dans une table
Les colonnes sont représentées par plusieurs classes dérivées de la classe Column de base (dans l’espace de noms Microsoft.AnalysisServices.Tabular) :
- DataColumn (pour les colonnes régulières dans les tables régulières)
- CalculatedColumn (pour les colonnes soutenues par l’expression DAX)
- CalculatedTableColumn (pour les colonnes régulières dans les tables calculées)
- RowNumberColumn (type spécial de colonne créé par SSAS pour chaque table).
Numéros de ligne dans une table
Chaque objet Table sur un serveur a un RowNumberColumn utilisé à des fins d’indexation. Vous ne pouvez pas le créer ou l’ajouter explicitement. La colonne est créée automatiquement lorsque vous enregistrez ou mettez à jour l’objet :
Db. Savechanges
Db. Update(ExpandFull)
Lors de l’appel de l’une ou l’autre méthode, le serveur crée automatiquement la colonne de numéro de ligne, qui sera visible sous la forme RowNumberColumn de la collection Columns de la table.
Tables calculées
Les tables calculées proviennent d’une expression DAX qui réappare les données des structures de données existantes dans le modèle ou des liaisons hors ligne. Pour créer une table calculée par programme, procédez comme suit :
Créez une table générique.
Ajoutez-y une partition avec source de type CalculatedPartitionSource, où la source est une expression DAX. La source de la partition est ce qui différencie une table régulière d’une table calculée.
Lorsque vous enregistrez les modifications sur le serveur, le serveur retourne la liste déduite de CalculatedTableColumns (les tables calculées sont composées de colonnes de table calculées), visible via la collection Columns de la table.
Étape suivante
Passez en revue les classes utilisées pour gérer les exceptions dans TOM : Gestion des erreurs dans TOM
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour