Criação de tabelas no SQL Data Warehouse do AzureDesigning tables in Azure SQL Data Warehouse

Aprenda os conceitos principais para a criação de tabelas no SQL Data Warehouse do Azure.Learn key concepts for designing tables in Azure SQL Data Warehouse.

Determinar a categoria da tabelaDetermine table category

Um esquema em estrela organiza dados em tabelas de fatos e dimensões.A star schema organizes data into fact and dimension tables. Algumas tabelas são usadas para dados de integração ou de preparo antes de movê-las para uma tabela de fatos ou dimensões.Some tables are used for integration or staging data before it moves to a fact or dimension table. Ao criar uma tabela, decida se os dados da tabela pertencem a uma tabela de integração, de dimensão ou de fato.As you design a table, decide whether the table data belongs in a fact, dimension, or integration table. Essa decisão informa a distribuição e a estrutura da tabela apropriadas.This decision informs the appropriate table structure and distribution.

  • As Tabelas de fatos contêm dados quantitativos normalmente gerados em um sistema transacional e, depois, carregados no data warehouse.Fact tables contain quantitative data that are commonly generated in a transactional system, and then loaded into the data warehouse. Por exemplo, uma empresa de varejo gera transações de vendas todos os dias e, em seguida, carrega os dados para uma tabela de fatos do data warehouse para análise.For example, a retail business generates sales transactions every day, and then loads the data into a data warehouse fact table for analysis.

  • As Tabelas de dimensões contêm dados de atributo que podem ser alterados, mas essas alterações são raras.Dimension tables contain attribute data that might change but usually changes infrequently. Por exemplo, um nome e endereço do cliente são armazenados em uma tabela de dimensões e atualizados somente quando o perfil do cliente é alterado.For example, a customer's name and address are stored in a dimension table and updated only when the customer's profile changes. Para minimizar o tamanho de uma tabela de fatos grande, não deixe o nome e o endereço do cliente em todas as linhas de uma tabela de fatos.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. Em vez disso, a tabela de fatos e a tabela de dimensões podem compartilhar uma ID do cliente.Instead, the fact table and the dimension table can share a customer ID. Uma consulta pode unir as duas tabelas para associar o perfil e as transações de um cliente.A query can join the two tables to associate a customer's profile and transactions.

  • As Tabelas de integrações oferecem um local para dados de preparo ou integração.Integration tables provide a place for integrating or staging data. Você pode criar uma tabela de integração como uma tabela regular, uma tabela externa ou uma tabela temporária.You can create an integration table as a regular table, an external table, or a temporary table. Por exemplo, é possível carregar dados em uma tabela de preparo, executar transformações nos dados de preparo e, em seguida, inserir os dados em uma tabela de produção.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.

Nomes de tabelas e esquemasSchema and table names

Os esquemas são uma boa maneira de agrupar tabelas, usadas de maneira semelhante, em conjunto.Schemas are a good way to group tables, used in a similar fashion, together. Se você estiver migrando vários bancos de dados de uma solução local para SQL Data Warehouse, funcionará melhor migrar todas as tabelas de fatos, dimensões e integração para um esquema no 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. Por exemplo, você pode armazenar todas as tabelas do data warehouse de exemplo WideWorldImportersDW em um esquema chamado wwi.For example, you could store all the tables in the WideWorldImportersDW sample data warehouse within one schema called wwi. O código a seguir cria um esquema definido pelo usuário chamado wwi.The following code creates a user-defined schema called wwi.

CREATE SCHEMA wwi;

Para mostrar a organização das tabelas no SQL Data Warehouse, você pode usar fact, dim e int como prefixos para os nomes das tabelas.To show the organization of the tables in SQL Data Warehouse, you could use fact, dim, and int as prefixes to the table names. A tabela a seguir mostra alguns dos nomes de tabelas e esquema para WideWorldImportersDW.The following table shows some of the schema and table names for WideWorldImportersDW.

WideWorldImportersDW tableWideWorldImportersDW table Tipo de tabelaTable type SQL Data WarehouseSQL Data Warehouse
CityCity DimensãoDimension wwi.DimCitywwi.DimCity
ClassificarOrder FatoFact wwi.FactOrderwwi.FactOrder

Persistência da tabelaTable persistence

As tabelas armazenam dados permanentemente no Armazenamento do Microsoft Azure, temporariamente no Armazenamento do Microsoft Azure, ou em um armazenamento de dados externo para data warehouse.Tables store data either permanently in Azure Storage, temporarily in Azure Storage, or in a data store external to data warehouse.

Tabela regularRegular table

