Progettazione di tabelle in Azure SQL Data WarehouseDesigning tables in Azure SQL Data Warehouse

Concetti chiave della progettazione di tabelle in Azure SQL Data Warehouse.Learn key concepts for designing tables in Azure SQL Data Warehouse.

Determinare la categoria della tabellaDetermine table category

Uno schema star organizza i dati in tabelle fact e tabelle delle dimensioni.A star schema organizes data into fact and dimension tables. Alcune tabelle vengono usate per i dati di integrazione o di staging prima di spostarli in una tabella fact o delle dimensioni.Some tables are used for integration or staging data before it moves to a fact or dimension table. Quando si progetta una tabella, occorre decidere se i dati appartengono a una tabella fact, delle dimensioni o di integrazione.As you design a table, decide whether the table data belongs in a fact, dimension, or integration table. Questa decisione determina la struttura della tabella e la distribuzione appropriate.This decision informs the appropriate table structure and distribution.

  • Le tabelle fact contengono i dati quantitativi che vengono comunemente generati in un sistema transazionale e successivamente caricati nel data warehouse.Fact tables contain quantitative data that are commonly generated in a transactional system, and then loaded into the data warehouse. Un'azienda di vendita al dettaglio, ad esempio, genera quotidianamente transazioni di vendita e successivamente carica i dati in una tabella fact di data warehouse per analizzarli.For example, a retail business generates sales transactions every day, and then loads the data into a data warehouse fact table for analysis.

  • Le tabelle delle dimensioni contengono i dati degli attributi che possono cambiare, ma che in genere cambiano raramente.Dimension tables contain attribute data that might change but usually changes infrequently. Il nome e l'indirizzo di un cliente, ad esempio, vengono archiviati in una tabella delle dimensioni e aggiornati solo quando viene modificato il profilo del cliente.For example, a customer's name and address are stored in a dimension table and updated only when the customer's profile changes. Per ridurre al minimo le dimensioni di una tabella fact di grandi dimensioni, si può evitare di inserire il nome e l'indirizzo del cliente in ogni riga della tabella.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. La tabella fact e la tabella delle dimensioni possono invece condividere un ID cliente.Instead, the fact table and the dimension table can share a customer ID. Una query può creare un join tra le due tabelle per associare il profilo e le transazioni di un cliente.A query can join the two tables to associate a customer's profile and transactions.

  • Le tabelle di integrazione sono un luogo in cui integrare o gestire temporaneamente i dati.Integration tables provide a place for integrating or staging data. È possibile creare una tabella di integrazione come una tabella normale, una tabella esterna o una tabella temporanea.You can create an integration table as a regular table, an external table, or a temporary table. È ad esempio possibile caricare i dati in una tabella di staging, eseguire trasformazioni sui dati in gestione temporanea e quindi inserirli in una tabella di produzione.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.

Nomi di tabella e dello schemaSchema and table names

In SQL Data Warehouse un data warehouse è un tipo di database.In SQL Data Warehouse, a data warehouse is a type of database. Tutte le tabelle nel data warehouse sono contenute all'interno dello stesso database.All of the tables in the data warehouse are contained within the same database. Non è possibile creare un join tra le tabelle che si trovano in più data warehouse.You cannot join tables across multiple data warehouses. Questo comportamento è diverso da quello di SQL Server, dove i join tra database sono supportati.This behavior is different from SQL Server, which supports cross-database joins.

In un database di SQL Server è possibile usare fact, dim o integrate come nomi di schema.In a SQL Server database, you might use fact, dim, or integrate for the schema names. Se si esegue la migrazione di un database di SQL Server a SQL Data Warehouse, è consigliabile migrare tutte le tabelle fact, delle dimensioni e di integrazione in un unico schema in SQL Data Warehouse.If you are migrating a SQL Server database to SQL Data Warehouse, it works best to migrate all of the fact, dimension, and integration tables to one schema in SQL Data Warehouse. Si può, ad esempio, archiviare tutte le tabelle nel data warehouse di esempio WideWorldImportersDW all'interno di un unico schema denominato wwi.For example, you could store all the tables in the WideWorldImportersDW sample data warehouse within one schema called wwi. Il codice seguente crea uno schema definito dall'utente denominato wwi.The following code creates a user-defined schema called wwi.

