Conception de tables dans Azure SQL Data WarehouseDesigning tables in Azure SQL Data Warehouse

Découvrez les principaux concepts de la conception de tables dans Azure SQL Data Warehouse.Learn key concepts for designing tables in Azure SQL Data Warehouse.

Déterminer la catégorie des tablesDetermine table category

Un schéma en étoile organise les données dans des tables de faits et de dimension.A star schema organizes data into fact and dimension tables. Certaines tables sont utilisées pour l’intégration ou la mise en lots des données avant leur transfert dans une table de faits ou de dimension.Some tables are used for integration or staging data before it moves to a fact or dimension table. Quand vous concevez une table, déterminez si les données de la table sont contenues dans une table de faits, de dimension ou d’intégration.As you design a table, decide whether the table data belongs in a fact, dimension, or integration table. Ceci est important pour choisir une structure et une distribution appropriées pour la table.This decision informs the appropriate table structure and distribution.

  • Les tables de faits contiennent des données quantitatives qui sont le plus souvent générées dans un système transactionnel avant d’être chargées dans l’entrepôt de données.Fact tables contain quantitative data that are commonly generated in a transactional system, and then loaded into the data warehouse. Par exemple, une entreprise de vente au détail génère des transactions de ventes chaque jour et charge ensuite ces données dans une table de faits de l’entrepôt de données pour les analyser.For example, a retail business generates sales transactions every day, and then loads the data into a data warehouse fact table for analysis.

  • Les tables de dimension contiennent des données d’attribut modifiables, mais qui changent peu en règle générale.Dimension tables contain attribute data that might change but usually changes infrequently. Par exemple, le nom et l’adresse d’un client sont stockés dans une table de dimension et sont mis à jour uniquement si le profil du client change.For example, a customer's name and address are stored in a dimension table and updated only when the customer's profile changes. Pour réduire la taille d’une table de faits volumineuse, il est inutile d’indiquer le nom et l’adresse du client dans chaque ligne de la table de faits.To minimize the size of a large fact table, the customer's name and address do not need to be in every row of a fact table. Au lieu de cela, la table de faits et la table de dimension peuvent partager un ID client.Instead, the fact table and the dimension table can share a customer ID. Vous pouvez alors créer une requête de jointure entre les deux tables pour associer le profil d’un client et les transactions qui le concernent.A query can join the two tables to associate a customer's profile and transactions.

  • Les tables d’intégration fournissent un emplacement pour l’intégration ou la mise en lots des données.Integration tables provide a place for integrating or staging data. Vous pouvez créer une table d’intégration en tant que table normale, table externe ou table temporaire.You can create an integration table as a regular table, an external table, or a temporary table. Vous pouvez, par exemple, charger des données dans une table de mise en lots, effectuer des transformations sur ces données, puis insérer les données dans une table de production.For example, you can load data to a staging table, perform transformations on the data in staging, and then insert the data into a production table.

Noms de schéma et de tableSchema and table names

Les schémas sont un bon moyen de regrouper les tables, de manière similaire, conjointement.Schemas are a good way to group tables, used in a similar fashion, together. Si vous migrez plusieurs bases de données à partir d’une solution sur site vers SQL Data Warehouse, nous vous recommandons de migrer tous les tables de faits, dimension et intégration à un schéma dans SQL Data Warehouse.If you are migrating multiple databases from an on-prem solution to SQL Data Warehouse, it works best to migrate all of the fact, dimension, and integration tables to one schema in SQL Data Warehouse. Par exemple, stockez toutes les tables de l’entrepôt de données WideWorldImportersDW dans un seul schéma appelé wwi.For example, you could store all the tables in the WideWorldImportersDW sample data warehouse within one schema called wwi. Le code suivant crée un schéma défini par l’utilisateur appelé wwi.The following code creates a user-defined schema called wwi.

CREATE SCHEMA wwi;

