Tabella temporanea e variabile di tabella più rapide con l'ottimizzazione per la memoriaFaster temp table and table variable by using memory optimization

QUESTO ARGOMENTO SI APPLICA A: sìSQL Server (a partire dalla versione 2016)sìDatabase SQL di AzurenoAzure SQL Data Warehouse noParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2016)yesAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

Se si usano tabelle temporanee, variabili di tabella o parametri con valori di tabella, è possibile convertirli per usufruire delle tabelle e delle variabili di tabella con ottimizzazione per la memoria per migliorare le prestazioni.If you use temporary tables, table variables, or table-valued parameters, consider conversions of them to leverage memory-optimized tables and table variables to improve performance. Le modifiche al codice sono in genere limitate.The code changes are usually minimal.

Questo articolo descrive:This article describes:

  • Scenari a sostegno della conversione in elementi in memoria.Scenarios which argue in favor of conversion to In-Memory.
  • Passaggi tecnici per l'implementazione della conversione in elementi in memoria.Technical steps for implementing the conversions to In-Memory.
  • Prerequisiti per la conversione in elementi in memoria.Prerequisites before conversion to In-Memory.
  • Un esempio di codice che evidenzia i vantaggi in termini di prestazioni dell'ottimizzazione per la memoriaA code sample that highlights the performance benefits of memory-optimization

A.A. Introduzione alle variabili di tabella con ottimizzazione per la memoriaBasics of memory-optimized table variables

Una variabile di tabella con ottimizzazione per la memoria offre una maggiore efficienza grazie all'uso dello stesso algoritmo e delle stesse strutture di dati con ottimizzazione per la memoria usate dalle tabelle con ottimizzazione per la memoria.A memory-optimized table variable provides great efficiency by using the same memory-optimized algorithm and data structures that are used by memory-optimized tables. L'efficienza è particolarmente evidente quando viene eseguito l'accesso alla variabile di tabella dall'interno di un modulo compilato in modo nativo.The efficiency is maximized when the table variable is accessed from within a natively compiled module.

Una variabile di tabella con ottimizzazione per la memoria:A memory-optimized table variable:

  • È archiviata solo in memoria e non ha alcun componente su disco.Is stored only in memory, and has no component on disk.
  • Non comporta alcuna attività di I/O.Involves no IO activity.
  • Non comporta alcun utilizzo di tempdb o contesa.Involves no tempdb utilization or contention.
  • Può essere passata in una stored procedure come parametro con valori di tabella (TVP).Can be passed into a stored proc as a table-valued parameter (TVP).
  • Deve avere almeno un indice, hash o non cluster.Must have at least one index, either hash or nonclustered.
    • Per un indice hash, il numero di bucket dovrebbe essere idealmente 1 o 2 volte il numero di chiavi di indice univoco previsto. Tuttavia, sovrastimare il numero di bucket è solitamente corretto (fino a 10 X).For a hash index, the bucket count should ideally be 1-2 times the number of expected unique index keys, but overestimating bucket count is usually fine (up to 10X). Per dettagli, vedere Indexes for Memory-Optimized Tables(Indici per tabelle con ottimizzazione per la memoria).For details see Indexes for Memory-Optimized Tables.

Tipi di oggettiObject types

OLTP in memoria offre gli oggetti seguenti che possono essere usati per l'ottimizzazione per la memoria di tabelle temporanee e variabili di tabella:In-Memory OLTP provides the following objects that can be used for memory-optimizing temp tables and table variables:

  • Tabelle con ottimizzazione per la memoriaMemory-optimized tables
    • Durability = SCHEMA_ONLYDurability = SCHEMA_ONLY
  • Variabili di tabella con ottimizzazione per la memoriaMemory-optimized table variables
    • Devono essere dichiarate in due passaggi (anziché inline):Must be declared in two steps (rather than inline):
      • CREATE TYPE my_type AS TABLE ...; , quindiCREATE TYPE my_type AS TABLE ...; , then
      • DECLARE @mytablevariable my_type;(Indici per tabelle con ottimizzazione per la memoria).DECLARE @mytablevariable my_type;.