CREATE SCHEMA wwi;

Per visualizzare l'organizzazione delle tabelle in SQL Data Warehouse, è possibile usare fact, dim e int come prefissi dei nomi delle tabelle.To show the organization of the tables in SQL Data Warehouse, you could use fact, dim, and int as prefixes to the table names. La tabella seguente include alcuni dei nomi di tabella e dello schema per WideWorldImportersDW.The following table shows some of the schema and table names for WideWorldImportersDW. Questa tabella mette a confronto i nomi in SQL Server con i nomi in SQL Data Warehouse.It compares the names in SQL Server with names in SQL Data Warehouse.

Tabella WideWorldImportersDWWideWorldImportersDW table Tipo di tabellaTable type SQL ServerSQL Server SQL Data WarehouseSQL Data Warehouse
CityCity DimensionDimension Dimension.CityDimension.City wwi.DimCitywwi.DimCity
OrdineOrder FactFact Fact.OrderFact.Order wwi.FactOrderwwi.FactOrder

Persistenza delle tabelleTable persistence

Le tabelle archiviano i dati in modo permanente in Archiviazione di Azure, temporaneamente in Archiviazione di Azure oppure in un archivio dati esterno al data warehouse.Tables store data either permanently in Azure Storage, temporarily in Azure Storage, or in a data store external to data warehouse.

Tabella normaleRegular table

Una tabella normale archivia i dati in Archiviazione di Azure come parte del data warehouse.A regular table stores data in Azure Storage as part of the data warehouse. La tabella e i dati sono persistenti indipendentemente dalla presenza o meno di una sessione aperta.The table and the data persist regardless of whether a session is open. Questo esempio crea una tabella normale con due colonne.This example creates a regular table with two columns.

CREATE TABLE MyTable (col1 int, col2 int );  

Tabella temporaneaTemporary table

Una tabella temporanea esiste solo per la durata della sessione.A temporary table only exists for the duration of the session. Si può usare questo tipo di tabella per impedire ad altri utenti di visualizzare i risultati temporanei e anche per ridurre la necessità di eseguire una pulizia.You can use a temporary table to prevent other uses from seeing temporary results and also to reduce the need for cleanup. Poiché le tabelle temporanee utilizzano anche archiviazione locale, possono offrire prestazioni più veloci per alcune operazioni.Since temporary tables also utilize local storage, they can offer faster performance for some operations. Per altre informazioni, vedere Tabelle temporanee.For more information, see Temporary tables.

Tabella esternaExternal table

Una tabella esterna punta ai dati che si trovano nel BLOB del servizio di archiviazione di Azure o in Azure Data Lake Store.An external table points to data located in Azure Storage blob or Azure Data Lake Store. Quando viene usata in combinazione con l'istruzione CREATE TABLE AS SELECT, la selezione da una tabella esterna importa i dati in 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. Le tabelle esterne sono pertanto utili per il caricamento dei dati.External tables are therefore useful for loading data. Per un'esercitazione sul caricamento, vedere Usare PolyBase per caricare dati dall'archivio BLOB di Azure a SQL Data Warehouse.For a loading tutorial, see Use PolyBase to load data from Azure blob storage.

Tipi di datiData types

SQL Data Warehouse supporta i tipi di dati più diffusi.SQL Data Warehouse supports the most commonly used data types. Per un elenco dei tipi di dati supportati, vedere tipi di dati nel riferimento sull'istruzione CREATE TABLE.For a list of the supported data types, see data types in CREATE TABLE reference in the CREATE TABLE statement. La riduzione al minimo delle dimensioni dei tipi di dati consente di migliorare le prestazioni delle query.Minimizing the size of data types helps to improve query performance. Per informazioni sull'uso dei tipi di dati, vedere Tipi di dati.For guidance on using data types, see Data types.