Uma tabela regular armazena dados no Armazenamento do Microsoft Azure como parte do data warehouse.A regular table stores data in Azure Storage as part of the data warehouse. A tabela e os dados persistem independentemente se há uma sessão aberta.The table and the data persist regardless of whether a session is open. Este exemplo cria uma tabela regular com duas colunas.This example creates a regular table with two columns.

CREATE TABLE MyTable (col1 int, col2 int );  

Tabela temporáriaTemporary table

Uma tabela temporária só existe durante a sessão.A temporary table only exists for the duration of the session. Você pode usar uma tabela temporária para impedir que outros usuários vejam resultados temporários e também para reduzir a necessidade de limpeza.You can use a temporary table to prevent other users from seeing temporary results and also to reduce the need for cleanup. As tabelas temporárias utilizam o armazenamento local para oferecer um desempenho rápido.Temporary tables utilize local storage to offer fast performance. Para obter mais informações, confira Tabelas temporárias.For more information, see Temporary tables.

Tabela externaExternal table

Uma tabela externa aponta para dados localizados no Azure Storage Blob ou Azure Data Lake Store.An external table points to data located in Azure Storage blob or Azure Data Lake Store. Quando usada em conjunto com a instrução CREATE TABLE AS SELECT, selecionar a partir de uma tabela externa importa dados no 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. Ou seja, as tabelas externas são úteis para carregar dados.External tables are therefore useful for loading data. Para ver um tutorial de carregamento, confira Usar o PolyBase para carregar dados do Armazenamento de Blobs do Azure.For a loading tutorial, see Use PolyBase to load data from Azure blob storage.

Tipos de dadosData types

O SQL Data Warehouse oferece suporte aos tipos comuns de dados usados.SQL Data Warehouse supports the most commonly used data types. Para obter uma lista dos tipos de dados com suporte, consulte tipos de dados na referência CREATE TABLE na instrução CREATE TABLE.For a list of the supported data types, see data types in CREATE TABLE reference in the CREATE TABLE statement. Para obter diretrizes sobre o uso dos tipos de dados, consulte Tipos de dados.For guidance on using data types, see Data types.

Tabelas distribuídasDistributed tables

Um recurso fundamental do SQL Data Warehouse é a maneira como ele pode armazenar e operar em tabelas entre distribuições.A fundamental feature of SQL Data Warehouse is the way it can store and operate on tables across distributions. O SQL Data Warehouse dá suporte a três métodos de distribuição de dados, Round-Robin (padrão), hash e replicados.SQL Data Warehouse supports three methods for distributing data, round-robin (default), hash and replicated.

Tabelas distribuídas em hashHash-distributed tables

Uma tabela distribuída por hash distribui linhas com base no valor na coluna de distribuição.A hash distributed table distributes rows based on the value in the distribution column. Uma tabela distribuída por hash foi projetada para alcançar alto desempenho para consultas em tabelas grandes.A hash distributed table is designed to achieve high performance for queries on large tables. Há vários fatores a serem considerados ao escolher uma coluna de distribuição.There are several factors to consider when choosing a distribution column.

Para obter mais informações, consulte Criação de diretrizes para tabelas distribuídas.For more information, see Design guidance for distributed tables.

Tabelas replicadasReplicated tables

Uma tabela replicada possui uma cópia completa da tabela disponível em cada nó de Computação.A replicated table has a full copy of the table available on every Compute node. Consultas de execução rápida em tabelas replicadas como junções em tabelas replicadas não exigem a movimentação de dados.Queries run fast on replicated tables since joins on replicated tables do not require data movement. No entanto, a replicação exige armazenamento extra e não é prática para tabelas grandes.Replication requires extra storage, though, and is not practical for large tables.

Para obter mais informações, confira Criação de diretrizes para tabelas replicadas.For more information, see Design guidance for replicated tables.

Tabelas round robinRound-robin tables

Uma tabela round robin distribui linhas de tabela uniformemente em todas as distribuições.A round-robin table distributes table rows evenly across all distributions. As linhas são distribuídas aleatoriamente.The rows are distributed randomly. Carregar dados em uma tabela round robin é rápido.Loading data into a round-robin table is fast. No entanto, as consultas podem exigir mais movimentação de dados que os outros métodos de distribuição.However, queries can require more data movement than the other distribution methods.

Para obter mais informações, consulte Criação de diretrizes para tabelas distribuídas.For more information, see Design guidance for distributed tables.

Métodos de distribuição comuns para tabelasCommon distribution methods for tables

A categoria da tabela geralmente determina qual opção escolher para a distribuição da tabela.The table category often determines which option to choose for distributing the table.