B.B. Scenario: sostituire la tabella temporanea globaleScenario: Replace global tempdb ##table

Si supponga di avere la tabella temporanea globale seguente.Suppose you have the following global temporary table.

CREATE TABLE ##tempGlobalB  
(  
    Column1   INT   NOT NULL ,  
    Column2   NVARCHAR(4000)  
);  

È possibile sostituire la tabella temporanea globale con la tabella con ottimizzazione per la memoria seguente che include DURABILITY = SCHEMA_ONLY.Consider replacing the global temporary table with the following memory-optimized table that has DURABILITY = SCHEMA_ONLY.

CREATE TABLE dbo.soGlobalB  
(  
    Column1   INT   NOT NULL   INDEX ix1 NONCLUSTERED,  
    Column2   NVARCHAR(4000)  
)  
    WITH  
        (MEMORY_OPTIMIZED = ON,  
        DURABILITY        = SCHEMA_ONLY);  

B.1 PassaggiB.1 Steps

Per convertire la tabella temporanea globale in SCHEMA_ONLY, eseguire i passaggi seguenti:The conversion from global temporary to SCHEMA_ONLY is the following steps:

  1. Creare la tabella dbo.soGlobalB, una sola volta, allo stesso modo di una normale tabella su disco.Create the dbo.soGlobalB table, one time, just as you would any traditional on-disk table.
  2. Rimuovere da Transact-SQL la creazione della tabella ##tempGlobalB.From your Transact-SQL, remove the create of the ##tempGlobalB table.
  3. In T-SQL sostituire tutti i riferimenti di ##tempGlobalB con dbo.soGlobalB.In your T-SQL, replace all mentions of ##tempGlobalB with dbo.soGlobalB.

C.C. Scenario: sostituire la tabella temporanea di sessioneScenario: Replace session tempdb #table

Le operazioni preliminari per la sostituzione di una tabella temporanea di sessione implicano un uso maggiore di T-SQL rispetto allo scenario della tabella temporanea globale precedente.The preparations for replacing a session temporary table involve more T-SQL than for the earlier global temporary table scenario. Fortunatamente, una maggior quantità di T-SQL non implica alcuna altra operazione per eseguire la conversione.Happily the extra T-SQL does not mean any more effort is needed to accomplish the conversion.

Si supponga di avere la tabella temporanea di sessione seguente.Suppose you have the following session temporary table.

CREATE TABLE #tempSessionC  
(  
    Column1   INT   NOT NULL ,  
    Column2   NVARCHAR(4000)  
);  

Creare prima di tutto la funzione con valori di tabella seguente per applicare un filtro in @@spid.First, create the following table-value function to filter on @@spid. La funzione potrà essere usata da tutte le tabelle SCHEMA_ONLY convertite da tabelle temporanee di sessione.The function will be usable by all SCHEMA_ONLY tables that you convert from session temporary tables.

CREATE FUNCTION dbo.fn_SpidFilter(@SpidFilter smallint)  
    RETURNS TABLE  
    WITH SCHEMABINDING , NATIVE_COMPILATION  
AS  
    RETURN  
        SELECT 1 AS fn_SpidFilter  
            WHERE @SpidFilter = @@spid;  

Creare quindi la tabella SCHEMA_ONLY e i criteri di sicurezza nella tabella.Second, create the SCHEMA_ONLY table, plus a security policy on the table.

Si noti che ogni tabella con ottimizzazione per la memoria deve contenere almeno un indice.Note that each memory-optimized table must have at least one index.

  • Per la tabella dbo.soSessionC potrebbe essere consigliabile un indice HASH, se viene calcolato il BUCKET_COUNT corretto.For table dbo.soSessionC a HASH index might be better, if we calculate the appropriate BUCKET_COUNT. In questo esempio, tuttavia, viene usato per semplicità un indice NONCLUSTERED.But for this sample we simplify to a NONCLUSTERED index.
