Panoramica delle tabelle in SQL Data WarehouseOverview of tables in SQL Data Warehouse

Iniziare a creare tabelle in SQL Data Warehouse è facile.Getting started with creating tables in SQL Data Warehouse is simple. La sintassi di base CREATE TABLE segue la sintassi comune che probabilmente è già nota perché usata in altri database.The basic CREATE TABLE syntax follows the common syntax you are most likely already familiar with from working with other databases. Per creare una tabella, è sufficiente assegnarle un nome, assegnare un nome alle colonne e definire i tipi di dati per ogni colonna.To create a table, you simply need to name your table, name your columns and define data types for each column. Se sono state create tabelle in altri database, si dovrebbe avere già familiarità con la procedura.If you've create tables in other databases, this should look very familiar to you.

CREATE TABLE Customers (FirstName VARCHAR(25), LastName VARCHAR(25))

Nell'esempio sopra riportato viene creata una tabella di nome Customers con due colonne: FirstName e LastName.The above example creates a table named Customers with two columns, FirstName and LastName. Ogni colonna è definita con un tipo di dati VARCHAR(25), che limita i dati a 25 caratteri.Each column is defined with a data type of VARCHAR(25), which limits the data to 25 characters. Questi e altri attributi fondamentali di una tabella sono praticamente identici a quelli di altri database.These fundamental attributes of a table, as well as others, are mostly the same as other databases. I tipi di dati vengono definiti per ogni colonna e garantiscono l'integrità dei dati.Data types are defined for each column and ensure the integrity of your data. È possibile aggiungere indici per aumentare le prestazioni riducendo l'I/O.Indexes can be added to improve performance by reducing I/O. È possibile aggiungere il partizionamento per migliorare le prestazioni quando è necessario modificare i dati.Partitioning can be added to improve performance when you need to modify data.

La ridenominazione di una tabella di SQL Data Warehouse sarà simile alle seguente:Renaming a SQL Data Warehouse table looks like this:

RENAME OBJECT Customer TO CustomerOrig; 

Tabelle con distribuzioneDistributed tables

Un nuovo attributo fondamentale introdotto da sistemi distribuiti come SQL Data Warehouse è la colonna di distribuzione.A new fundamental attribute introduced by distributed systems like SQL Data Warehouse is the distribution column. Il nome stesso è indicativo di cosa sia una colonna di distribuzione.The distribution column is very much what it sounds like. Si tratta della colonna che determina come distribuire, o dividere, i dati in background.It is the column that determines how to distribute, or divide, your data behind the scenes. Quando si crea una tabella senza specificare la colonna di distribuzione, la tabella viene automaticamente distribuita mediante round robin.When you create a table without specifying the distribution column, the table is automatically distributed using round robin. Sebbene le tabelle round robin possano essere sufficiente in alcuni scenari, definire le colonne di distribuzione può ridurre considerevolmente lo spostamento dei dati durante le query, ottimizzando così le prestazioni.While round robin tables can be sufficient in some scenarios, defining distribution columns can greatly reduce data movement during queries, thus optimizing performance. In situazioni in cui esiste una piccola quantità di dati in una tabella, scegliendo di creare la tabella con il tipo di distribuzione di replica si copiano i dati in ogni nodo di calcolo e si evita di spostare i dati in fase di esecuzione della query.In situations where there is a small amount of data in a table, choosing to create the table with the replicate distribution type copies data to each compute node and saves data movement at query execution time. Per altre informazioni su come selezionare una colonna di distribuzione, vedere Distribuzione di una tabella.See Distributing a Table to learn more about how to select a distribution column.

Indicizzazione e partizionamento delle tabelleIndexing and partitioning tables

Con l'acquisizione di maggiore esperienza nell'uso di SQL Data Warehouse e il desiderio di ottimizzare le prestazioni, l'utente vorrà trovare ulteriori informazioni sulla progettazione della tabella.As you become more advanced in using SQL Data Warehouse and want to optimize performance, you'll want to learn more about Table Design. Per altre informazioni, vedere gli articoli su tipi di dati di una tabella, distribuzione di una tabella, indicizzazione di una tabella e partizionamento di una tabella.To learn more, see the articles on Table Data Types, Distributing a Table, Indexing a Table and Partitioning a Table.

Statistiche della tabellaTable statistics

