Tabelle di partizionamento in SQL Data WarehousePartitioning tables in SQL Data Warehouse

Il partizionamento è supportato in tutti i tipi di tabella di SQL Data Warehouse, tra cui columnstore cluster, indice cluster e heap.Partitioning is supported on all SQL Data Warehouse table types; including clustered columnstore, clustered index, and heap. Il partizionamento è supportato anche in tutti i tipi di distribuzione, sia hash che round robin.Partitioning is also supported on all distribution types, including both hash or round robin distributed. Il partizionamento consente di dividere i dati in gruppi di dati più piccoli e nella maggior parte dei casi il partizionamento viene effettuato su una colonna relativa alla data.Partitioning enables you to divide your data into smaller groups of data and in most cases, partitioning is done on a date column.

Vantaggi del partizionamentoBenefits of partitioning

Il partizionamento può recare vantaggio alle prestazioni di query e di conservazione dei dati.Partitioning can benefit data maintenance and query performance. Il fatto di recare vantaggio a entrambi i tipi di prestazioni o solo a uno dei due dipende dalla modalità di caricamento dei dati e dalla possibilità di usare la stessa colonna per entrambi gli scopi, poiché il partizionamento può essere eseguito solo su una colonna.Whether it benefits both or just one is dependent on how data is loaded and whether the same column can be used for both purposes, since partitioning can only be done on one column.

Vantaggi in termini di caricamentoBenefits to loads

Il vantaggio principale del partizionamento in SQL Data Warehouse è aumentare l'efficienza e le prestazioni di caricamento dei dati usando l'eliminazione, il cambio e l'unione delle partizioni.The primary benefit of partitioning in SQL Data Warehouse is improve the efficiency and performance of loading data by use of partition deletion, switching and merging. Nella maggior parte dei casi viene eseguito il partizionamento dei dati in una colonna di date strettamente legata alla sequenza in cui i dati vengono caricati nel database.In most cases data is partitioned on a date column that is closely tied to the sequence which the data is loaded to the database. Uno dei principali vantaggi dell'uso di partizioni per conservare i dati è che evita la registrazione delle transazioni.One of the greatest benefits of using partitions to maintain data it the avoidance of transaction logging. Mentre le semplici operazioni di inserimento, aggiornamento o eliminazione dei dati possono rappresentare l'approccio più semplice, con un po' di impegno e di ragionamento, l'uso del partizionamento durante il processo di caricamento può migliorare notevolmente le prestazioni.While simply inserting, updating or deleting data can be the most straightforward approach, with a little thought and effort, using partitioning during your load process can substantially improve performance.

Il cambio di partizioni consente di rimuovere o sostituire rapidamente una sezione di tabella.Partition switching can be used to quickly remove or replace a section of a table. Ad esempio, una tabella dei fatti delle vendite potrebbe contenere solo i dati relativi agli ultimi 36 mesi.For example, a sales fact table might contain just data for the past 36 months. Alla fine di ogni mese, il mese dei dati di vendita meno recenti viene eliminato dalla tabella.At the end of every month, the oldest month of sales data is deleted from the table. Questi dati potrebbero essere eliminati tramite un'istruzione delete per eliminare i dati relativi al mese meno recente.This data could be deleted by using a delete statement to delete the data for the oldest month. Tuttavia, l'eliminazione di una grande quantità di dati riga per riga con un'istruzione delete può richiedere molto tempo e inoltre creare il rischio di transazioni di grandi dimensioni il cui rollback potrebbe richiedere molto tempo nel caso in cui qualcosa andasse storto.However, deleting a large amount of data row-by-row with a delete statement can take a very long time, as well as create the risk of large transactions which could take a long time to rollback if something goes wrong. Un approccio più appropriato consiste semplicemente nel rilasciare la partizione dei dati meno recente.A more optimal approach is to simply drop the oldest partition of data. Nei casi in cui l'eliminazione delle singole righe arrivasse a richiedere alcune ore, l'eliminazione di un'intera partizione potrebbe richiedere pochi secondi.Where deleting the individual rows could take hours, deleting an entire partition could take seconds.