<span data-ttu-id="0f525-150">CREATE TABLE dbo.soSessionC</span><span class="sxs-lookup"><span data-stu-id="0f525-150">CREATE TABLE dbo.soSessionC</span></span>  
<span data-ttu-id="0f525-151">(</span><span class="sxs-lookup"><span data-stu-id="0f525-151">(</span></span>  
    <span data-ttu-id="0f525-152">Column1     INT         NOT NULL,</span><span class="sxs-lookup"><span data-stu-id="0f525-152">Column1     INT         NOT NULL,</span></span>  
    <span data-ttu-id="0f525-153">Column2     NVARCHAR(4000)  NULL,</span><span class="sxs-lookup"><span data-stu-id="0f525-153">Column2     NVARCHAR(4000)  NULL,</span></span>  

    SpidFilter  SMALLINT    NOT NULL   DEFAULT (@@spid),  

    INDEX ix_SpidFiler NONCLUSTERED (SpidFilter),  
    --INDEX ix_SpidFilter HASH  
    --    (SpidFilter) WITH (BUCKET_COUNT = 64),  

    CONSTRAINT CHK_soSessionC_SpidFilter  
        CHECK ( SpidFilter = @@spid ),  
<span data-ttu-id="0f525-154">)</span><span class="sxs-lookup"><span data-stu-id="0f525-154">)</span></span>  
    <span data-ttu-id="0f525-155">con</span><span class="sxs-lookup"><span data-stu-id="0f525-155">WITH</span></span>  
        <span data-ttu-id="0f525-156">(MEMORY_OPTIMIZED = ON,</span><span class="sxs-lookup"><span data-stu-id="0f525-156">(MEMORY_OPTIMIZED = ON,</span></span>  
         <span data-ttu-id="0f525-157">DURABILITY = SCHEMA_ONLY);</span><span class="sxs-lookup"><span data-stu-id="0f525-157">DURABILITY = SCHEMA_ONLY);</span></span>  
<span data-ttu-id="0f525-158">go</span><span class="sxs-lookup"><span data-stu-id="0f525-158">go</span></span>  


<span data-ttu-id="0f525-159">CREATE SECURITY POLICY dbo.soSessionC_SpidFilter_Policy</span><span class="sxs-lookup"><span data-stu-id="0f525-159">CREATE SECURITY POLICY dbo.soSessionC_SpidFilter_Policy</span></span>  
    <span data-ttu-id="0f525-160">ADD FILTER PREDICATE dbo.fn_SpidFilter(SpidFilter)</span><span class="sxs-lookup"><span data-stu-id="0f525-160">ADD FILTER PREDICATE dbo.fn_SpidFilter(SpidFilter)</span></span>  
    <span data-ttu-id="0f525-161">ON dbo.soSessionC</span><span class="sxs-lookup"><span data-stu-id="0f525-161">ON dbo.soSessionC</span></span>  
    <span data-ttu-id="0f525-162">WITH (STATE = ON);</span><span class="sxs-lookup"><span data-stu-id="0f525-162">WITH (STATE = ON);</span></span>  
<span data-ttu-id="0f525-163">go</span><span class="sxs-lookup"><span data-stu-id="0f525-163">go</span></span>  

Infine, nel codice T-SQL generale:Third, in your general T-SQL code:

  1. Modificare tutti i riferimenti alla tabella temporanea nelle istruzioni Transact-SQL impostando la nuova tabella con ottimizzazione per la memoria:Change all references to the temp table in your Transact-SQL statements to the new memory-optimized table:
    • Precedente: #tempSessionCOld: #tempSessionC
    • Nuovo: dbo.soSessionCNew: dbo.soSessionC
  2. Sostituire le istruzioni CREATE TABLE #tempSessionC nel codice con DELETE FROM dbo.soSessionC per assicurarsi che una sessione non venga esposta al contenuto della tabella inserito da una sessione precedente con lo stesso session_idReplace the CREATE TABLE #tempSessionC statements in your code with DELETE FROM dbo.soSessionC, to ensure a session is not exposed to table contents inserted by a previous session with the same session_id
  3. Rimuovere le istruzioni DROP TABLE #tempSessionC dal codice. Facoltativamente, è possibile inserire un'istruzione DELETE FROM dbo.soSessionC, nel caso le dimensioni della memoria costituiscano un potenziale problemaRemove the DROP TABLE #tempSessionC statements from your code – optionally you can insert a DELETE FROM dbo.soSessionC statement, in case memory size is a potential concern

