Diseño de tablas mediante un grupo de SQL dedicado en Azure Synapse AnalyticsDesign tables using dedicated SQL pool in Azure Synapse Analytics

En este artículo se proporcionan conceptos introductorios clave para el diseño de tablas en el grupo de SQL dedicado.This article provides key introductory concepts for designing tables in dedicated SQL pool.

Determinación de la categoría de tablaDetermine table category

Un esquema de estrella organiza los datos en tablas de hechos y dimensiones.A star schema organizes data into fact and dimension tables. Algunas tablas se utilizan para datos de integración o de almacenamiento provisional antes de que se pasen a una tabla de hechos o dimensiones.Some tables are used for integration or staging data before it moves to a fact or dimension table. Al diseñar una tabla, decidirá si los datos de la misma pertenecen a una tabla de hechos, dimensiones o integración.As you design a table, decide whether the table data belongs in a fact, dimension, or integration table. Esta decisión informa de la distribución y estructura de tabla adecuadas.This decision informs the appropriate table structure and distribution.

  • Las tablas de hechos contienen datos cuantitativos que se suelen generar en un sistema transaccional y, después, se cargan en el grupo de SQL dedicado.Fact tables contain quantitative data that are commonly generated in a transactional system, and then loaded into the dedicated SQL pool. Por ejemplo, una empresa minorista genera transacciones de ventas todos los días y, después, carga los datos en una tabla de hechos en el grupo de SQL dedicado para su análisis.For example, a retail business generates sales transactions every day, and then loads the data into a dedicated SQL pool fact table for analysis.

  • Las tablas de dimensiones contienen datos de atributos que pueden cambiar, pero normalmente no cambian con frecuencia.Dimension tables contain attribute data that might change but usually changes infrequently. Por ejemplo, el nombre y la dirección de un cliente se almacenan en una tabla de dimensiones y solo se actualizan cuando el perfil del cliente cambia.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 el tamaño de una tabla de hechos de gran tamaño, el nombre y la dirección del cliente no necesitan estar en todas las filas de una tabla de hechos.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. En su lugar, la tabla de hechos y la tabla de dimensiones pueden compartir un identificador de cliente.Instead, the fact table and the dimension table can share a customer ID. Una consulta puede combinar las dos tablas para asociar el perfil y las transacciones de un cliente.A query can join the two tables to associate a customer's profile and transactions.

  • Las tablas de integración proporcionan un lugar para integración o almacenamiento provisional de datos.Integration tables provide a place for integrating or staging data. Puede crear una tabla de integración como una tabla normal, una tabla externa o una tabla temporal.You can create an integration table as a regular table, an external table, or a temporary table. Por ejemplo, puede cargar datos a una tabla de almacenamiento provisional, realizar transformaciones en los datos en el almacenamiento provisional y luego insertar dichos datos en una tabla de producción.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.

Nombres de esquema y tablaSchema and table names

Los esquemas son una buena manera de agrupar tablas que se usan de manera similar.Schemas are a good way to group tables, used in a similar fashion, together. Si está migrando varias bases de datos de una solución local al grupo de SQL dedicado, lo mejor es migrar todas las tablas de hechos, dimensiones e integración a un esquema del grupo de SQL dedicado.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.

Por ejemplo, podría almacenar todas las tablas en el grupo de SQL dedicado de ejemplo WideWorldImportersDW dentro de un esquema denominado wwi.For example, you could store all the tables in the WideWorldImportersDW sample dedicated SQL pool within one schema called wwi. El siguiente código crea un esquema definido por el usuario denominado wwi.The following code creates a user-defined schema called wwi.

CREATE SCHEMA wwi;

Para mostrar la organización de las tablas en el grupo de SQL dedicado, puede utilizar fact, dim e int como prefijos para los nombres de tabla.To show the organization of the tables in dedicated SQL pool, you could use fact, dim, and int as prefixes to the table names. En la tabla siguiente se muestran algunos de los nombres de esquema y tabla para WideWorldImportersDW.The following table shows some of the schema and table names for WideWorldImportersDW.

Tabla WideWorldImportersDWWideWorldImportersDW table Tipo de tabla.Table type Grupo de SQL dedicadoDedicated SQL pool
CityCity DimensiónDimension wwi.DimCitywwi.DimCity
Pedido deOrder FactFact wwi.FactOrderwwi.FactOrder

Persistencia de tablaTable persistence

Las tablas almacenan datos de manera permanente en Azure Storage, temporalmente en Azure Storage o en un almacén de datos externo al grupo de SQL dedicado.Tables store data either permanently in Azure Storage, temporarily in Azure Storage, or in a data store external to dedicated SQL pool.

Tabla normalRegular table