Vantaggi in termini di queryBenefits to queries

Il partizionamento può essere usato anche per aumentare le prestazioni delle query.Partitioning can also be used to improve query performance. Se una query applica un filtro in una colonna con partizionamento, questo può limitare l'analisi solo alle partizioni idonee che potrebbero rappresentare un sottoinsieme di dati molto più ridotto, evitando un'analisi completa della tabella.If a query applies a filter on a partitioned column, this can limit the scan to only the qualifying partitions which may be a much smaller subset of the data, avoiding a full table scan. Con l'introduzione di indici columnstore cluster, i vantaggi delle prestazioni di eliminazione del predicato sono meno utili, ma in alcuni casi possono esserci vantaggi per le query.With the introduction of clustered columnstore indexes, the predicate elimination performance benefits are less beneficial, but in some cases there can be a benefit to queries. Ad esempio, se la tabella dei fatti delle vendite è suddivisa in 36 mesi tramite il campo della data di vendita, le query che filtrano la data di vendita possono ignorare la ricerca nelle partizioni che non corrispondono al filtro.For example, if the sales fact table is partitioned into 36 months using the sales date field, then queries that filter on the sale date can skip searching in partitions that don’t match the filter.

Indicazioni sul dimensionamento delle partizioniPartition sizing guidance

Mentre il partizionamento può essere usato per aumentare le prestazioni di alcuni scenari, in alcune circostanze la creazione di una tabella con troppe partizioni può influire negativamente sulle prestazioni.While partitioning can be used to improve performance some scenarios, creating a table with too many partitions can hurt performance under some circumstances. Questi problemi valgono soprattutto per le tabelle columnstore cluster.These concerns are especially true for clustered columnstore tables. Affinché il partizionamento sia utile, per un amministratore di database è importante capire quando usare il partizionamento e il numero di partizioni da creare.For partitioning to be helpful, it is important to understand when to use partitioning and the number of partitions to create. Non esiste una regola assoluta che chiarisca cosa si intende per troppe partizioni, perché dipende dai dati e dal numero di partizioni caricate contemporaneamente.There is no hard fast rule as to how many partitions are too many, it depends on your data and how many partitions you are loading to simultaneously. Tuttavia, come regola empirica generale, è consigliabile aggiungere alcune decine o centinaia di partizioni, non migliaia.But as a general rule of thumb, think of adding 10s to 100s of partitions, not 1000s.

Quando si crea il partizionamento in tabelle columnstore cluster , è importante tenere in considerazione il numero di righe visualizzate in ogni partizione.When creating partitioning on clustered columnstore tables, it is important to consider how many rows will land in each partition. Per ottenere risultati ottimali in termini di compressione e prestazioni delle tabelle columnstore cluster, è necessario almeno 1 milione di righe per distribuzione e partizione.For optimal compression and performance of clustered columnstore tables, a minimum of 1 million rows per distribution and partition is needed. Prima della creazione delle partizioni, SQL Data Warehouse divide già ogni tabella in 60 database distribuiti.Before partitions are created, SQL Data Warehouse already divides each table into 60 distributed databases. Eventuali partizionamenti aggiunti a una tabella sono in più rispetto alle distribuzioni create in background.Any partitioning added to a table is in addition to the distributions created behind the scenes. Utilizzando questo esempio, se la tabella dei fatti delle vendite contenesse 36 partizioni mensili e dato che SQL Data Warehouse dispone di 60 distribuzioni, la tabella dei fatti delle vendite dovrebbe contenere 60 milioni di righe al mese o 2,1 milioni di righe quando tutti i mesi sono popolati.Using this example, if the sales fact table contained 36 monthly partitions, and given that SQL Data Warehouse has 60 distributions, then the sales fact table should contain 60 million rows per month, or 2.1 billion rows when all months are populated. Se una tabella contiene un numero di righe significativamente inferiore a quello minimo consigliato per partizione, è necessario prendere in considerazione l'uso di un minor numero di partizioni per aumentare il numero di righe per partizione.If a table contains significantly less rows than the recommended minimum number of rows per partition, consider using fewer partitions in order to make increase the number of rows per partition. Vedere anche l'articolo sull'indicizzazione, che include le query che possono essere eseguite in SQL Data Warehouse per valutare la qualità degli indici columnstore cluster.Also see the Indexing article which includes queries that can be run on SQL Data Warehouse to assess the quality of cluster columnstore indexes.