D.D. Scenario: la variabile di tabella può essere MEMORY_OPTIMIZED=ONScenario: Table variable can be MEMORY_OPTIMIZED=ON

Una variabile di tabella tradizionale rappresenta una tabella del database tempdb.A traditional table variable represents a table in the tempdb database. Per ottenere migliori prestazioni è possibile convertire la variabile di tabella in variabile di tabella con ottimizzazione per la memoria.For much faster performance you can memory-optimize your table variable.

Di seguito è riportato il codice T-SQL per una variabile di tabella tradizionale.Here is the T-SQL for a traditional table variable. L'ambito termina alla fine del batch o della sessione.Its scope ends when either the batch or the session ends.

DECLARE @tvTableD TABLE  
    ( Column1   INT   NOT NULL ,  
      Column2   CHAR(10) );  

D.1 Convertire da inline a esplicitoD.1 Convert inline to explicit

La sintassi precedente crea la variabile di tabella inline.The preceding syntax is said to create the table variable inline. La sintassi inline non supporta l'ottimizzazione per la memoria.The inline syntax does not support memory-optimization. È necessario quindi convertire la sintassi inline nella sintassi esplicita per TYPE.So let us convert the inline syntax to the explicit syntax for the TYPE.

Ambito: la definizione TYPE creata dal primo batch delimitato da go rimane valida anche dopo che il server è stato arrestato e riavviato.Scope: The TYPE definition created by the first go-delimited batch persists even after the server is shutdown and restarted. Tuttavia, dopo il primo delimitatore go, la tabella dichiarata @tvTableC rimane valida solo fino a quando non vengono raggiunti il go successivo e la fine del batch.But after the first go delimiter, the declared table @tvTableC persists only until the next go is reached and the batch ends.

CREATE TYPE dbo.typeTableD  
    AS TABLE  
    (  
        Column1  INT   NOT NULL ,  
        Column2  CHAR(10)  
    );  
go  

SET NoCount ON;  
DECLARE @tvTableD dbo.typeTableD  
;  
INSERT INTO @tvTableD (Column1) values (1), (2)  
;  
SELECT * from @tvTableD;  
go  

D.2 Convertire esplicito su disco in ottimizzato per la memoriaD.2 Convert explicit on-disk to memory-optimized

Una variabile di tabella con ottimizzazione per la memoria è memorizzata in tempdb.A memory-optimized table variable does not reside in tempdb. L'ottimizzazione per la memoria offre una velocità spesso maggiore di 10 volte o più.Memory-optimization results in speed increases that are often 10 times faster or more.

La conversione in ottimizzato per la memoria viene eseguita in un solo passaggio.The conversion to memory-optimized is achieved in only one step. Migliorare la creazione TYPE esplicita come segue, aggiungendo:Enhance the explicit TYPE creation to be the following, which adds:

  • Un indice.An index. Si noti che ogni tabella con ottimizzazione per la memoria deve contenere almeno un indice.Again, each memory-optimized table must have at least one index.
  • MEMORY_OPTIMIZED = ON.MEMORY_OPTIMIZED = ON.