Categoria de tabelaTable category Opção de distribuição recomendadaRecommended distribution option
FatoFact Use a distribuição de hash com índice columnstore clusterizado.Use hash-distribution with clustered columnstore index. O desempenho melhora quando duas tabelas de hash são unidas na mesma coluna de distribuição.Performance improves when two hash tables are joined on the same distribution column.
DimensãoDimension Use a replicada para tabelas menores.Use replicated for smaller tables. Se as tabelas forem grandes demais para serem armazenadas em cada nó de computação, use a distribuição de hash.If tables are too large to store on each Compute node, use hash-distributed.
StagingStaging Use um round robin para a tabela de preparo.Use round-robin for the staging table. A carga com CTAS é rápida.The load with CTAS is fast. Depois que os dados estiverem na tabela de preparo, use INSERT... Selecione para mover os dados para tabelas de produção.Once the data is in the staging table, use INSERT...SELECT to move the data to production tables.

Partições de tabelaTable partitions

Uma tabela particionada armazena e executa operações nas linhas da tabela de acordo com os intervalos de dados.A partitioned table stores and performs operations on the table rows according to data ranges. Por exemplo, uma tabela pode ser particionada por dia, mês ou ano.For example, a table could be partitioned by day, month, or year. Você pode melhorar o desempenho de consultas através da eliminação da partição, o que limita a verificação de uma consulta para dados dentro de uma partição.You can improve query performance through partition elimination, which limits a query scan to data within a partition. Você também pode manter os dados por meio de alternância de partição.You can also maintain the data through partition switching. Como os dados no SQL Data Warehouse já foram distribuídos, um número excessivo de partições pode diminuir o desempenho da consulta.Since the data in SQL Data Warehouse is already distributed, too many partitions can slow query performance. Para saber mais informações, confira Diretrizes de particionamento.For more information, see Partitioning guidance. Quando a partição muda para partições de tabela que não estão vazias, considere usar a opção TRUNCATE_TARGET na instrução ALTER TABLE se os dados existentes forem truncados.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. O código abaixo alterna os dados diários transformados para o SalesFact, substituindo os dados existentes.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);  

Índices ColumnStoreColumnstore indexes

Por padrão, o SQL Data Warehouse armazena uma tabela como um índice columnstore clusterizado.By default, SQL Data Warehouse stores a table as a clustered columnstore index. Essa forma de armazenamento de dados atinge a alta compactação de dados e o desempenho de consultas em tabelas grandes.This form of data storage achieves high data compression and query performance on large tables. Normalmente, o índice columnstore clusterizado é a melhor opção, mas existem alguns casos onde um índice clusterizado ou um heap são estruturas de armazenamento mais adequadas.The clustered columnstore index is usually the best choice, but in some cases a clustered index or a heap is the appropriate storage structure. Uma tabela de heap pode ser especialmente útil para carregar dados transitórios, como uma tabela de preparo que é transformada em uma tabela final.A heap table can be especially useful for loading transient data, such as a staging table which is transformed into a final table.

Para obter uma lista de recursos columnstore, confira Quais são as novidades dos índices columnstores.For a list of columnstore features, see What's new for columnstore indexes. Para melhorar o desempenho do índice columnstore, confira Como maximizar a qualidade do rowgroup para índices columnstore.To improve columnstore index performance, see Maximizing rowgroup quality for columnstore indexes.

EstatísticasStatistics

O otimizador de consulta usa estatísticas de nível de coluna quando cria o plano para executar uma consulta.The query optimizer uses column-level statistics when it creates the plan for executing a query. Para melhorar o desempenho da consulta, é importante ter estatísticas em colunas individuais, especialmente colunas usadas em junções de consulta.To improve query performance, it's important to have statistics on individual columns, especially columns used in query joins. A criação de estatísticas ocorre automaticamente.Creating statistics happens automatically. No entanto, a atualização de estatísticas não ocorre automaticamente.However, updating statistics does not happen automatically. Atualize as estatísticas depois que um número significativo de linhas for adicionado ou alterado.Update statistics after a significant number of rows are added or changed. Por exemplo, atualize as estatísticas depois de uma carga.For example, update statistics after a load. Para obter mais informações, confira Diretrizes sobre estatísticas.For more information, see Statistics guidance.

Chave primária e chave exclusivaPrimary key and unique key

Só há suporte para a chave primária quando não CLUSTERIZAdo e não imposto são usados.PRIMARY KEY is only supported when NONCLUSTERED and NOT ENFORCED are both used. Só há suporte para a restrição UNIQUE quando não imposta é usado.UNIQUE constraint is only supported with NOT ENFORCED is used. Verifique SQL data warehouse restrições de tabela.Check SQL Data Warehouse Table Constraints.