Differenze di sintassi rispetto a SQL ServerSyntax difference from SQL Server

SQL Data Warehouse introduce una definizione semplificata delle partizioni, leggermente diversa da SQL Server.SQL Data Warehouse introduces a simplified definition of partitions which is slightly different from SQL Server. Le funzioni e gli schemi di partizionamento non vengono usati in SQL Data Warehouse come in SQL Server.Partitioning functions and schemes are not used in SQL Data Warehouse as they are in SQL Server. Piuttosto, è necessario identificare la colonna partizionata e le delimitazioni.Instead, all you need to do is identify partitioned column and the boundary points. Mentre la sintassi del partizionamento può essere leggermente diversa da quella di SQL Server, i concetti di base sono gli stessi.While the syntax of partitioning may be slightly different from SQL Server, the basic concepts are the same. SQL Server e SQL Data Warehouse supportano una colonna di partizione per tabella, che può essere il partizionamento con intervallo.SQL Server and SQL Data Warehouse support one partition column per table, which can be ranged partition. Per altre informazioni sul partizionamento, vedere Tabelle e indici partizionati.To learn more about partitioning, see Partitioned Tables and Indexes.

Il seguente esempio di istruzione CREATE TABLE con partizionamento di SQL Data Warehouse esegue il partizionamento della tabella FactInternetSales nella colonna OrderDateKey:The below example of a SQL Data Warehouse partitioned CREATE TABLE statement, partitions the FactInternetSales table on the OrderDateKey column:

CREATE TABLE [dbo].[FactInternetSales]
(
    [ProductKey]            int          NOT NULL
,   [OrderDateKey]          int          NOT NULL
,   [CustomerKey]           int          NOT NULL
,   [PromotionKey]          int          NOT NULL
,   [SalesOrderNumber]      nvarchar(20) NOT NULL
,   [OrderQuantity]         smallint     NOT NULL
,   [UnitPrice]             money        NOT NULL
,   [SalesAmount]           money        NOT NULL
)
WITH
(   CLUSTERED COLUMNSTORE INDEX
,   DISTRIBUTION = HASH([ProductKey])
,   PARTITION   (   [OrderDateKey] RANGE RIGHT FOR VALUES
                    (20000101,20010101,20020101
                    ,20030101,20040101,20050101
                    )
                )
)
;

Migrazione del partizionamento da SQL ServerMigrating partitioning from SQL Server

Per eseguire la migrazione delle definizioni delle partizioni di SQL Server a SQL Data Warehouse, è necessario semplicemente:To migrate SQL Server partition definitions to SQL Data Warehouse simply:

Se si sta migrando una tabella con partizionamento da un'istanza di SQL Server, l'SQL di seguito è utile per interrogare il numero di righe in ogni partizione.If you are migrating a partitioned table from a SQL Server instance the below SQL can help you to interrogate the number of rows that are in each partition. È necessario tenere presente che se viene usata la stessa granularità di partizionamento in SQL Data Warehouse, il numero di righe per partizione diminuirà di un fattore pari a 60.Keep in mind that if the same partitioning granularity is used on SQL Data Warehouse, the number of rows per partition will decrease by a factor of 60.