<span data-ttu-id="0f525-190">CREATE TYPE dbo.typeTableD</span><span class="sxs-lookup"><span data-stu-id="0f525-190">CREATE TYPE dbo.typeTableD</span></span>  
    <span data-ttu-id="0f525-191">AS TABLE</span><span class="sxs-lookup"><span data-stu-id="0f525-191">AS TABLE</span></span>  
    <span data-ttu-id="0f525-192">(</span><span class="sxs-lookup"><span data-stu-id="0f525-192">(</span></span>  
        <span data-ttu-id="0f525-193">Column1  INT   NOT NULL   INDEX ix1,</span><span class="sxs-lookup"><span data-stu-id="0f525-193">Column1  INT   NOT NULL   INDEX ix1,</span></span>  
        <span data-ttu-id="0f525-194">Column2  CHAR(10)</span><span class="sxs-lookup"><span data-stu-id="0f525-194">Column2  CHAR(10)</span></span>  
    <span data-ttu-id="0f525-195">)</span><span class="sxs-lookup"><span data-stu-id="0f525-195">)</span></span>  
    <span data-ttu-id="0f525-196">con</span><span class="sxs-lookup"><span data-stu-id="0f525-196">WITH</span></span>  
        <span data-ttu-id="0f525-197">(MEMORY_OPTIMIZED = ON);</span><span class="sxs-lookup"><span data-stu-id="0f525-197">(MEMORY_OPTIMIZED = ON);</span></span>  

La conversione è stata completata.Done.

E.E. FILEGROUP prerequisito per SQL ServerPrerequisite FILEGROUP for SQL Server

In Microsoft SQL Server per usare le funzionalità di ottimizzazione per la memoria, è necessario che il database includa un FILEGROUP dichiarato con MEMORY_OPTIMIZED_DATA.On Microsoft SQL Server, to use memory-optimized features, your database must have a FILEGROUP that is declared with MEMORY_OPTIMIZED_DATA.

  • Il database SQL di Azure non richiede la creazione del FILEGROUP.Azure SQL Database does not require creating this FILEGROUP.

Prerequisito: il seguente codice Transact-SQL per un FILEGROUP è un prerequisito per i lunghi esempi di codice T-SQL riportati nelle sezioni successive di questo articolo.Prerequisite: The following Transact-SQL code for a FILEGROUP is a prerequisite for the long T-SQL code samples in later sections of this article.

  1. È necessario usare SSMS.exe o un altro strumento che può inviare T-SQL.You must use SSMS.exe or another tool that can submit T-SQL.
  2. Incollare il codice T-SQL di FILEGROUP di esempio in SQL Server Management Studio.Paste the sample FILEGROUP T-SQL code into SSMS.
  3. Modificare il codice T-SQL per cambiare i nomi e i percorsi di directory in base alle proprie esigenze.Edit the T-SQL to change its specific names and directory paths to your liking.
    • Tutte le directory nel valore FILENAME devono essere già esistenti, ad eccezione della directory finale.All directories in the FILENAME value must preexist, except the final directory must not preexist.
  4. Eseguire il codice T-SQL modificato.Run your edited T-SQL.
    • Non è necessario eseguire il FILEGROUP T-SQL più di una volta, anche nel caso in cui il codice T-SQL di confronto della velocità venga modificato e rieseguito più volte.There is no need to run the FILEGROUP T-SQL more than one time, even if you repeatedly adjust and rerun the speed comparison T-SQL in the next subsection.
<span data-ttu-id="0f525-210">ALTER DATABASE InMemTest2</span><span class="sxs-lookup"><span data-stu-id="0f525-210">ALTER DATABASE InMemTest2</span></span>  
    <span data-ttu-id="0f525-211">ADD FILEGROUP FgMemOptim3</span><span class="sxs-lookup"><span data-stu-id="0f525-211">ADD FILEGROUP FgMemOptim3</span></span>  
        <span data-ttu-id="0f525-212">CONTAINS MEMORY_OPTIMIZED_DATA;</span><span class="sxs-lookup"><span data-stu-id="0f525-212">CONTAINS MEMORY_OPTIMIZED_DATA;</span></span>  