Una tabla normal almacena datos en Azure Storage como parte del grupo de SQL dedicado.A regular table stores data in Azure Storage as part of dedicated SQL pool. La tabla y los datos persisten, independientemente de si hay una sesión abierta.The table and the data persist regardless of whether a session is open. En el ejemplo siguiente se crea una tabla normal con dos columnas.The following example creates a regular table with two columns.

CREATE TABLE MyTable (col1 int, col2 int );  

Tabla temporalTemporary table

Una tabla temporal solo existe mientras dura la sesión.A temporary table only exists for the duration of the session. Una tabla temporal se puede usar para evitar que otros usuarios vean los resultados temporales y también para reducir la necesidad de limpieza.You can use a temporary table to prevent other users from seeing temporary results and also to reduce the need for cleanup.

Las tablas temporales usan el almacenamiento local para ofrecer un rendimiento más rápido.Temporary tables utilize local storage to offer fast performance. Para más información, consulte Tablas temporales.For more information, see Temporary tables.

Tabla externaExternal table

Una tabla externa apunta a datos ubicados en Azure Storage Blob o Azure Data Lake Store.An external table points to data located in Azure Storage blob or Azure Data Lake Store. Cuando se utiliza en combinación con la instrucción CREATE TABLE AS SELECT, la selección de una tabla externa importa datos en el grupo de SQL dedicado.When used in conjunction with the CREATE TABLE AS SELECT statement, selecting from an external table imports data into dedicated SQL pool.

Por este motivo, las tablas externas son útiles para cargar datos.As such, external tables are useful for loading data. Para un tutorial sobre la carga, consulte Uso de PolyBase para cargar datos de Azure Blob Storage en Azure SQL Data Warehouse.For a loading tutorial, see Use PolyBase to load data from Azure blob storage.

Tipos de datosData types

El grupo de SQL dedicado admite los tipos de datos usados más comúnmente.Dedicated SQL pool supports the most commonly used data types. Para obtener una lista de los tipos de datos admitidos, consulte los tipos de datos en la referencia de CREATE TABLE de la instrucción CREATE TABLE.For a list of the supported data types, see data types in CREATE TABLE reference in the CREATE TABLE statement. Para una guía sobre el uso de los tipos de datos, vea Guía para definir los tipos de datos para las tablas en SQL Data Warehouse.For guidance on using data types, see Data types.

Tablas distribuidasDistributed tables

Una característica fundamental de un grupo de SQL dedicado es la forma en que puede almacenar y operar en tablas de varias distribuciones.A fundamental feature of dedicated SQL pool is the way it can store and operate on tables across distributions. El grupo de SQL dedicado admite tres métodos para distribuir datos: round-robin (predeterminado), hash y replicado.Dedicated SQL pool supports three methods for distributing data: round-robin (default), hash and replicated.

Tablas distribuidas mediante una función hashHash-distributed tables

La distribución hash de la tabla distribuye las filas en función del valor de la columna de distribución.A hash distributed table distributes rows based on the value in the distribution column. La tabla distribuida de hash está diseñada para lograr un alto rendimiento para consultas en tablas grandes.A hash distributed table is designed to achieve high performance for queries on large tables. Hay varios factores que debe tener en cuenta al elegir una columna de distribución.There are several factors to consider when choosing a distribution column.

Para más información, vea Distribución de tablas en SQL Data Warehouse.For more information, see Design guidance for distributed tables.

Tablas replicadasReplicated tables

Una tabla replicada tiene una copia completa de la tabla disponible en cada nodo de proceso.A replicated table has a full copy of the table available on every Compute node. Las consultas se ejecutan rápidamente en tablas replicadas porque las combinaciones en las tablas replicadas no requieren movimiento de datos.Queries run fast on replicated tables since joins on replicated tables don't require data movement. Sin embargo, la replicación necesita almacenamiento adicional y este método no resulta práctico para tablas de gran tamaño.Replication requires extra storage, though, and isn't practical for large tables.

Para más información, consulte Instrucciones de diseño para el uso de tablas replicadas en Azure SQL Data Warehouse.For more information, see Design guidance for replicated tables.

Tablas round robinRound-robin tables

Una tabla round robin distribuye las filas de la tabla uniformemente entre todas las distribuciones.A round-robin table distributes table rows evenly across all distributions. Las filas se distribuyen aleatoriamente.The rows are distributed randomly. Cargar datos en una tabla round robin es rápido.Loading data into a round-robin table is fast. Tenga en cuenta que las consultas pueden requerir más movimiento de datos que los demás métodos de distribución.Keep in mind that queries can require more data movement than the other distribution methods.

Para más información, vea Distribución de tablas en SQL Data Warehouse.For more information, see Design guidance for distributed tables.

Métodos comunes de distribución para tablasCommon distribution methods for tables