Le statistiche sono estremamente importanti per ottenere le migliori prestazioni da SQL Data Warehouse.Statistics are an extremely important to getting the best performance out of your SQL Data Warehouse. Poiché SQL Data Warehouse ancora non crea e non aggiorna automaticamente le statistiche per l'utente, come ci si potrebbe aspettare dal database SQL di Azure, l'articolo sulle statistiche potrebbe essere una delle fonti più importanti da cui imparare a ottenere prestazioni ottimali dalle query.Since SQL Data Warehouse does not yet automatically create and update statistics for you, like you may have come to expect in Azure SQL Database, reading our article on Statistics might be one of the most important articles you read to ensure that you get the best performance from your queries.

Tabelle temporaneeTemporary tables

Le tabelle temporanee sono tabelle che esistono solo per la durata dell'accesso e che non possono essere visualizzate da altri utenti.Temporary tables are tables which only exist for the duration of your logon and cannot be seen by other users. Le tabelle temporanee possono essere un ottimo modo per impedire ad altri utenti di visualizzare i risultati temporanei e per ridurre la necessità di pulizia.Temporary tables can be a good way to prevent others from seeing temporary results and also 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 sulle tabelle temporanee, vedere l'articolo Tabelle temporanee in SQL Data Warehouse.See the Temporary Table articles for more details about temporary tables.

Tabelle esterneExternal tables

Le tabelle esterne, note anche come tabelle Polybase, sono tabelle in cui è possibile eseguire query da SQL Data Warehouse, ma che puntano a dati esterni da SQL Data Warehouse.External tables, also known as Polybase tables, are tables which can be queried from SQL Data Warehouse, but point to data external from SQL Data Warehouse. Ad esempio, è possibile creare una tabella esterna che punta ai file nell'archiviazione BLOB di Azure.For example, you can create an external table which points to files on Azure Blob Storage. Per altre informazioni su come creare ed eseguire query in una tabella esterna, vedere Caricare dati con Polybase.For more details on how to create and query an external table, see Load data with Polybase.

Funzionalità non supportate delle tabelleUnsupported table features

Mentre SQL Data Warehouse contiene molte delle stesse funzionalità delle tabelle offerte da altri database, esistono alcune funzionalità che non sono ancora supportate.While SQL Data Warehouse contains many of the same table features offered by other databases, there are some features which are not yet supported. Di seguito è riportato un elenco di alcune funzionalità non ancora supportate.Below is a list of some of the table features which are not yet supported.

Funzionalità non supportateUnsupported features
Vincoli di tabella Primary key, Foreign key, Unique e CheckPrimary key, Foreign keys, Unique and Check Table Constraints
Indici univociUnique Indexes
Colonne calcolateComputed Columns
Colonne di tipo sparseSparse Columns
Tipi definiti dall'utenteUser-Defined Types
SequenzaSequence
TriggerTriggers
Viste indicizzateIndexed Views
SinonimiSynonyms

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) consentono di visualizzare molti più dettagli, nonché di fornire un controllo di gran lunga superiore sui risultati della query.Dynamic management views (DMVs) will allow you to see much more detail as well as give you much greater control over the query results. Per iniziare, creare questa vista, a cui si farà riferimento in molti esempi di questo e di altri articoli.Start by creating this view, which will be referred to by many of our examples in this and other articles.

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. È una query molto utile per verificare quali sono le tabelle più grandi e se sono con distribuzione hash, replicata o round robin.It is a great query to see which tables are your largest tables and whether they are round robin, replicated or hash distributed. Per le tabelle con distribuzione hash viene mostrata anche la colonna di distribuzione.For hash distributed tables it also shows the distribution column. Nella maggior parte dei casi le tabelle più grandi devono essere con distribuzione hash e avere un indice columnstore cluster.In most cases your largest tables should be hash distributed with a clustered columnstore index.

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

Per altre informazioni, vedere gli articoli su tipi di dati di una tabella, distribuzione di una tabella, indicizzazione di una tabella, partizionamento di una tabella, gestione delle statistiche di una tabella e tabelle temporanee.To learn more, see the articles on Table Data Types, Distributing a Table, Indexing a Table, Partitioning a Table, Maintaining Table Statistics and Temporary Tables. Per altre informazioni sulle procedure consigliate, vedere Procedure consigliate per SQL Data Warehouse.For more about best practices, see SQL Data Warehouse Best Practices.