Pour afficher l’organisation des tables dans SQL Data Warehouse, vous pouvez utiliser les préfixes fact, dim et int dans les noms de table.To show the organization of the tables in SQL Data Warehouse, you could use fact, dim, and int as prefixes to the table names. Le tableau suivant répertorie quelques noms de schéma et de table pour WideWorldImportersDW.The following table shows some of the schema and table names for WideWorldImportersDW.

Table WideWorldImportersDWWideWorldImportersDW table Type de tableTable type SQL Data WarehouseSQL Data Warehouse
CityCity DimensionDimension wwi.DimCitywwi.DimCity
OrdreOrder FactFact wwi.FactOrderwwi.FactOrder

Persistance de la tableTable persistence

Les tables stockent les données soit définitivement dans le stockage Azure, soit temporairement dans le stockage Azure, soit dans un magasin de données externe à l’entrepôt de données.Tables store data either permanently in Azure Storage, temporarily in Azure Storage, or in a data store external to data warehouse.

Table normaleRegular table

Une table normale stocke les données dans le stockage Azure comme partie intégrante de l’entrepôt de données.A regular table stores data in Azure Storage as part of the data warehouse. La table et les données sont persistantes, qu’une session soit ou non ouverte.The table and the data persist regardless of whether a session is open. Cet exemple crée une table normale contenant deux colonnes.This example creates a regular table with two columns.

CREATE TABLE MyTable (col1 int, col2 int );  

Table temporaireTemporary table

Une table temporaire existe uniquement pendant la durée de la session.A temporary table only exists for the duration of the session. Vous pouvez utiliser une table temporaire pour empêcher les autres utilisateurs de voir les résultats temporaires et également pour réduire la nécessité pour le nettoyage.You can use a temporary table to prevent other users from seeing temporary results and also to reduce the need for cleanup. Tables temporaires utilisent un stockage local pour vous proposer des performances rapides.Temporary tables utilize local storage to offer fast performance. Pour plus d’informations, consultez Tables temporaires.For more information, see Temporary tables.

Table externeExternal table

Une table externe pointe vers des données situées dans le stockage Blob Azure ou Azure Data Lake Store.An external table points to data located in Azure Storage blob or Azure Data Lake Store. Utilisée conjointement avec l’instruction CREATE TABLE AS SELECT, la sélection à partir d’une table externe permet d’importer des données dans SQL Data Warehouse.When used in conjunction with the CREATE TABLE AS SELECT statement, selecting from an external table imports data into SQL Data Warehouse. Les tables externes sont donc utiles pour charger des données.External tables are therefore useful for loading data. Pour obtenir un didacticiel sur le chargement, consultez Utiliser PolyBase pour charger des données du Stockage Blob Azure.For a loading tutorial, see Use PolyBase to load data from Azure blob storage.

Types de donnéesData types

SQL Data Warehouse prend en charge les types de données les plus couramment utilisés.SQL Data Warehouse supports the most commonly used data types. Pour obtenir la liste des types de données pris en charge, consultez les types de données dans la référence CREATE TABLE dans l’instruction CREATE TABLE.For a list of the supported data types, see data types in CREATE TABLE reference in the CREATE TABLE statement. Pour obtenir des conseils sur l’utilisation des types de données, consultez Types de données.For guidance on using data types, see Data types.

Tables distribuéesDistributed tables

Une fonctionnalité essentielle de SQL Data Warehouse est la façon dont il peut stocker et agissent sur les tables entre distributions.A fundamental feature of SQL Data Warehouse is the way it can store and operate on tables across distributions. SQL Data Warehouse prend en charge trois méthodes de distribution de données, de tourniquet (par défaut), de hachage et répliquées.SQL Data Warehouse supports three methods for distributing data, round-robin (default), hash and replicated.

Tables distribuées par hachageHash-distributed tables