-- Partition information for a SQL Server Database
SELECT      s.[name]                        AS      [schema_name]
,           t.[name]                        AS      [table_name]
,           i.[name]                        AS      [index_name]
,           p.[partition_number]            AS      [partition_number]
,           SUM(a.[used_pages]*8.0)         AS      [partition_size_kb]
,           SUM(a.[used_pages]*8.0)/1024    AS      [partition_size_mb]
,           SUM(a.[used_pages]*8.0)/1048576 AS      [partition_size_gb]
,           p.[rows]                        AS      [partition_row_count]
,           rv.[value]                      AS      [partition_boundary_value]
,           p.[data_compression_desc]       AS      [partition_compression_desc]
FROM        sys.schemas s
JOIN        sys.tables t                    ON      t.[schema_id]         = s.[schema_id]
JOIN        sys.partitions p                ON      p.[object_id]         = t.[object_id]
JOIN        sys.allocation_units a          ON      a.[container_id]      = p.[partition_id]
JOIN        sys.indexes i                   ON      i.[object_id]         = p.[object_id]
                                            AND     i.[index_id]          = p.[index_id]
JOIN        sys.data_spaces ds              ON      ds.[data_space_id]    = i.[data_space_id]
LEFT JOIN   sys.partition_schemes ps        ON      ps.[data_space_id]    = ds.[data_space_id]
LEFT JOIN   sys.partition_functions pf      ON      pf.[function_id]      = ps.[function_id]
LEFT JOIN   sys.partition_range_values rv   ON      rv.[function_id]      = pf.[function_id]
                                            AND     rv.[boundary_id]      = p.[partition_number]
WHERE       p.[index_id] <=1
GROUP BY    s.[name]
,           t.[name]
,           i.[name]
,           p.[partition_number]
,           p.[rows]
,           rv.[value]
,           p.[data_compression_desc]
;

Gestione del carico di lavoroWorkload management

Un'ultima considerazione da tenere presente nella decisione relativa alla partizione della tabella riguarda la gestione del carico di lavoro.One final piece consideration to factor in to the table partition decision is workload management. La gestione del carico di lavoro in SQL Data Warehouse è principalmente la gestione di memoria e concorrenza.Workload management in SQL Data Warehouse is primarily the management of memory and concurrency. In SQL Data Warehouse la memoria massima allocata a ogni distribuzione durante l'esecuzione della query è controllata dalle classi di risorse.In SQL Data Warehouse the maximum memory allocated to each distribution during query execution is governed resource classes. In teoria le dimensioni delle partizioni devono tenere in considerazione altri fattori come la memoria necessaria per creare indici columnstore cluster.Ideally your partitions will be sized in consideration of other factors like the memory needs of building clustered columnstore indexes. Gli indici columnstore cluster traggono importanti vantaggi quando la memoria allocata è maggiore.Clustered columnstore indexes benefit greatly when they are allocated more memory. È quindi opportuno verificare che la ricompilazione dell'indice della partizione non esaurisca la memoria.Therefore, you will want to ensure that a partition index rebuild is not starved of memory. Per ottenere l'aumento della memoria disponibile per la query, è possibile passare dal ruolo predefinito, smallrc, a uno degli altri ruoli, ad esempio largerc.Increasing the amount of memory available to your query can be achieved by switching from the default role, smallrc, to one of the other roles such as largerc.

Le informazioni sull'allocazione di memoria per ogni distribuzione sono disponibili mediante l'esecuzione di una query sulle viste a gestione dinamica di Resource Governor.Information on the allocation of memory per distribution is available by querying the resource governor dynamic management views. In realtà la concessione di memoria sarà inferiore rispetto alle cifre seguenti.In reality your memory grant will be less than the figures below. Fornisce tuttavia un livello di indicazioni che è possibile usare durante il dimensionamento delle partizioni per le operazioni di gestione dati.However, this provides a level of guidance that you can use when sizing your partitions for data management operations. Evitare se possibile di dimensionare le partizioni oltre la concessione di memoria fornita dalla classe di risorse molto grande.Try to avoid sizing your partitions beyond the memory grant provided by the extra large resource class. Se le partizioni aumentano oltre questa cifra, si rischia un utilizzo elevato di memoria che a sua volta determina una compressione non ottimale.If your partitions grow beyond this figure you run the risk of memory pressure which in turn leads to less optimal compression.

