Partizionamento di tabelle in un pool SQL dedicatoPartitioning tables in dedicated SQL pool

Suggerimenti ed esempi per l'uso di partizioni di tabella nel pool SQL dedicato.Recommendations and examples for using table partitions in dedicated SQL pool.

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 del pool SQL dedicati. inclusi columnstore cluster, indice cluster e heap.Partitioning is supported on all dedicated SQL pool 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 nel pool SQL dedicato consiste nel migliorare l'efficienza e le prestazioni del caricamento dei dati mediante l'eliminazione, il cambio e l'Unione delle partizioni.The primary benefit of partitioning in dedicated SQL pool is to improve the efficiency and performance of loading data by use of partition deletion, switching and merging. Nella maggior parte dei casi i dati vengono partizionati in una colonna di data strettamente legata all'ordine in cui i dati vengono caricati nel pool SQL.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 SQL pool. Uno dei principali vantaggi derivanti dall'utilizzo delle partizioni per la manutenzione dei dati è l'evitare la registrazione delle transazioni.One of the greatest benefits of using partitions to maintain data is 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.

Se, ad esempio, la tabella dei fatti delle vendite è partizionata in 36 mesi usando il campo Sales date, 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, il pool SQL dedicato divide già ogni tabella in database distribuiti 60.Before partitions are created, dedicated SQL pool 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. Usando questo esempio, se la tabella dei fatti delle vendite conteneva 36 partizioni mensili e dato che un pool SQL dedicato ha 60 distribuzioni, la tabella dei fatti delle vendite dovrebbe contenere 60 milioni righe al mese o 2,1 miliardi righe quando tutti i mesi sono popolati.Using this example, if the sales fact table contained 36 monthly partitions, and given that a dedicated SQL pool 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

Il pool SQL dedicato introduce un modo per definire partizioni più semplici rispetto a SQL Server.Dedicated SQL pool introduces a way to define partitions that is simpler than SQL Server. Le funzioni e gli schemi di partizionamento non vengono usati nel pool SQL dedicato così come sono in SQL Server.Partitioning functions and schemes are not used in dedicated SQL pool 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 il pool SQL dedicato supportano una colonna di partizione per ogni tabella, che può essere con intervallo di partizione.SQL Server and dedicated SQL pool 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 SQL Server al pool SQL dedicato, è sufficiente:To migrate SQL Server partition definitions to dedicated SQL pool 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. Tenere presente che se si usa la stessa granularità di partizionamento nel pool SQL dedicato, il numero di righe per partizione diminuisce di un fattore di 60.Keep in mind that if the same partitioning granularity is used in dedicated SQL pool, 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]
;

Cambio di partizionePartition switching

Il pool SQL dedicato supporta la suddivisione, l'Unione e il cambio di partizioni.Dedicated SQL pool 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);

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. quando la tabella include un indice columnstore è possibile dividere solo le partizioni vuote.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];

Caricare nuovi dati in partizioni che contengono dati in un unico passaggioLoad new data into partitions that contain data in one step

Il caricamento dei dati nelle partizioni con cambio di partizione è un modo pratico per organizzare i nuovi dati in una tabella che non è visibile agli utenti.Loading data into partitions with partition switching is a convenient way to stage new data in a table that is not visible to users. Per gestire la contesa di blocco associata al cambio di partizione, è possibile che si tratti di una sfida sui sistemi occupati.It can be challenging on busy systems to deal with the locking contention associated with partition switching.

Per cancellare i dati esistenti in una partizione, un ALTER TABLE utilizzato per disattivare i dati.To clear out the existing data in a partition, an ALTER TABLE used to be required to switch out the data. Quindi ALTER TABLE , era necessario un altro per attivare i nuovi dati.Then another ALTER TABLE was required to switch in the new data.

Nel pool SQL dedicato, l' TRUNCATE_TARGET opzione è supportata nel ALTER TABLE comando.In dedicated SQL pool, the TRUNCATE_TARGET option is supported in the ALTER TABLE command. Con TRUNCATE_TARGET il ALTER TABLE comando sovrascrive i dati esistenti nella partizione con nuovi dati.With TRUNCATE_TARGET the ALTER TABLE command overwrites existing data in the partition with new data. Di seguito è riportato un esempio che usa CTAS per creare una nuova tabella con i dati esistenti, inserire nuovi dati, quindi riportare tutti i dati nella tabella di destinazione, sovrascrivendo i dati esistenti.Below is an example that uses CTAS to create a new table with the existing data, inserts new data, then switches all the data back into the target table, overwriting the existing data.

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

INSERT INTO dbo.FactInternetSales_NewSales
VALUES (1,20000101,2,2,2,2,2,2);

ALTER TABLE dbo.FactInternetSales_NewSales SWITCH PARTITION 2 TO dbo.FactInternetSales PARTITION 2 WITH (TRUNCATE_TARGET = ON);  

Controllo del codice sorgente del partizionamento della tabellaTable partitioning source control

Per evitare che la definizione della tabella venga arrugginita nel sistema di controllo del codice sorgente, è consigliabile 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 e i valori limite del partizionamento possono essere dinamici; evoluzione con il pool SQL 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 SQL pool 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.