<span data-ttu-id="0f525-213">go</span><span class="sxs-lookup"><span data-stu-id="0f525-213">go</span></span>  
<span data-ttu-id="0f525-214">ALTER DATABASE InMemTest2</span><span class="sxs-lookup"><span data-stu-id="0f525-214">ALTER DATABASE InMemTest2</span></span>  
    <span data-ttu-id="0f525-215">ADD FILE</span><span class="sxs-lookup"><span data-stu-id="0f525-215">ADD FILE</span></span>  
    <span data-ttu-id="0f525-216">(</span><span class="sxs-lookup"><span data-stu-id="0f525-216">(</span></span>  
        <span data-ttu-id="0f525-217">NAME = N'FileMemOptim3a',</span><span class="sxs-lookup"><span data-stu-id="0f525-217">NAME = N'FileMemOptim3a',</span></span>  
        <span data-ttu-id="0f525-218">FILENAME = N'C:\DATA\FileMemOptim3a'</span><span class="sxs-lookup"><span data-stu-id="0f525-218">FILENAME = N'C:\DATA\FileMemOptim3a'</span></span>  
                 <span data-ttu-id="0f525-219">--  C:\DATA\    preexisted.</span><span class="sxs-lookup"><span data-stu-id="0f525-219">--  C:\DATA\    preexisted.</span></span>  
    <span data-ttu-id="0f525-220">)</span><span class="sxs-lookup"><span data-stu-id="0f525-220">)</span></span>  
    <span data-ttu-id="0f525-221">TO FILEGROUP FgMemOptim3;</span><span class="sxs-lookup"><span data-stu-id="0f525-221">TO FILEGROUP FgMemOptim3;</span></span>  
<span data-ttu-id="0f525-222">go</span><span class="sxs-lookup"><span data-stu-id="0f525-222">go</span></span>  

Lo script seguente crea automaticamente il filegroup e configura le impostazioni di database consigliate: enable-in-memory-oltp.sqlThe following script creates the filegroup for you and configures recommended database settings: enable-in-memory-oltp.sql

Per altre informazioni su ALTER DATABASE ... ADD per FILE e FILEGROUP, vedere:For more information about ALTER DATABASE ... ADD for FILE and FILEGROUP, see:

F.F. Test rapido per dimostrare il miglioramento della velocitàQuick test to prove speed improvement

Questa sezione include il codice Transact-SQL che è possibile eseguire per testare e confrontare l'aumento della velocità di INSERT-DELETE dovuto all'uso di una variabile di tabella con ottimizzazione per la memoria.This section provides Transact-SQL code that you can run to test and compare the speed gain for INSERT-DELETE from using a memory-optimized table variable. Il codice è suddiviso in due parti pressoché uguali, ad eccezione del fatto che nella prima parte il tipo di tabella corrisponde a una tabella con ottimizzazione per la memoria.The code is composed of two halves that are nearly the same, except in the first half the table type is memory-optimized.

Il test di confronto richiede circa 7 secondi.The comparison test lasts about 7 seconds. Per eseguire l'esempio:To run the sample:

  1. Prerequisito: è necessario avere già eseguito il codice T-SQL di FILEGROUP della sezione precedente.Prerequisite: You must already have run the FILEGROUP T-SQL from the previous section.
  2. Eseguire lo script INSERT-DELETE T-SQL seguente.Run the following T-SQL INSERT-DELETE script.
    • Si noti l'istruzione 'GO 5001' che invia il codice T-SQL 5001 volte.Notice the 'GO 5001' statement, which resubmits the T-SQL 5001 times. È possibile modificare il numero ed eseguire di nuovo lo script.You can adjust the number and rerun.

Quando si esegue lo script in un database SQL di Azure, assicurarsi di eseguire lo script da una macchina virtuale nella stessa area.When running the script in an Azure SQL Database, make sure to run from a VM in the same region.

PRINT ' ';  
PRINT '---- Next, memory-optimized, faster. ----';  

DROP TYPE IF EXISTS dbo.typeTableC_mem;  
go  
CREATE TYPE dbo.typeTableC_mem  -- !!  Memory-optimized.  
     AS TABLE  
     (  
          Column1  INT NOT NULL INDEX ix1,  
          Column2  CHAR(10)  
     )  
     WITH  
          (MEMORY_OPTIMIZED = ON);  
