Progettare tabelle con un pool SQL dedicato in Azure sinapsi AnalyticsDesign tables using dedicated SQL pool in Azure Synapse Analytics

Questo articolo fornisce i principali concetti introduttivi per la progettazione di tabelle in un pool SQL dedicato.This article provides key introductory concepts for designing tables in dedicated SQL pool.

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 dei fatti contengono dati quantitativi che vengono comunemente generati in un sistema transazionale e quindi caricati nel pool SQL dedicato.Fact tables contain quantitative data that are commonly generated in a transactional system, and then loaded into the dedicated SQL pool. Ad esempio, un'azienda di vendita al dettaglio genera transazioni di vendita ogni giorno e quindi carica i dati in una tabella dei fatti del pool SQL dedicata per l'analisi.For example, a retail business generates sales transactions every day, and then loads the data into a dedicated SQL pool 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 dei fatti di grandi dimensioni, non è necessario che il nome e l'indirizzo del cliente si trovino in ogni riga di una tabella dei fatti.To minimize the size of a large fact table, the customer's name and address don't 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

Gli schemi sono un metodo efficace per raggruppare le tabelle, utilizzate in modo analogo, insieme.Schemas are a good way to group tables, used in a similar fashion, together. Se si esegue la migrazione di più database da una soluzione locale a un pool SQL dedicato, è consigliabile eseguire la migrazione di tutte le tabelle dei fatti, delle dimensioni e di integrazione in uno schema in un pool SQL dedicato.If you're migrating multiple databases from an on-prem solution to a dedicated SQL pool, it works best to migrate all of the fact, dimension, and integration tables to one schema in a dedicated SQL pool.

È possibile, ad esempio, archiviare tutte le tabelle nel pool SQL dedicato di esempio WideWorldImportersDW all'interno di uno schema chiamato "prima guerra".For example, you could store all the tables in the WideWorldImportersDW sample dedicated SQL pool within one schema called wwi. Il codice seguente crea uno schema definito dall'utente denominato "prima guerra".The following code creates a user-defined schema called wwi.

CREATE SCHEMA wwi;

Per visualizzare l'organizzazione delle tabelle nel pool SQL dedicato, è possibile utilizzare fact, Dim e int come prefissi dei nomi delle tabelle.To show the organization of the tables in dedicated SQL pool, 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.

Tabella WideWorldImportersDWWideWorldImportersDW table Tipo di tabella.Table type Pool SQL dedicatoDedicated SQL pool
CityCity DimensionDimension wwi.DimCitywwi.DimCity
JSONOrder FactFact wwi.FactOrderwwi.FactOrder

Persistenza delle tabelleTable persistence

Le tabelle archiviano i dati in modo permanente in archiviazione di Azure, temporaneamente in archiviazione di Azure o in un archivio dati esterno a un pool SQL dedicato.Tables store data either permanently in Azure Storage, temporarily in Azure Storage, or in a data store external to dedicated SQL pool.

Tabella normaleRegular table

Una tabella regolare archivia i dati in archiviazione di Azure come parte del pool SQL dedicato.A regular table stores data in Azure Storage as part of dedicated SQL pool. 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. Nell'esempio seguente viene creata una tabella normale con due colonne.The following 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. È possibile utilizzare una tabella temporanea per impedire ad altri utenti di visualizzare i risultati temporanei e anche di ridurre la necessità di pulizia.You can use a temporary table to prevent other users from seeing temporary results and also to reduce the need for cleanup.

Le tabelle temporanee utilizzano l'archiviazione locale per offrire prestazioni elevate.Temporary tables utilize local storage to offer fast performance. 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 usato in combinazione con l'istruzione SELECT CREATE TABLE, la selezione da una tabella esterna importa i dati in un pool SQL dedicato.When used in conjunction with the CREATE TABLE AS SELECT statement, selecting from an external table imports data into dedicated SQL pool.

Di conseguenza, le tabelle esterne sono utili per il caricamento dei dati.As such, external tables are useful for loading data. Per un'esercitazione sul caricamento, vedere usare la polibase per caricare dati dall'archivio BLOB di Azure.For a loading tutorial, see Use PolyBase to load data from Azure blob storage.

Tipi di datiData types

Il pool SQL dedicato supporta i tipi di dati usati più di frequente.Dedicated SQL pool 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. 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 funzionalità fondamentale del pool SQL dedicato è il modo in cui è possibile archiviare e operare sulle tabelle tra le distribuzioni.A fundamental feature of dedicated SQL pool is the way it can store and operate on tables across distributions. Il pool SQL dedicato supporta tre metodi per la distribuzione dei dati: Round Robin (impostazione predefinita), hash e replicati.Dedicated SQL pool supports three methods for distributing data: round-robin (default), hash and replicated.

Tabelle con distribuzione hashHash-distributed tables