Tabelle con distribuzioneDistributed tables

Una caratteristica fondamentale di SQL Data Warehouse è il modo è riesce ad archiviare e operare sulle tabelle in 60 distribuzioni.A fundamental feature of SQL Data Warehouse is the way it can store and operate on tables across 60 distributions. Le tabelle vengono distribuite usando un metodo round robin, hash o di replica.The tables are distributed using a round-robin, hash, or replication method.

Tabelle con distribuzione hashHash-distributed tables

La distribuzione hash distribuisce le righe in base al valore nella colonna di distribuzione.The hash distribution distributes rows based on the value in the distribution column. La tabella con distribuzione hash è progettata per ottenere prestazioni elevate in presenza di join di query tra tabelle di grandi dimensioni.The hash-distributed table is designed to achieve high performance for query joins on large tables. Molti fattori influiscono sulla scelta della colonna di distribuzione.There are several factors that affect the choice of the distribution column.

Per altre informazioni, vedere Linee guida di progettazione per tabelle distribuite.For more information, see Design guidance for distributed tables.

Tabelle replicateReplicated tables

Le tabelle replicate mettono a disposizione una copia completa della tabella in ogni nodo di calcolo.A replicated table has a full copy of the table available on every Compute node. Le query sulle tabelle replicate sono veloci poiché i join nelle tabelle replicate non richiedono lo spostamento dei dati.Queries run fast on replicated tables since joins on replicated tables do not require data movement. La replica esige tuttavia uno spazio di archiviazione aggiuntivo e non risulta pratica per le tabelle di grandi dimensioni.Replication requires extra storage, though, and is not practical for large tables.

Per altre informazioni, vedere Linee guida di progettazione per l'uso di tabelle replicate in Azure SQL Data Warehouse.For more information, see Design guidance for replicated tables.

Tabelle round robinRound-robin tables

Una tabella round robin distribuisce le righe della tabella in modo uniforme tra tutte le distribuzioni.A round-robin table distributes table rows evenly across all distributions. Le righe vengono distribuite in modo casuale.The rows are distributed randomly. Il caricamento dei dati in una tabella round robin è veloce.Loading data into a round-robin table is fast. Tuttavia, le query possono richiedere un maggiore spostamento dei dati rispetto agli altri metodi di distribuzione.However, queries can require more data movement than the other distribution methods.

Per altre informazioni, vedere Linee guida di progettazione per tabelle distribuite.For more information, see Design guidance for distributed tables.

Metodi di distribuzione comuni per le tabelleCommon distribution methods for tables

La categoria della tabella spesso determina l'opzione appropriata per la distribuzione della tabella.The table category often determines which option to choose for distributing the table.

Categoria di tabellaTable category Opzione di distribuzione consigliataRecommended distribution option
FactFact Usare la distribuzione hash con indice columnstore cluster.Use hash-distribution with clustered columnstore index. Le prestazioni aumentano quando si crea un join tra due tabelle hash nella stessa colonna di distribuzione.Performance improves when two hash tables are joined on the same distribution column.
DimensionDimension Usare le tabelle replicate per le tabelle di dimensioni più piccole.Use replicated for smaller tables. Se le tabelle sono troppo grandi per essere archiviate in ogni nodo di calcolo, usare le tabelle con distribuzione hash.If tables are too large to store on each Compute node, use hash-distributed.
StagingStaging Usare una tabella round robin per la tabella di staging.Use round-robin for the staging table. Il carico con un'istruzione CTAS è veloce.The load with CTAS is fast. Dopo che i dati sono stati inseriti nella tabella di staging, usare INSERT...SELECT per spostarli in una tabella di produzione.Once the data is in the staging table, use INSERT...SELECT to move the data to a production tables.