go  
DECLARE @dateString_Begin nvarchar(64) =  
    Convert(nvarchar(64), GetUtcDate(), 121);  
PRINT Concat(@dateString_Begin, '  = Begin time, _mem.');  
go  
SET NoCount ON;  
DECLARE @tvTableC dbo.typeTableC_mem;  -- !!  

INSERT INTO @tvTableC (Column1) values (1), (2);  
INSERT INTO @tvTableC (Column1) values (3), (4);  
DELETE @tvTableC;  

GO 5001  

DECLARE @dateString_End nvarchar(64) =  
    Convert(nvarchar(64), GetUtcDate(), 121);  
PRINT Concat(@dateString_End, '  = End time, _mem.');  
go  
DROP TYPE IF EXISTS dbo.typeTableC_mem;  
go  

---- End memory-optimized.  
-------------------------------------------------  
---- Start traditional on-disk.  

PRINT ' ';  
PRINT '---- Next, tempdb based, slower. ----';  

DROP TYPE IF EXISTS dbo.typeTableC_tempdb;  
go  
CREATE TYPE dbo.typeTableC_tempdb  -- !!  Traditional tempdb.  
    AS TABLE  
    (  
        Column1  INT NOT NULL ,  
        Column2  CHAR(10)  
    );  
go  
DECLARE @dateString_Begin nvarchar(64) =  
    Convert(nvarchar(64), GetUtcDate(), 121);  
PRINT Concat(@dateString_Begin, '  = Begin time, _tempdb.');  
go  
SET NoCount ON;  
DECLARE @tvTableC dbo.typeTableC_tempdb;  -- !!  

INSERT INTO @tvTableC (Column1) values (1), (2);  
INSERT INTO @tvTableC (Column1) values (3), (4);  
DELETE @tvTableC;  

GO 5001  

DECLARE @dateString_End nvarchar(64) =  
    Convert(nvarchar(64), GetUtcDate(), 121);  
PRINT Concat(@dateString_End, '  = End time, _tempdb.');  
go  
DROP TYPE IF EXISTS dbo.typeTableC_tempdb;  
go  
----  

PRINT '---- Tests done. ----';  

go  

/*** Actual output, SQL Server 2016:  

---- Next, memory-optimized, faster. ----  
2016-04-20 00:26:58.033  = Begin time, _mem.  
Beginning execution loop  
Batch execution completed 5001 times.  
2016-04-20 00:26:58.733  = End time, _mem.  

---- Next, tempdb based, slower. ----  
2016-04-20 00:26:58.750  = Begin time, _tempdb.  
Beginning execution loop  
Batch execution completed 5001 times.  
2016-04-20 00:27:05.440  = End time, _tempdb.  
---- Tests done. ----  
***/  

G.G. Stimare il consumo di memoria attivaPredict active memory consumption

È possibile imparare a prevedere la quantità di memoria attiva richiesta dalle tabelle con ottimizzazione per la memoria con le risorse seguenti:You can learn to predict the active memory needs of your memory-optimized tables with the following resources:

Per le variabili di tabella di dimensioni maggiori, gli indici non cluster usano una maggior quantità di memoria rispetto a quella usata per le tabellecon ottimizzazione per la memoria.For larger table variables, nonclustered indexes use more memory than they do for memory-optimized tables. Maggiore è il totale delle righe e la chiave di indice, maggiore sarà la differenza.The larger the row count and the index key, the more the difference increases.

Se l'accesso alla variabile di tabella con ottimizzazione per la memoria avviene soltanto con un determinato valore di chiave a ogni accesso, è consigliabile usare un indice hash anziché un indice non cluster.If the memory-optimized table variable is accessed only with one exact key value per access, a hash index might be a better choice than a nonclustered index. Tuttavia, se non si è in grado di stimare il valore BUCKET_COUNT appropriato, un indice NONCLUSTERED rappresenta una buona scelta.However, if you cannot estimate the appropriate BUCKET_COUNT, a NONCLUSTERED index is a good second choice.

H.H. Vedere ancheSee also