SELECT  rp.[name]                                AS [pool_name]
,       rp.[max_memory_kb]                        AS [max_memory_kb]
,       rp.[max_memory_kb]/1024                    AS [max_memory_mb]
,       rp.[max_memory_kb]/1048576                AS [mex_memory_gb]
,       rp.[max_memory_percent]                    AS [max_memory_percent]
,       wg.[name]                                AS [group_name]
,       wg.[importance]                            AS [group_importance]
,       wg.[request_max_memory_grant_percent]    AS [request_max_memory_grant_percent]
FROM    sys.dm_pdw_nodes_resource_governor_workload_groups    wg
JOIN    sys.dm_pdw_nodes_resource_governor_resource_pools    rp ON wg.[pool_id] = rp.[pool_id]
WHERE   wg.[name] like 'SloDWGroup%'
AND     rp.[name]    = 'SloDWPool'
;

Cambio di partizionePartition switching

SQL Data Warehouse supporta la suddivisione, l'unione e il cambio di partizioni.SQL Data Warehouse supports partition splitting, merging, and switching. Ognuna di queste funzioni viene eseguita usando l'istruzione ALTER TABLE.Each of these functions is excuted using the ALTER TABLE statement.

Per il cambio di partizione tra due tabelle, è necessario verificare che le partizioni siano allineate sui rispettivi limiti e che le definizioni delle tabelle corrispondano.To switch partitions between two tables you must ensure that the partitions align on their respective boundaries and that the table definitions match. Poiché non sono disponibili vincoli CHECK per imporre l'intervallo di valori in una tabella, la tabella di origine deve contenere gli stessi limiti di partizione della tabella di destinazione.As check constraints are not available to enforce the range of values in a table the source table must contain the same partition boundaries as the target table. In caso contrario, il cambio di partizione non riuscirà, perché i metadati della partizione non verranno sincronizzati.If this is not the case, then the partition switch will fail as the partition metadata will not be synchronized.

Come suddividere una partizione che contiene datiHow to split a partition that contains data

Il metodo più efficiente per suddividere una partizione che contiene già dati, consiste nell'usare un'istruzione CTAS .The most efficient method to split a partition that already contains data is to use a CTAS statement. Se la tabella partizionata è un columnstore cluster, la partizione della tabella deve essere vuota per poterla suddividere.If the partitioned table is a clustered columnstore then the table partition must be empty before it can be split.

Di seguito è riportato un esempio di tabella columnstore contenente una riga in ogni partizione:Below is a sample partitioned columnstore table containing one row in each partition:

CREATE TABLE [dbo].[FactInternetSales]
(
        [ProductKey]            int          NOT NULL
    ,   [OrderDateKey]          int          NOT NULL
    ,   [CustomerKey]           int          NOT NULL
    ,   [PromotionKey]          int          NOT NULL
    ,   [SalesOrderNumber]      nvarchar(20) NOT NULL
    ,   [OrderQuantity]         smallint     NOT NULL
    ,   [UnitPrice]             money        NOT NULL
    ,   [SalesAmount]           money        NOT NULL
)
WITH
(   CLUSTERED COLUMNSTORE INDEX
,   DISTRIBUTION = HASH([ProductKey])
,   PARTITION   (   [OrderDateKey] RANGE RIGHT FOR VALUES
                    (20000101
                    )
                )
)
;

INSERT INTO dbo.FactInternetSales
VALUES (1,19990101,1,1,1,1,1,1);
INSERT INTO dbo.FactInternetSales
VALUES (1,20000101,1,1,1,1,1,1);


CREATE STATISTICS Stat_dbo_FactInternetSales_OrderDateKey ON dbo.FactInternetSales(OrderDateKey);

Nota

