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

Raccomandazioni ed esempi per l'uso di partizioni della tabella in Azure SQL Data Warehouse per lo sviluppo di soluzioni.Recommendations and examples for using table partitions in Azure SQL Data Warehouse.

Introduzione alle partizioni di tabellaWhat are table partitions?

Le partizioni di tabella consentono di suddividere i dati in gruppi più piccoli.Table partitions enable you to divide your data into smaller groups of data. Nella maggior parte dei casi, le partizioni di tabella vengono create in una colonna data.In most cases, table partitions are created on a date column. 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 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 to 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 all'ordine in cui i dati vengono caricati nel database.In most cases data is partitioned on a date column that is closely tied to the order in which the data is loaded into 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 troppo tempo e inoltre creare il rischio di transazioni di grandi dimensioni il cui rollback può 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 too much time, as well as create the risk of large transactions that take a long time to rollback if something goes wrong. Un approccio più appropriato consiste nel rilasciare la partizione dei dati meno recente.A more optimal approach is to 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. Una query che applica un filtro ai dati partizionati può limitare l'analisi solo alle partizioni idonee.A query that applies a filter to partitioned data can limit the scan to only the qualifying partitions. Questo metodo di filtraggio può evitare un'analisi completa della tabella e analizzare solo un subset di dati più piccolo.This method of filtering can avoid a full table scan and only scan a smaller subset of data. 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.

Ridimensionamento delle partizioniSizing partitions

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 loading simultaneously. In genere, uno schema di partizione corretto ha decine di centinaia di partizioni, non migliaia.A successful partitioning scheme usually has tens to hundreds of partitions, not thousands.

Quando si creano partizioni in tabelle columnstore cluster, è importante tenere in considerazione il numero di righe appartenenti a ogni partizione.When creating partitions on clustered columnstore tables, it is important to consider how many rows belong to 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 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 fewer than the recommended minimum number of rows per partition, consider using fewer partitions in order to increase the number of rows per partition. Per altre informazioni, vedere anche l'articolo sull'indicizzazione, che include le query che possono valutare la qualità degli indici columnstore cluster.For more information, see the Indexing article, which includes queries that can assess the quality of cluster columnstore indexes.

Differenze di sintassi rispetto a SQL ServerSyntax differences from SQL Server

SQL Data Warehouse introduce una modalità per definire le partizioni più semplice rispetto a SQL Server.SQL Data Warehouse introduces a way to define partitions that is simpler than 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.

L'esempio seguente usa l'istruzione CREATE TABLE per eseguire il partizionamento della tabella FactInternetSales nella colonna OrderDateKey:The following example uses the CREATE TABLE statement to partition 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 calcolare il numero di righe in ogni partizione.If you are migrating a partitioned table from a SQL Server instance, the following SQL can help you to figure out the number of rows that 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 diminuisce 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 decreases 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 consideration to factor in to your 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 by 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 are 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 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 è inferiore rispetto ai risultati della query seguente.In reality, your memory grant is less than the results of the following query. Questa query, tuttavia, fornisce un livello di indicazioni che è possibile usare durante il dimensionamento delle partizioni per le operazioni di gestione dati.However, this query 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 executed 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. Se i limiti di partizione non sono uguali, il cambio di partizione non riuscirà, perché i metadati della partizione non verranno sincronizzati.If the partition boundaries are not then same, 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.

L'esempio seguente crea una tabella columnstore partizionata.The following example creates a partitioned columnstore table. Inserisce una riga in ogni partizione:It inserts one row into 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 statistiche, i metadati della tabella sono più accurati.By creating the statistic object, the table metadata is more accurate. Se si omettono le statistiche, SQL Data Warehouse userà i valori predefiniti.If you omit statistics, then SQL Data Warehouse will use default values. Per informazioni dettagliate, vedere l'articolo relativo alla gestione delle statistiche.For details on statistics, please review statistics.

La query seguente consente di trovare il numero delle righe usando la vista del catalogo sys.partitions:The following query finds the row count by 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'
;

Il comando di divisione seguente riceve un messaggio di errore:The following split command receives an error message:

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, you can use CTAS to create a new table to hold the 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 you 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 is to align the data to the new partition boundaries using CTAS, and then switch the data back into 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.Once you have completed the movement of the data, it is a good idea to refresh the statistics on the target table. L'aggiornamento delle statistiche assicura che le statistiche rispecchino in modo accurato la nuova distribuzione dei dati nelle rispettive partizioni.Updating statistics ensures the statistics 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 fossilizzi 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 () )
    )
    ;
    
  2. 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 sullo sviluppo di tabelle, vedere gli articoli sui cenni preliminari sulle tabelle.For more information about developing tables, see the articles on Table Overview.