La categoría de tabla a menudo determina qué opción elegir para distribuir la tabla.The table category often determines which option to choose for distributing the table.

Categoría de tablaTable category Opción de distribución recomendadaRecommended distribution option
FactFact Utilice la distribución por hash con el índice de almacén de columnas agrupado.Use hash-distribution with clustered columnstore index. El rendimiento mejora cuando se combinan dos tablas hash en la misma columna de distribución.Performance improves when two hash tables are joined on the same distribution column.
DimensiónDimension Use la distribución replicada para tablas más pequeñas.Use replicated for smaller tables. Si las tablas son demasiado grandes para almacenar en cada nodo de proceso, utilice la distribución por hash.If tables are too large to store on each Compute node, use hash-distributed.
EnsayoStaging Use round robin para la tabla de almacenamiento provisional.Use round-robin for the staging table. La carga con CTAS es rápida.The load with CTAS is fast. Una vez que los datos estén en la tabla de almacenamiento provisional, use INSERT... SELECT para mover los datos a las tablas de producción.Once the data is in the staging table, use INSERT...SELECT to move the data to production tables.

Particiones de tablaTable partitions

Una tabla con particiones almacena y realiza operaciones en las filas de la tabla según los intervalos de datos.A partitioned table stores and performs operations on the table rows according to data ranges. Por ejemplo, una tabla puede tener particiones por día, mes o año.For example, a table could be partitioned by day, month, or year. Puede mejorar el rendimiento de las consultas mediante la eliminación de particiones, ya que limita el examen de una consulta a los datos dentro de una partición.You can improve query performance through partition elimination, which limits a query scan to data within a partition. También puede mantener los datos a través de modificación de particiones.You can also maintain the data through partition switching. Puesto que los datos del grupo de SQL ya están distribuidos, demasiadas particiones pueden ralentizar el rendimiento de las consultas.Since the data in SQL pool is already distributed, too many partitions can slow query performance. Para más información, consulte Creación de particiones de tablas en SQL Data Warehouse.For more information, see Partitioning guidance. Cuando cambie de partición a otras particiones de tabla que no estén vacías, puede usar la opción TRUNCATE_TARGET en la instrucción ALTER TABLE si se deben truncar los datos existentes.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. El siguiente código cambia los datos diarios transformados en SalesFact y sobrescribe cualquier información existente.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 de almacén de columnasColumnstore indexes

De manera predeterminada, el grupo de SQL dedicado almacena una tabla como índice de almacén de columnas agrupado.By default, dedicated SQL pool stores a table as a clustered columnstore index. Esta forma de almacenamiento de datos logra una compresión de datos y rendimiento de las consultas altos en tablas grandes.This form of data storage achieves high data compression and query performance on large tables.

El índice de almacén de columnas agrupado suele ser la mejor opción, pero en algunos casos un índice agrupado o un montón es la estructura de almacenamiento adecuada.The clustered columnstore index is usually the best choice, but in some cases a clustered index or a heap is the appropriate storage structure.

Sugerencia

Una tabla de montón puede ser especialmente útil para cargar datos transitorios, como una tabla de almacenamiento provisional que se transforma en una tabla 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 una lista de características de almacén de columnas, vea Novedades de los índices de almacén de columnas.For a list of columnstore features, see What's new for columnstore indexes. Para mejorar el rendimiento del índice de almacén de columnas, vea Maximización de la calidad del grupo de filas del almacén de columnas.To improve columnstore index performance, see Maximizing rowgroup quality for columnstore indexes.

EstadísticasStatistics

El optimizador de consultas utiliza estadísticas de columna cuando crea el plan de ejecución de una consulta.The query optimizer uses column-level statistics when it creates the plan for executing a query.

Para mejorar el rendimiento de las consultas, es importante crear estadísticas en columnas individuales, especialmente en las columnas que se usan en combinaciones de consultas.To improve query performance, it's important to have statistics on individual columns, especially columns used in query joins. La creación de estadísticas se lleva a cabo automáticamente.Creating statistics happens automatically.

La actualización de las estadísticas no se realiza automáticamente.Updating statistics doesn't happen automatically. Actualice las estadísticas cuando se agregue o cambie un número significativo de filas.Update statistics after a significant number of rows are added or changed. Por ejemplo, actualice las estadísticas después de una carga.For example, update statistics after a load. Para más información, consulte Administración de estadísticas en tablas en SQL Data Warehouse.For more information, see Statistics guidance.

Clave principal y clave únicaPrimary key and unique key

PRIMARY KEY solo se admite cuando se usan NONCLUSTERED y NOT ENFORCED.PRIMARY KEY is only supported when NONCLUSTERED and NOT ENFORCED are both used. Solo se admite la restricción UNIQUE cuando se usa NOT ENFORCED.UNIQUE constraint is only supported with NOT ENFORCED is used. Compruebe las restricciones de tabla del grupo de SQL dedicado.Check Dedicated SQL pool table constraints.