Con la creazione dell'oggetto Statistic, si assicura una maggiore accuratezza dei metadati della tabella.By Creating the statistic object, we ensure that table metadata is more accurate. Se si omette la creazione di statistiche, SQL Data Warehouse userà i valori predefiniti.If we omit creating statistics, then SQL Data Warehouse will use default values. Per altre informazioni, vedere l'articolo relativo alla gestione delle statistiche.For details on statistics please review statistics.

È quindi possibile eseguire una query per il conteggio delle righe usando la vista del catalogo sys.partitions :We can then query for the row count using the sys.partitions catalog view:

SELECT  QUOTENAME(s.[name])+'.'+QUOTENAME(t.[name]) as Table_name
,       i.[name] as Index_name
,       p.partition_number as Partition_nmbr
,       p.[rows] as Row_count
,       p.[data_compression_desc] as Data_Compression_desc
FROM    sys.partitions p
JOIN    sys.tables     t    ON    p.[object_id]   = t.[object_id]
JOIN    sys.schemas    s    ON    t.[schema_id]   = s.[schema_id]
JOIN    sys.indexes    i    ON    p.[object_id]   = i.[object_Id]
                            AND   p.[index_Id]    = i.[index_Id]
WHERE t.[name] = 'FactInternetSales'
;

Se si tenta di suddividere questa tabella, verrà restituito un errore:If we try to split this table, we will get an error:

ALTER TABLE FactInternetSales SPLIT RANGE (20010101);

Messaggio 35346, livello 15, stato 1, riga 44 Clausola SPLIT dell'istruzione ALTER PARTITION non riuscita perché la partizione non è vuota.Msg 35346, Level 15, State 1, Line 44 SPLIT clause of ALTER PARTITION statement failed because the partition is not empty. Solo le partizioni vuote possono essere suddivise quando nella tabella è presente un indice columnstore.Only empty partitions can be split in when a columnstore index exists on the table. Provare a disabilitare l'indice columnstore prima di eseguire l'istruzione ALTER PARTITION, quindi ricompilare l'indice columnstore dopo il completamento di ALTER PARTITION.Consider disabling the columnstore index before issuing the ALTER PARTITION statement, then rebuilding the columnstore index after ALTER PARTITION is complete.

È tuttavia possibile usare CTAS per creare una nuova tabella per contenere i dati.However, we can use CTAS to create a new table to hold our data.

CREATE TABLE dbo.FactInternetSales_20000101
    WITH    (   DISTRIBUTION = HASH(ProductKey)
            ,   CLUSTERED COLUMNSTORE INDEX
            ,   PARTITION   (   [OrderDateKey] RANGE RIGHT FOR VALUES
                                (20000101
                                )
                            )
            )
AS
SELECT *
FROM    FactInternetSales
WHERE   1=2
;

Poiché i limiti della partizione sono allineati, il cambio è consentito.As the partition boundaries are aligned a switch is permitted. In questo modo la tabella di origine avrà una partizione vuota che in seguito si potrà suddividere.This will leave the source table with an empty partition that we can subsequently split.

ALTER TABLE FactInternetSales SWITCH PARTITION 2 TO  FactInternetSales_20000101 PARTITION 2;

ALTER TABLE FactInternetSales SPLIT RANGE (20010101);

A questo punto è sufficiente allineare i dati ai nuovi limiti di partizione usando CTAS e ritrasferire i dati nella tabella principale.All that is left to do is to align our data to the new partition boundaries using CTAS and switch our data back in to the main table

CREATE TABLE [dbo].[FactInternetSales_20000101_20010101]
    WITH    (   DISTRIBUTION = HASH([ProductKey])
            ,   CLUSTERED COLUMNSTORE INDEX
            ,   PARTITION   (   [OrderDateKey] RANGE RIGHT FOR VALUES
                                (20000101,20010101
                                )
                            )
            )
AS
SELECT  *
FROM    [dbo].[FactInternetSales_20000101]
WHERE   [OrderDateKey] >= 20000101
AND     [OrderDateKey] <  20010101
;