Una tabella con distribuzione hash distribuisce le righe in base al valore nella colonna di distribuzione.A hash distributed table distributes rows based on the value in the distribution column. Una tabella con distribuzione hash è progettata per ottenere prestazioni elevate per le query su tabelle di grandi dimensioni.A hash distributed table is designed to achieve high performance for queries on large tables. Quando si sceglie una colonna di distribuzione, è necessario considerare diversi fattori.There are several factors to consider when choosing a 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 vengono eseguite rapidamente nelle tabelle replicate poiché i join nelle tabelle replicate non richiedono lo spostamento dei dati.Queries run fast on replicated tables since joins on replicated tables don't require data movement. La replica richiede comunque ulteriore spazio di archiviazione e non è pratica per tabelle di grandi dimensioni.Replication requires extra storage, though, and isn't 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. Tenere presente che le query possono richiedere un maggiore spostamento dei dati rispetto agli altri metodi di distribuzione.Keep in mind that 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. Una volta che i dati sono presenti nella tabella di staging, usare INSERT... Selezionare questa finestra per spostare i dati nelle tabelle di produzione.Once the data is in the staging table, use INSERT...SELECT to move the data to 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 Azure sinapsi Analytics sono già distribuiti, un numero eccessivo di partizioni può rallentare le prestazioni delle query.Since the data in Azure Synapse Analytics is already distributed, too many partitions can slow query performance. Per altre informazioni, vedere Indicazioni sul partizionamento.For more information, see Partitioning guidance. Quando la partizione passa a partizioni di tabella non vuote, è consigliabile utilizzare l'opzione TRUNCATE_TARGET nell'istruzione ALTER TABLE se i dati esistenti devono essere troncati.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. Il codice seguente passa i dati giornalieri trasformati in SalesFact sovrascrivendo i dati esistenti.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);  

Indici columnstoreColumnstore indexes

Per impostazione predefinita, il pool SQL dedicato archivia una tabella come indice columnstore cluster.By default, dedicated SQL pool 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.

Suggerimento

Una tabella heap può essere particolarmente utile per il caricamento di dati temporanei, ad esempio una tabella di staging, che viene trasformata in una tabella finale.A heap table can be especially useful for loading transient data, such as a staging table which is transformed into a final table.

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 avere statistiche sulle singole colonne, in particolare sulle colonne utilizzate nei join di query.To improve query performance, it's important to have statistics on individual columns, especially columns used in query joins. La creazione di statistiche viene eseguita automaticamente.Creating statistics happens automatically.

L'aggiornamento delle statistiche non avviene automaticamente.Updating statistics doesn't happen automatically. 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.

Chiave primaria e chiave univocaPrimary key and unique key

La chiave primaria è supportata solo se vengono usati entrambi non CLUSTER e non applicati.PRIMARY KEY is only supported when NONCLUSTERED and NOT ENFORCED are both used. Il vincolo UNIQUE è supportato solo se viene usato non applicato.UNIQUE constraint is only supported with NOT ENFORCED is used. Controllare i vincoli di tabella del pool SQL dedicati.Check Dedicated SQL pool table constraints.

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 è archiviata in un pool SQL dedicato.The definition of the table is stored in dedicated SQL pool. 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 pool SQL dedicatoAligning source data with dedicated SQL pool

Le tabelle del pool SQL dedicate vengono popolate caricando i dati da un'altra origine dati.Dedicated SQL pool tables are populated by loading data from another data source. Per eseguire correttamente il caricamento, il numero e i tipi di dati delle colonne nei dati di origine devono essere allineati con la definizione della tabella nel pool SQL dedicato.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 dedicated SQL pool. 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, caricare i dati nel pool SQL dedicato e archiviarli in una tabella di integrazione.If data is coming from multiple data stores, you load the data into the dedicated SQL pool and store it in an integration table. Una volta che i dati si trovino nella tabella di integrazione, è possibile usare la potenza del pool SQL dedicato per eseguire operazioni di trasformazione.Once data is in the integration table, you can use the power of dedicated SQL pool 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

Il pool SQL dedicato supporta molte, ma non tutte, le funzionalità della tabella offerte da altri database.Dedicated SQL pool supports many, but not all, of the table features offered by other databases. Nell'elenco seguente vengono illustrate alcune delle funzionalità della tabella che non sono supportate nel pool SQL dedicato:The following list shows some of the table features that aren't supported in dedicated SQL pool:

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 visualizzazione: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]
WHERE pn.[type] = 'COMPUTE'
)
, 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 tabelle sono le tabelle più grandi e se sono Round Robin, replicate o con distribuzione hash.It allows you to see which tables are your largest tables and whether they're 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 aver creato le tabelle per il pool SQL dedicato, il passaggio successivo consiste nel caricare i dati nella tabella.After creating the tables for your dedicated SQL pool, the next step is to load data into the table. Per un'esercitazione sul caricamento, vedere caricamento di dati in un pool SQL dedicato.For a loading tutorial, see Loading data to dedicated SQL pool.