Une table distribuée par hachage distribue les lignes selon la valeur dans la colonne de distribution.A hash distributed table distributes rows based on the value in the distribution column. Table de hachage distribuée est conçue pour optimiser les performances de requêtes sur des tables volumineuses.A hash distributed table is designed to achieve high performance for queries on large tables. Il existe plusieurs facteurs à prendre en compte lors du choix d’une colonne de distribution.There are several factors to consider when choosing a distribution column.

Pour plus d’informations, consultez le Guide de conception pour les tables distribuées.For more information, see Design guidance for distributed tables.

Tables répliquéesReplicated tables

Les tables répliquées effectuent une copie complète de la table disponible sur chaque nœud de calcul.A replicated table has a full copy of the table available on every Compute node. Les requêtes sur les tables répliquées s’exécutent rapidement, car les jointures sur ce type de table ne nécessitent pas de déplacement de données.Queries run fast on replicated tables since joins on replicated tables do not require data movement. Toutefois, la réplication a besoin de plus de stockage et n’est donc pas une méthode appropriée pour les tables volumineuses.Replication requires extra storage, though, and is not practical for large tables.

Pour plus d’informations, consultez Guide de conception pour les tables répliquées.For more information, see Design guidance for replicated tables.

Tables par tourniquetRound-robin tables

Une table par tourniquet distribue les lignes de la table uniformément sur toutes les distributions.A round-robin table distributes table rows evenly across all distributions. Les lignes sont distribuées de façon aléatoire.The rows are distributed randomly. Le chargement des données dans une table par tourniquet se fait rapidement.Loading data into a round-robin table is fast. Toutefois, les requêtes peuvent nécessiter davantage de déplacements de données que les autres méthodes de distribution.However, queries can require more data movement than the other distribution methods.

Pour plus d’informations, consultez le Guide de conception pour les tables distribuées.For more information, see Design guidance for distributed tables.

Méthodes courantes de distribution pour les tablesCommon distribution methods for tables

La catégorie de la table détermine souvent le choix de l’option de distribution de la table.The table category often determines which option to choose for distributing the table.

Catégorie de tableTable category Option de distribution recommandéeRecommended distribution option
FactFact Utilisez la distribution par hachage avec un index columnstore cluster.Use hash-distribution with clustered columnstore index. Les performances sont meilleures quand deux tables de hachage sont jointes sur la même colonne de distribution.Performance improves when two hash tables are joined on the same distribution column.
DimensionDimension Utilisez la réplication pour les tables de petite taille.Use replicated for smaller tables. Si les tables sont trop volumineuses pour être stockées sur chaque nœud de calcul, utilisez la distribution par hachage.If tables are too large to store on each Compute node, use hash-distributed.
StagingStaging Utilisez la distribution par tourniquet (round robin) pour la table de mise en lots.Use round-robin for the staging table. Le chargement avec la fonctionnalité CTAS est rapide.The load with CTAS is fast. Une fois les données dans la table intermédiaire, utilisez INSERT... Sélectionnez cette option pour déplacer les données vers les tables de production.Once the data is in the staging table, use INSERT...SELECT to move the data to production tables.

Partitions de tableTable partitions

Une table partitionnée stocke les lignes de table et effectue des opérations sur ces lignes selon les plages de données définies.A partitioned table stores and performs operations on the table rows according to data ranges. Par exemple, une table peut être partitionnée par jour, mois ou année.For example, a table could be partitioned by day, month, or year. Vous pouvez améliorer les performances des requêtes via l’élimination de partition, qui limite l’analyse d’une requête aux seules données contenues dans une partition.You can improve query performance through partition elimination, which limits a query scan to data within a partition. Vous pouvez également tenir à jour les données à l’aide du basculement de partition.You can also maintain the data through partition switching. Comme les données dans SQL Data Warehouse sont déjà distribuées, un partitionnement excessif risque de ralentir les requêtes.Since the data in SQL Data Warehouse is already distributed, too many partitions can slow query performance. Pour plus d’informations, consultez Partitionnement de tables.For more information, see Partitioning guidance. Lorsque le basculement dans la table de partition partitions qui ne sont pas vides, envisagez d’utiliser l’option TRUNCATE_TARGET dans votre ALTER TABLE instruction si les données existantes sont le point d’être tronqué.When partition switching into table partitions that are not empty, consider using the TRUNCATE_TARGET option in your ALTER TABLE statement if the existing data is to be truncated. Le dessous des commutateurs de code dans les données transformées quotidiennes dans le SalesFact remplaçant les données existantes.The below code switches in the transformed daily data into the SalesFact overwriting any existing data.