ALTER TABLE dbo.FactInternetSales_20000101_20010101 SWITCH PARTITION 2 TO dbo.FactInternetSales PARTITION 2;

Dopo aver completato lo spostamento dei dati, è consigliabile aggiornare le statistiche nella tabella di destinazione per assicurare che riflettano accuratamente la nuova distribuzione dei dati nelle rispettive partizioni:Once you have completed the movement of the data it is a good idea to refresh the statistics on the target table to ensure they accurately reflect the new distribution of the data in their respective partitions:

UPDATE STATISTICS [dbo].[FactInternetSales];

Controllo del codice sorgente del partizionamento della tabellaTable partitioning source control

Per evitare che la definizione della tabella si stabilisca nel sistema di controllo del codice sorgente, è possibile considerare l'approccio seguente:To avoid your table definition from rusting in your source control system you may want to consider the following approach:

  1. Creare la tabella come tabella partizionata, ma senza valori di partizione.Create the table as a partitioned table but with no partition values
CREATE TABLE [dbo].[FactInternetSales]
(
    [ProductKey]            int          NOT NULL
,   [OrderDateKey]          int          NOT NULL
,   [CustomerKey]           int          NOT NULL
,   [PromotionKey]          int          NOT NULL
,   [SalesOrderNumber]      nvarchar(20) NOT NULL
,   [OrderQuantity]         smallint     NOT NULL
,   [UnitPrice]             money        NOT NULL
,   [SalesAmount]           money        NOT NULL
)
WITH
(   CLUSTERED COLUMNSTORE INDEX
,   DISTRIBUTION = HASH([ProductKey])
,   PARTITION   (   [OrderDateKey] RANGE RIGHT FOR VALUES
                    ()
                )
)
;
  1. SPLIT per suddividere la tabella come parte del processo di distribuzione:SPLIT the table as part of the deployment process:
-- Create a table containing the partition boundaries

CREATE TABLE #partitions
WITH
(
    LOCATION = USER_DB
,   DISTRIBUTION = HASH(ptn_no)
)
AS
SELECT  ptn_no
,       ROW_NUMBER() OVER (ORDER BY (ptn_no)) as seq_no
FROM    (
        SELECT CAST(20000101 AS INT) ptn_no
        UNION ALL
        SELECT CAST(20010101 AS INT)
        UNION ALL
        SELECT CAST(20020101 AS INT)
        UNION ALL
        SELECT CAST(20030101 AS INT)
        UNION ALL
        SELECT CAST(20040101 AS INT)
        ) a
;

-- Iterate over the partition boundaries and split the table

DECLARE @c INT = (SELECT COUNT(*) FROM #partitions)
,       @i INT = 1                                 --iterator for while loop
,       @q NVARCHAR(4000)                          --query
,       @p NVARCHAR(20)     = N''                  --partition_number
,       @s NVARCHAR(128)    = N'dbo'               --schema
,       @t NVARCHAR(128)    = N'FactInternetSales' --table
;

WHILE @i <= @c
BEGIN
    SET @p = (SELECT ptn_no FROM #partitions WHERE seq_no = @i);
    SET @q = (SELECT N'ALTER TABLE '+@s+N'.'+@t+N' SPLIT RANGE ('+@p+N');');

    -- PRINT @q;
    EXECUTE sp_executesql @q;

    SET @i+=1;
END

-- Code clean-up

DROP TABLE #partitions;

Con questo approccio, il codice nel controllo del codice sorgente rimane statico, mentre i valori dei limiti del partizionamento possono essere dinamici, evolvendo con il warehouse nel tempo.With this approach the code in source control remains static and the partitioning boundary values are allowed to be dynamic; evolving with the warehouse over time.

Passaggi successiviNext steps

Per altre informazioni, vedere gli articoli su panoramica delle tabelle, tipi di dati delle tabelle, distribuzione di una tabella, indicizzazione di una tabella, conservazione delle statistiche delle tabelle e tabelle temporanee.To learn more, see the articles on Table Overview, Table Data Types, Distributing a Table, Indexing 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.