Comandos para a criação de tabelasCommands for creating tables

Você pode criar uma tabela como uma nova tabela vazia.You can create a table as a new empty table. Você também pode criar e popular uma tabela com os resultados de uma instrução de seleção.You can also create and populate a table with the results of a select statement. A seguir estão os comandos T-SQL para criar uma tabela.The following are the T-SQL commands for creating a table.

Instruções T-SQLT-SQL Statement DESCRIÇÃODescription
CREATE TABLECREATE TABLE Cria uma tabela vazia com a definição de todas as opções e colunas da tabela.Creates an empty table by defining all the table columns and options.
CREATE EXTERNAL TABLECREATE EXTERNAL TABLE Cria uma tabela externa.Creates an external table. A definição da tabela é armazenada no SQL Data Warehouse.The definition of the table is stored in SQL Data Warehouse. Os dados da tabela são armazenados no Armazenamento de Blobs do Azure ou do 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 Popula uma tabela nova com os resultados de uma instrução selecionada.Populates a new table with the results of a select statement. Os tipos de dados e colunas de tabela baseiam-se nos resultados da instrução selecionada.The table columns and data types are based on the select statement results. Para importar dados, essa instrução pode selecionar de uma tabela externa.To import data, this statement can select from an external table.
CREATE EXTERNAL TABLE AS SELECTCREATE EXTERNAL TABLE AS SELECT Cria uma tabela externa nova exportando os resultados de uma instrução selecionada para um local externo.Creates a new external table by exporting the results of a select statement to an external location. O local é o armazenamento de Blobs do Azure ou o Azure Data Lake Store.The location is either Azure Blob storage or Azure Data Lake Store.

Como alinhar dados de origem com o data warehouseAligning source data with the data warehouse

As tabelas do data warehouse são populadas pelo carregamento de dados de outra fonte de dados.Data warehouse tables are populated by loading data from another data source. Para executar um carregamento bem-sucedido, os números e os tipos de dados das colunas na fonte de dados devem se alinhar com a definição da tabela no 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. Obter os dados para alinhar pode ser a parte mais difícil da criação de tabelas.Getting the data to align might be the hardest part of designing your tables.

Se os dados são provenientes de vários armazenamentos de dados, você pode trazer os dados para o data warehouse e armazená-los em uma tabela de integração.If data is coming from multiple data stores, you can bring the data into the data warehouse and store it in an integration table. Quando os dados estão na tabela de integração, você pode usar a potência do SQL Data Warehouse para executar operações de transformação.Once data is in the integration table, you can use the power of SQL Data Warehouse to perform transformation operations. Quando os dados estiverem preparados, será possível inseri-los nas tabelas de produção.Once the data is prepared, you can insert it into production tables.

Recursos da tabela sem suporteUnsupported table features

O SQL Data Warehouse oferece suporte a muitos, mas não a todos, os recursos de tabela oferecidos por outros bancos de dados.SQL Data Warehouse supports many, but not all, of the table features offered by other databases. A lista a seguir mostra alguns dos recursos de tabela que não têm suporte no SQL Data Warehouse.The following list shows some of the table features that are not supported in SQL Data Warehouse.

Consultas do tamanho da tabelaTable size queries

Uma maneira simples de identificar o espaço e as linhas consumidas por uma tabela em cada uma das 60 distribuições é usar 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');

No entanto, usar comandos DBCC pode ser bastante limitado.However, using DBCC commands can be quite limiting. Exibições de gerenciamento dinâmico (DMVs) mostram mais detalhes que os comandos DBCC.Dynamic management views (DMVs) show more detail than DBCC commands. Comece criando essa exibição.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
;

Resumo do espaço da tabelaTable space summary

Esta consulta retorna as linhas e o espaço por tabela.This query returns the rows and space by table. E permite que você veja quais são as tabelas maiores e se elas são distribuídas em hash, round robin ou replicadas.It allows you to see which tables are your largest tables and whether they are round-robin, replicated, or hash -distributed. Nas tabelas distribuídas em hash, a consulta exibe a coluna de distribuição.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
;

Espaço da tabela pelo tipo de distribuiçãoTable 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
;

Espaço da tabela pelo tipo de índiceTable 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
;

Resumo do espaço de distribuiçãoDistribution 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
;

Próximas etapasNext steps

Depois de criar as tabelas para o data warehouse, a próxima etapa é carregar dados na tabela.After creating the tables for your data warehouse, the next step is to load data into the table. Para obter um tutorial de carregamento, consulte Carregamento de dados no SQL Data Warehouse.For a loading tutorial, see Loading data to SQL Data Warehouse.