ALTER TABLE SalesFact_DailyFinalLoad SWITCH PARTITION 256 TO SalesFact PARTITION 256 WITH (TRUNCATE_TARGET = ON);  

Index ColumnstoreColumnstore indexes

Par défaut, SQL Data Warehouse stocke une table comme un index columnstore cluster.By default, SQL Data Warehouse stores a table as a clustered columnstore index. Ce format de stockage de données permet une compression élevée des données et offre des performances optimales pour les requêtes sur des tables volumineuses.This form of data storage achieves high data compression and query performance on large tables. L’index columnstore cluster est généralement le meilleur choix, mais dans certains cas, un index cluster ou un segment de mémoire est la structure de stockage la plus appropriée.The clustered columnstore index is usually the best choice, but in some cases a clustered index or a heap is the appropriate storage structure. Une table de segment de mémoire peut être particulièrement utile pour le chargement des données temporaires, comme une table intermédiaire qui est transformée en une table finale.A heap table can be especially useful for loading transient data, such as a staging table which is transformed into a final table.

Pour obtenir la liste des fonctionnalités columnstore, consultez Nouveautés pour les index columnstore.For a list of columnstore features, see What's new for columnstore indexes. Pour améliorer les performances des index columnstore, consultez Optimiser la qualité du rowgroup pour les index columnstore.To improve columnstore index performance, see Maximizing rowgroup quality for columnstore indexes.

StatistiquesStatistics

L’optimiseur de requête utilise des statistiques au niveau des colonnes quand il crée le plan d’exécution d’une requête.The query optimizer uses column-level statistics when it creates the plan for executing a query. Pour améliorer les performances des requêtes, il est important de disposer de statistiques sur des colonnes individuelles, en particulier les colonnes utilisées dans les jointures de requête.To improve query performance, it's important to have statistics on individual columns, especially columns used in query joins. Création de statistiques se produit automatiquement.Creating statistics happens automatically. Toutefois, la mise à jour des statistiques n’est pas automatique.However, updating statistics does not happen automatically. Mettez à jour les statistiques après l’ajout ou la modification d’un nombre significatif de lignes.Update statistics after a significant number of rows are added or changed. Par exemple, effectuez une mise à jour des statistiques après un chargement.For example, update statistics after a load. Pour plus d’informations, consultez Gestion des statistiques.For more information, see Statistics guidance.

Commandes pour la création de tablesCommands for creating tables

Vous pouvez créer une table à partir d’une nouvelle table vide.You can create a table as a new empty table. Vous pouvez aussi créer une table et la remplir avec les résultats d’une instruction select.You can also create and populate a table with the results of a select statement. Le tableau suivant répertorie les instructions T-SQL disponibles pour la création d’une table.The following are the T-SQL commands for creating a table.