Comandos para la creación de tablasCommands for creating tables

Puede crear una tabla como una nueva tabla vacía.You can create a table as a new empty table. También puede crear y rellenar una tabla con los resultados de una instrucción SELECT.You can also create and populate a table with the results of a select statement. A continuación se muestran los comandos de T-SQL para crear una tabla.The following are the T-SQL commands for creating a table.

Instrucción T-SQLT-SQL Statement DescripciónDescription
CREATE TABLECREATE TABLE Crea una tabla vacía mediante la definición de todas las opciones y columnas de la tabla.Creates an empty table by defining all the table columns and options.
CREATE EXTERNAL TABLECREATE EXTERNAL TABLE Crea una tabla externa.Creates an external table. La definición de la tabla se almacena en el grupo de SQL dedicado.The definition of the table is stored in dedicated SQL pool. Los datos de la tabla se almacenan en Azure Blob Storage o 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 Rellena una nueva tabla con los resultados de una instrucción SELECT.Populates a new table with the results of a select statement. Las columnas de tabla y los tipos de datos se basan en los resultados de la instrucción SELECT.The table columns and data types are based on the select statement results. Para importar datos, puede seleccionar esta instrucción en una tabla externa.To import data, this statement can select from an external table.
CREATE EXTERNAL TABLE AS SELECTCREATE EXTERNAL TABLE AS SELECT Crea una nueva tabla externa mediante la exportación de los resultados de una instrucción SELECT a una ubicación externa.Creates a new external table by exporting the results of a select statement to an external location. La ubicación es Azure Blob Storage o Azure Data Lake Store.The location is either Azure Blob storage or Azure Data Lake Store.

Alineación de los datos de origen con el grupo de SQL dedicadoAligning source data with dedicated SQL pool

Las tablas del grupo de SQL dedicado se rellenan cargando datos desde otro origen de datos.Dedicated SQL pool tables are populated by loading data from another data source. Para realizar una carga correcta, el número y los tipos de datos de las columnas de los datos de origen se deben alinear con la definición de tabla en el grupo de SQL dedicado.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. Obtener los datos que se van a alinear podría ser la parte más complicada de diseñar las tablas.Getting the data to align might be the hardest part of designing your tables.

Si los datos proceden de varios almacenes de datos, puede cargar dichos datos en el grupo de SQL dedicado y almacenarlos en una tabla de integración.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 vez que los datos están en la tabla de integración, puede utilizar la eficacia del grupo de SQL dedicado para realizar operaciones de transformación.Once data is in the integration table, you can use the power of dedicated SQL pool to perform transformation operations. Una vez que los datos están preparados, puede insertarlos en tablas de producción.Once the data is prepared, you can insert it into production tables.

Características no compatibles de las tablasUnsupported table features

El grupo de SQL dedicado admite muchas de las características de tabla que ofrecen otras bases de datos, aunque no la totalidad.Dedicated SQL pool supports many, but not all, of the table features offered by other databases. En la lista siguiente se muestran algunas de las características de tabla que no se admiten en el grupo de SQL dedicado:The following list shows some of the table features that aren't supported in dedicated SQL pool:

Consultas de tamaño de tablaTable size queries

Una forma sencilla de identificar el espacio y las filas que consume una tabla en cada una de las 60 distribuciones 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');

Sin embargo, el uso de los comandos DBCC puede resultar muy limitador.However, using DBCC commands can be quite limiting. Las vistas de administración dinámica (DMV) muestran más detalles que los comandos DBCC.Dynamic management views (DMVs) show more detail than DBCC commands. Empiece por crear esta 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]
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
;

Resumen de espacio de tablaTable space summary

Esta consulta devuelve las filas y el espacio por tabla.This query returns the rows and space by table. Permite ver qué tablas son las más grandes y si se han distribuido por hash, round robin o réplica.It allows you to see which tables are your largest tables and whether they're round-robin, replicated, or hash -distributed. Para las tablas distribuidas por hash, la consulta muestra la columna de distribución.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
;

Espacio de tabla por tipo de distribuciónTable 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
;

Espacio de tabla por 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
;

Resumen de espacio de distribuciónDistribution 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
;

Pasos siguientesNext steps

Después de crear las tablas para el grupo de SQL dedicado, el paso siguiente es cargar datos en la tabla.After creating the tables for your dedicated SQL pool, the next step is to load data into the table. Para ver un tutorial de carga, consulte Carga de datos en un grupo de SQL dedicado.For a loading tutorial, see Loading data to dedicated SQL pool.