Partizioni della tabellaTable partitions

Una tabella partizionata archivia ed esegue operazioni sulle righe di tabella in base agli intervalli di dati.A partitioned table stores and performs operations on the table rows according to data ranges. Una tabella può, ad esempio, essere partizionata in base ai giorni, ai mesi o agli anni.For example, a table could be partitioned by day, month, or year. È possibile migliorare le prestazioni delle query tramite l'eliminazione della partizione, che limita l'analisi di una query ai dati all'interno di una partizione.You can improve query performance through partition elimination, which limits a query scan to data within a partition. È inoltre possibile gestire i dati tramite la commutazione tra partizioni.You can also maintain the data through partition switching. Poiché i dati in SQL Data Warehouse sono già distribuiti, un numero eccessivo di partizioni può rallentare le prestazioni delle query.Since the data in SQL Data Warehouse is already distributed, too many partitions can slow query performance. Per altre informazioni, vedere Indicazioni sul partizionamento.For more information, see Partitioning guidance.

Indici ColumnstoreColumnstore indexes

Per impostazione predefinita, SQL Data Warehouse archivia una tabella come indice columnstore cluster.By default, SQL Data Warehouse stores a table as a clustered columnstore index. Questo modulo di archiviazione dei dati raggiunge compressione dei dati e prestazioni di query elevate su tabelle di grandi dimensioni.This form of data storage achieves high data compression and query performance on large tables. L'indice columnstore cluster è in genere la scelta migliore, ma in alcuni casi un indice cluster o un heap è la struttura di archiviazione appropriata.The clustered columnstore index is usually the best choice, but in some cases a clustered index or a heap is the appropriate storage structure.

Per un elenco delle funzionalità columnstore, vedere Indici columnstore - Novità.For a list of columnstore features, see What's new for columnstore indexes. Per migliorare le prestazioni dell'indice columnstore, vedere Ottimizzazione della qualità di un gruppo di righe per columnstore.To improve columnstore index performance, see Maximizing rowgroup quality for columnstore indexes.

StatisticheStatistics

Quando crea il piano per l'esecuzione di una query, Query Optimizer usa le statistiche a livello di colonna.The query optimizer uses column-level statistics when it creates the plan for executing a query. Per migliorare le prestazioni delle query, è importante creare statistiche su singole colonne, in particolare sulle colonne usate nei join delle query.To improve query performance, it's important to create statistics on individual columns, especially columns used in query joins. La creazione e l'aggiornamento delle statistiche non vengono eseguiti automaticamente.Creating and updating statistics does not happen automatically. Creare le statistiche dopo la creazione di una tabella.Create statistics after creating a table. Aggiornare le statistiche dopo l'aggiunta o la modifica di un numero significativo di righe.Update statistics after a significant number of rows are added or changed. Aggiornare, ad esempio, le statistiche dopo un carico.For example, update statistics after a load. Per altre informazioni, vedere Indicazioni sulle statistiche.For more information, see Statistics guidance.

Comandi per la creazione di tabelleCommands for creating tables

È possibile creare una tabella come nuova tabella vuota.You can create a table as a new empty table. È inoltre possibile creare e popolare una tabella con i risultati di un'istruzione SELECT.You can also create and populate a table with the results of a select statement. Di seguito sono riportati i comandi T-SQL per la creazione di una tabella.The following are the T-SQL commands for creating a table.