Instruction T-SQLT-SQL Statement DescriptionDescription
CREATE TABLECREATE TABLE Crée une table vide en définissant toutes les colonnes et options de la table.Creates an empty table by defining all the table columns and options.
CREATE EXTERNAL TABLECREATE EXTERNAL TABLE Crée une table externe.Creates an external table. La définition de la table est stockée dans SQL Data Warehouse.The definition of the table is stored in SQL Data Warehouse. Les données de la table sont stockées dans le Stockage Blob Azure ou Azure Data Lake Store.The table data is stored in Azure Blob storage or Azure Data Lake Store.
CREATE TABLE AS SELECTCREATE TABLE AS SELECT Crée une table et la remplit avec les résultats d’une instruction select.Populates a new table with the results of a select statement. Les colonnes et les types de données de la table sont basés sur les résultats de l’instruction select.The table columns and data types are based on the select statement results. Pour importer des données, cette instruction peut sélectionner les données dans une table externe.To import data, this statement can select from an external table.
CREATE EXTERNAL TABLE AS SELECTCREATE EXTERNAL TABLE AS SELECT Crée une table externe en exportant les résultats d’une instruction select vers un emplacement externe.Creates a new external table by exporting the results of a select statement to an external location. L’emplacement est le stockage Blob Azure ou Azure Data Lake Store.The location is either Azure Blob storage or Azure Data Lake Store.

Alignement des données sources avec l’entrepôt de donnéesAligning source data with the data warehouse

Les tables de l’entrepôt de données sont remplies avec les données chargées à partir d’une autre source de données.Data warehouse tables are populated by loading data from another data source. Pour effectuer un chargement correct, le nombre et les types de données des colonnes dans les données sources doivent être alignés sur la définition de la table dans l’entrepôt de données.To perform a successful load, the number and data types of the columns in the source data must align with the table definition in the data warehouse. L’alignement des données est parfois l’étape la plus difficile dans la conception des tables.Getting the data to align might be the hardest part of designing your tables.

Si les données proviennent de plusieurs magasins de données, vous pouvez importer les données dans l’entrepôt de données et les stocker dans une table d’intégration.If data is coming from multiple data stores, you can bring the data into the data warehouse and store it in an integration table. Vous pouvez ensuite effectuer des opérations de transformation sur les données de la table d’intégration en bénéficiant de toute la puissance de SQL Data Warehouse.Once data is in the integration table, you can use the power of SQL Data Warehouse to perform transformation operations. Une fois que les données sont préparées, vous pouvez les insérer dans des tables de production.Once the data is prepared, you can insert it into production tables.

Fonctionnalités de table non prises en chargeUnsupported table features

SQL Data Warehouse prend en charge beaucoup des fonctionnalités de table proposées par d’autres bases de données, mais pas toutes.SQL Data Warehouse supports many, but not all, of the table features offered by other databases. La liste suivante répertorie certaines fonctionnalités de table qui ne sont pas prises en charge dans SQL Data Warehouse.The following list shows some of the table features that are not supported in SQL Data Warehouse.

Requêtes de taille de tableTable size queries

Un moyen simple d’identifier l’espace et les lignes consommées par une table dans chacune des 60 distributions consiste à utiliser DBCC PDW_SHOWSPACEUSED.One simple way to identify space and rows consumed by a table in each of the 60 distributions, is to use DBCC PDW_SHOWSPACEUSED.

DBCC PDW_SHOWSPACEUSED('dbo.FactInternetSales');

Toutefois, l’utilisation des commandes DBCC peut être très limitante.However, using DBCC commands can be quite limiting. Les vues de gestion dynamique (DMV) affichent des informations plus détaillées que les commandes DBCC.Dynamic management views (DMVs) show more detail than DBCC commands. Commencez par créer cette vue.Start by creating this view.