Istruzione T-SQLT-SQL Statement DescrizioneDescription
CREATE TABLECREATE TABLE Crea una tabella vuota definendo tutte le opzioni e le colonne della tabella.Creates an empty table by defining all the table columns and options.
CREATE EXTERNAL TABLECREATE EXTERNAL TABLE Crea una tabella esterna.Creates an external table. La definizione della tabella viene archiviata in SQL Data Warehouse.The definition of the table is stored in SQL Data Warehouse. I dati della tabella vengono archiviati nell'archivio BLOB di Azure o in 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 Popola una nuova tabella con i risultati di un'istruzione SELECT.Populates a new table with the results of a select statement. Le colonne e i tipi di dati della tabella si basano sui risultati dell'istruzione SELECT.The table columns and data types are based on the select statement results. Per importare i dati, questa istruzione può selezionare da una tabella esterna.To import data, this statement can select from an external table.
CREATE EXTERNAL TABLE AS SELECTCREATE EXTERNAL TABLE AS SELECT Crea una nuova tabella esterna esportando i risultati di un'istruzione SELECT in una posizione esterna,Creates a new external table by exporting the results of a select statement to an external location. vale a dire l'archivio BLOB di Azure o Azure Data Lake Store.The location is either Azure Blob storage or Azure Data Lake Store.

Allineamento dei dati di origine con il data warehouseAligning source data with the data warehouse

Le tabelle del data warehouse vengono popolate caricando i dati da un'altra origine dati.Data warehouse tables are populated by loading data from another data source. Per eseguire un caricamento corretto, il numero e i tipi di dati delle colonne nei dati di origine devono essere allineati con la definizione della tabella nel data warehouse.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. Il recupero dei dati da allineare potrebbe risultare l'operazione più difficile della progettazione delle tabelle.Getting the data to align might be the hardest part of designing your tables.

Se i dati provengono da più archivi dati, è possibile migrarli nel data warehouse e archiviarli in una tabella di integrazione.If data is coming from multiple data stores, you can bring the data into the data warehouse and store it in an integration table. Dopo che i dati sono stati inseriti nella tabella di integrazione, è possibile sfruttare la potenza di SQL Data Warehouse per eseguire operazioni di trasformazione.Once data is in the integration table, you can use the power of SQL Data Warehouse to perform transformation operations. Dopo aver preparati i dati, è possibile inserirli nelle tabelle di produzione.Once the data is prepared, you can insert it into production tables.

Funzionalità non supportate delle tabelleUnsupported table features

SQL Data Warehouse supporta molte delle funzionalità per tabelle offerte da altri database, ma non tutte.SQL Data Warehouse supports many, but not all, of the table features offered by other databases. Di seguito sono elencate alcune delle funzionalità per tabelle che non sono supportate in SQL Data Warehouse.The following list shows some of the table features that are not supported in SQL Data Warehouse.

Query di dimensioni della tabellaTable size queries

Un modo semplice per identificare lo spazio e le righe usati da una tabella in ognuna delle 60 distribuzioni consiste nell'usare 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');

Tuttavia, l'utilizzo dei comandi DBCC può essere abbastanza restrittivo.However, using DBCC commands can be quite limiting. Le viste a gestione dinamica (DMV) mostrano maggiori dettagli rispetto ai comandi DBCC.Dynamic management views (DMVs) show more detail than DBCC commands. Iniziare creando questa vista.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
;

Riepilogo dello spazio della tabellaTable space summary

Questa query restituisce le righe e lo spazio per singola tabella.This query returns the rows and space by table. Consente di vedere quali sono le tabelle più grandi e se si tratta di tabelle con distribuzione hash, replicate o round robin.It allows you to see which tables are your largest tables and whether they are round-robin, replicated, or hash -distributed. Per le tabelle con distribuzione hash, la query mostra la colonna di distribuzione.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
;

Spazio della tabella per tipo di distribuzioneTable 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
;

Spazio della tabella per tipo di indiceTable 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
;

Riepilogo dello spazio di distribuzioneDistribution 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
;

Passaggi successiviNext steps

Dopo avere creato le tabelle per il data warehouse, il passaggio successivo consiste nel caricare i dati nella tabella.After creating the tables for your data warehouse, the next step is to load data into the table. Per un'esercitazione sul caricamento, vedere Caricare dati in SQL Data Warehouse.For a loading tutorial, see Loading data to SQL Data Warehouse.