CREATE VIEW dbo.vTableSizes
AS
WITH base
AS
(
SELECT 
 GETDATE()                                                             AS  [execution_time]
, DB_NAME()                                                            AS  [database_name]
, s.name                                                               AS  [schema_name]
, t.name                                                               AS  [table_name]
, QUOTENAME(s.name)+'.'+QUOTENAME(t.name)                              AS  [two_part_name]
, nt.[name]                                                            AS  [node_table_name]
, ROW_NUMBER() OVER(PARTITION BY nt.[name] ORDER BY (SELECT NULL))     AS  [node_table_name_seq]
, tp.[distribution_policy_desc]                                        AS  [distribution_policy_name]
, c.[name]                                                             AS  [distribution_column]
, nt.[distribution_id]                                                 AS  [distribution_id]
, i.[type]                                                             AS  [index_type]
, i.[type_desc]                                                        AS  [index_type_desc]
, nt.[pdw_node_id]                                                     AS  [pdw_node_id]
, pn.[type]                                                            AS  [pdw_node_type]
, pn.[name]                                                            AS  [pdw_node_name]
, di.name                                                              AS  [dist_name]
, di.position                                                          AS  [dist_position]
, nps.[partition_number]                                               AS  [partition_nmbr]
, nps.[reserved_page_count]                                            AS  [reserved_space_page_count]
, nps.[reserved_page_count] - nps.[used_page_count]                    AS  [unused_space_page_count]
, nps.[in_row_data_page_count] 
    + nps.[row_overflow_used_page_count] 
    + nps.[lob_used_page_count]                                        AS  [data_space_page_count]
, nps.[reserved_page_count] 
 - (nps.[reserved_page_count] - nps.[used_page_count]) 
 - ([in_row_data_page_count] 
         + [row_overflow_used_page_count]+[lob_used_page_count])       AS  [index_space_page_count]
, nps.[row_count]                                                      AS  [row_count]
from 
    sys.schemas s
INNER JOIN sys.tables t
    ON s.[schema_id] = t.[schema_id]
INNER JOIN sys.indexes i
    ON  t.[object_id] = i.[object_id]
    AND i.[index_id] <= 1
INNER JOIN sys.pdw_table_distribution_properties tp
    ON t.[object_id] = tp.[object_id]
INNER JOIN sys.pdw_table_mappings tm
    ON t.[object_id] = tm.[object_id]
INNER JOIN sys.pdw_nodes_tables nt
    ON tm.[physical_name] = nt.[name]
INNER JOIN sys.dm_pdw_nodes pn
    ON  nt.[pdw_node_id] = pn.[pdw_node_id]
INNER JOIN sys.pdw_distributions di
    ON  nt.[distribution_id] = di.[distribution_id]
INNER JOIN sys.dm_pdw_nodes_db_partition_stats nps
    ON nt.[object_id] = nps.[object_id]
    AND nt.[pdw_node_id] = nps.[pdw_node_id]
    AND nt.[distribution_id] = nps.[distribution_id]
LEFT OUTER JOIN (select * from sys.pdw_column_distribution_properties where distribution_ordinal = 1) cdp
    ON t.[object_id] = cdp.[object_id]
LEFT OUTER JOIN sys.columns c
    ON cdp.[object_id] = c.[object_id]
    AND cdp.[column_id] = c.[column_id]
)
, size
AS
(
SELECT
   [execution_time]
,  [database_name]
,  [schema_name]
,  [table_name]
,  [two_part_name]
,  [node_table_name]
,  [node_table_name_seq]
,  [distribution_policy_name]
,  [distribution_column]
,  [distribution_id]
,  [index_type]
,  [index_type_desc]
,  [pdw_node_id]
,  [pdw_node_type]
,  [pdw_node_name]
,  [dist_name]
,  [dist_position]
,  [partition_nmbr]
,  [reserved_space_page_count]
,  [unused_space_page_count]
,  [data_space_page_count]
,  [index_space_page_count]
,  [row_count]
,  ([reserved_space_page_count] * 8.0)                                 AS [reserved_space_KB]
,  ([reserved_space_page_count] * 8.0)/1000                            AS [reserved_space_MB]
,  ([reserved_space_page_count] * 8.0)/1000000                         AS [reserved_space_GB]
,  ([reserved_space_page_count] * 8.0)/1000000000                      AS [reserved_space_TB]
,  ([unused_space_page_count]   * 8.0)                                 AS [unused_space_KB]
,  ([unused_space_page_count]   * 8.0)/1000                            AS [unused_space_MB]
,  ([unused_space_page_count]   * 8.0)/1000000                         AS [unused_space_GB]
,  ([unused_space_page_count]   * 8.0)/1000000000                      AS [unused_space_TB]
,  ([data_space_page_count]     * 8.0)                                 AS [data_space_KB]
,  ([data_space_page_count]     * 8.0)/1000                            AS [data_space_MB]
,  ([data_space_page_count]     * 8.0)/1000000                         AS [data_space_GB]
,  ([data_space_page_count]     * 8.0)/1000000000                      AS [data_space_TB]
,  ([index_space_page_count]  * 8.0)                                   AS [index_space_KB]
,  ([index_space_page_count]  * 8.0)/1000                              AS [index_space_MB]
,  ([index_space_page_count]  * 8.0)/1000000                           AS [index_space_GB]
,  ([index_space_page_count]  * 8.0)/1000000000                        AS [index_space_TB]
FROM base
)
SELECT * 
FROM size
;

Résumé de l’espace de tableTable space summary

Cette requête renvoie les lignes et l’espace par table.This query returns the rows and space by table. Elle vous permet de voir quelles tables sont les plus volumineuses et de déterminer si elles sont distribuées par tourniquet (round robin), réplication ou hachage.It allows you to see which tables are your largest tables and whether they are round-robin, replicated, or hash -distributed. Pour les tables distribuées par hachage, la requête affiche la colonne de distribution.For hash-distributed tables, the query shows the distribution column.

SELECT 
     database_name
,    schema_name
,    table_name
,    distribution_policy_name
,      distribution_column
,    index_type_desc
,    COUNT(distinct partition_nmbr) as nbr_partitions
,    SUM(row_count)                 as table_row_count
,    SUM(reserved_space_GB)         as table_reserved_space_GB
,    SUM(data_space_GB)             as table_data_space_GB
,    SUM(index_space_GB)            as table_index_space_GB
,    SUM(unused_space_GB)           as table_unused_space_GB
FROM 
    dbo.vTableSizes
GROUP BY 
     database_name
,    schema_name
,    table_name
,    distribution_policy_name
,      distribution_column
,    index_type_desc
ORDER BY
    table_reserved_space_GB desc
;

Espace de table par type de distributionTable space by distribution type

SELECT 
     distribution_policy_name
,    SUM(row_count)                as table_type_row_count
,    SUM(reserved_space_GB)        as table_type_reserved_space_GB
,    SUM(data_space_GB)            as table_type_data_space_GB
,    SUM(index_space_GB)           as table_type_index_space_GB
,    SUM(unused_space_GB)          as table_type_unused_space_GB
FROM dbo.vTableSizes
GROUP BY distribution_policy_name
;

Espace de table par type d’indexTable space by index type

SELECT 
     index_type_desc
,    SUM(row_count)                as table_type_row_count
,    SUM(reserved_space_GB)        as table_type_reserved_space_GB
,    SUM(data_space_GB)            as table_type_data_space_GB
,    SUM(index_space_GB)           as table_type_index_space_GB
,    SUM(unused_space_GB)          as table_type_unused_space_GB
FROM dbo.vTableSizes
GROUP BY index_type_desc
;

Résumé de l’espace de distributionDistribution space summary

SELECT 
    distribution_id
,    SUM(row_count)                as total_node_distribution_row_count
,    SUM(reserved_space_MB)        as total_node_distribution_reserved_space_MB
,    SUM(data_space_MB)            as total_node_distribution_data_space_MB
,    SUM(index_space_MB)           as total_node_distribution_index_space_MB
,    SUM(unused_space_MB)          as total_node_distribution_unused_space_MB
FROM dbo.vTableSizes
GROUP BY     distribution_id
ORDER BY    distribution_id
;

Étapes suivantesNext steps

Après avoir créé les tables dans votre entrepôt de données, l’étape suivante va être de charger des données dans ces tables.After creating the tables for your data warehouse, the next step is to load data into the table. Pour suivre un tutoriel sur le chargement, consultez Chargement de données dans SQL Data Warehouse.For a loading tutorial, see Loading data to SQL Data Warehouse.