Dimensioni di tabelle e righe per le tabelle con ottimizzazione per la memoriaTable and Row Size in Memory-Optimized Tables

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

Prima di SQL Server 2016SQL Server 2016 le dimensioni dei dati all'interno delle righe di un tabella ottimizzata per la memoria non potevano essere superiori a 8.060 byte.Prior to SQL Server 2016SQL Server 2016 the in-row data size of a memory-optimized table couldn't be longer than 8,060 bytes. A partire da SQL Server 2016SQL Server 2016 e nel database SQL di Azure è invece possibile creare una tabella ottimizzata per la memoria con più colonne di grandi dimensioni, ad esempio più colonne varbinary (8000), e colonne LOB, ad esempio colonne varbinary (max), varchar (max) e nvarchar (max). È anche possibile eseguire operazioni sulle colonne usando moduli T-SQL compilati in modo nativo e tipi di tabella.However, starting SQL Server 2016SQL Server 2016 and in Azure SQL Database it is now possible to create a memory-optimized table with multiple large columns (e.g., multiple varbinary(8000) columns) and LOB columns (i.e., varbinary(max), varchar(max), and nvarchar(max)) and perform operations on them using natively compiled T-SQL modules and table types.

Le colonne che superano le dimensioni massime delle righe di 8060 byte vengono inserite all'esterno delle righe, in una tabella interna separata.Columns that do not fit in the 8060 byte row size limit are placed off-row, in a separate internal table. Ogni colonna all'esterno delle righe ha una corrispondente tabella interna, che a sua volta ha un indice non cluster.Each off-row column has a corresponding internal table, which in turn has a single nonclustered index. Per informazioni dettagliate su queste tabelle interne usate per colonne all'esterno di righe, vedere sys.memory_optimized_tables_internal_attributes (Transact-SQL).For details about these internal tables used for off-row columns see sys.memory_optimized_tables_internal_attributes (Transact-SQL).

Esistono alcuni scenari in cui è utile calcolare le dimensioni della riga e della tabella:There are certain scenarios where it is useful to compute the size of the row and the table:

  • Quanta memoria viene utilizzata da una tabella?How much memory does a table use?

    • La quantità di memoria utilizzata dalla tabella non può essere calcolata esattamente.The amount of memory used by the table cannot be calculated exactly. Molti fattori influiscono su tale quantità,Many factors affect the amount of memory used. ad esempio l'allocazione della memoria basata sul paging, la località, la memorizzazione nella cache e il riempimento.Factors such as page-based memory allocation, locality, caching, and padding. Un altro fattore può essere la presenza di più versioni delle righe a cui sono associate transazioni attive o che sono in attesa di Garbage Collection.Also, multiple versions of rows that either have active transactions associated or that are waiting for garbage collection.

    • Le dimensioni minime richieste per i dati e gli indici nella tabella si ottengono con il calcolo di [table size] descritto di seguito.The minimum size required for the data and indexes in the table is given by the calculation for [table size], discussed below.

    • Il calcolo dell'utilizzo della memoria è nella migliore delle ipotesi un'approssimazione ed è consigliabile includere la pianificazione della capacità nei piani di distribuzione.Calculating memory use is at best an approximation and you are advised to include capacity planning in your deployment plans.

  • Quali sono le dimensioni dei dati di una riga? Tali dimensioni rientrano nel limite di 8.060 byte?The data size of a row, and does it fit in the 8,060 byte row size limitation? Per rispondere a queste domande, utilizzare il calcolo di [row body size] descritto di seguito.To answer these questions, use the computation for [row body size], discussed below.

    Una tabella con ottimizzazione per la memoria è costituita da una raccolta di righe e di indici contenenti i puntatori alle righe.A memory-optimized table consists of a collection of rows and indexes that contain pointers to rows. Nella figura seguente viene illustrata una tabella con indici e righe, che a loro volta contengono intestazioni e corpi di riga:The following figure illustrates a table with indexes and rows, which in turn have row headers and bodies:

    Tabella ottimizzata per la memoria.Memory optimized table.
    Tabella con ottimizzazione per la memoria, costituita da indici e righe.Memory-optimized table, consisting of indexes and rows.

Calcolo delle dimensioni di una tabella Computing Table Size

Le dimensioni in memoria di una tabella, in byte, vengono calcolate come segue:The in-memory size of a table, in bytes, is computed as follows:

[table size] = [size of index 1] + … + [size of index n] + ([row size] * [row count])  

Le dimensioni di un indice hash vengono fissate al momento della creazione della tabella e dipendono dal numero effettivo di bucket.The size of a hash index is fixed at table creation time and depends on the actual bucket count. Il valore di bucket_count specificato con la specifica dell'indice viene arrotondato per eccesso alla più vicina potenza di 2 per ottenere il valore [actual bucket count].The bucket_count specified with the index specification is rounded up to the nearest power of 2 to obtain the [actual bucket count]. Ad esempio, se il valore di bucket_count specificato è 100.000, il valore di [actual bucket count] per l'indice è 131.072.For example, if the specified bucket_count is 100000, the [actual bucket count] for the index is 131072.

[hash index size] = 8 * [actual bucket count]  

Le dimensioni di un indice non cluster corrispondono a [row count] * [index key size].The size of a nonclustered index is in the order of [row count] * [index key size].

Le dimensioni delle righe vengono calcolate aggiungendo l'intestazione e il corpo:The row size is computed by adding the header and the body:

[row size] = [row header size] + [actual row body size]  
[row header size] = 24 + 8 * [number of indices]  

Calcolo delle dimensioni del corpo di una riga Computing Row Body Size

Struttura delle righeRow Structure

Le righe di una tabella con ottimizzazione per la memoria includono i componenti seguenti:The rows in a memory-optimized table have the following components:

  • L'intestazione di riga contiene il timestamp necessario per implementare il controllo delle versioni delle righe.The row header contains the timestamp necessary to implement row versioning. L'intestazione di riga contiene inoltre il puntatore dell'indice per implementare il concatenamento di righe nei bucket di hash (descritti in precedenza).The row header also contains the index pointer to implement the row chaining in the hash buckets (described above).

  • Il corpo della riga contiene i dati effettivi della colonna, che includono le informazioni ausiliarie come la matrice Null per le colonne che ammettono i valori Null e la matrice di offset per i tipi di dati a lunghezza variabile.The row body contains the actual column data, which includes some auxiliary information like the null array for nullable columns and the offset array for variable-length data types.

    Nella figura seguente viene illustrata la struttura di righe per una tabella con due indici:The following figure illustrates the row structure for a table that has two indexes:

    Struttura di righe per una tabella con due indici.Row structure for a table that has two indexes.

    I timestamp di inizio e fine indicano il periodo in cui è valida una versione di riga specifica.The begin and end timestamps indicate the period in which a particular row version is valid. Le transazioni che iniziano in questo intervallo possono rilevare questa versione di riga.Transactions that start in this interval can see this row version. Per altri dettagli, vedere Transactions in Memory-Optimized Tables(Transazioni con tabelle con ottimizzazione per la memoria).For more details see Transactions with Memory-Optimized Tables.

    I puntatori dell'indice puntano alla riga successiva della catena che appartiene al bucket di hash.The index pointers point to the next row in the chain belonging to the hash bucket. Nella figura seguente viene illustrata la struttura di una tabella con due colonne (nome, città) e con due indici, uno per il nome della colonna e uno per la città.The following figure illustrates the structure of a table with two columns (name, city), and with two indexes, one on the column name, and one on the column city.

    Struttura di una tabella con due colonne e indici.Structure of a table with two columns and indexes.

    Nella figura, per i nomi John e Jane viene eseguito l'hashing al primo bucket.In this figure, the names John and Jane are hashed to the first bucket. Per Susan viene eseguito l'hashing al secondo bucket.Susan is hashed to the second bucket. Per le città Pechino e Bogotà viene eseguito l'hashing al primo bucket.The cities Beijing and Bogota are hashed to the first bucket. Per Parigi e Praga viene eseguito l'hashing al secondo bucket.Paris and Prague are hashed to the second bucket.

    Le catene per l'indice hash sul nome sono pertanto le seguenti:Thus, the chains for the hash index on name are as follows:

  • Primo bucket: (John, Pechino); (John, Parigi); (Jane, Praga)First bucket: (John, Beijing); (John, Paris); (Jane, Prague)

  • Secondo bucket: (Susan, Bogotà)Second bucket: (Susan, Bogota)

    Le catene per l'indice sulla città sono le seguenti:The chains for the index on city are as follows:

  • Primo bucket: (John, Pechino), (Susan, Bogotà)First bucket: (John, Beijing), (Susan, Bogota)

  • Secondo bucket: (John, Parigi), (Jane, Praga)Second bucket: (John, Paris), (Jane, Prague)

    Un timestamp di fine ∞ (infinito) indica che si tratta della versione attualmente valida per le righe.An end timestamp ∞ (infinity) indicates that this is the currently valid version of the row. La riga non è stata aggiornata o eliminata dopo la scrittura di questa versione di riga.The row has not been updated or deleted since this row version was written.

    Per un'ora maggiore di 200, la tabella contiene le righe seguenti:For a time greater than 200, the table contains the following rows:

NomeName CityCity
JohnJohn PechinoBeijing
JaneJane PragaPrague

Tuttavia, le eventuali transazioni attive con un'ora di inizio 100 rileveranno la seguente versione della tabella:However, any active transaction with begin time 100 will see the following version of the table:

NomeName CityCity
JohnJohn ParigiParis
JaneJane PragaPrague
SusanSusan BogotàBogata

Il calcolo di [row body size] viene descritto nella tabella seguente.The calculation of [row body size] is discussed in the following table.

Le dimensioni del corpo delle righe possono essere considerate da due punti di vista diversi, le dimensioni calcolate e le dimensioni effettive, come illustrato di seguito.There are two different computations for row body size: computed size and the actual size:

  • Le dimensioni calcolate, indicate con [computed row body size], vengono utilizzate per determinare se il limite di dimensione di 8.060 byte viene superato.The computed size, denoted with [computed row body size], is used to determine if the row size limitation of 8,060 bytes is exceeded.

  • Le dimensioni effettive, indicate con [actual row body size], rappresentano le dimensioni di archiviazione effettive del corpo delle righe in memoria e nei file del checkpoint.The actual size, denoted with [actual row body size], is the actual storage size of the row body in memory and in the checkpoint files.

    Entrambi i valori di [computed row body size] e [actual row body size] vengono calcolati in modo analogo.Both [computed row body size] and [actual row body size] are calculated similarly. L'unica differenza è il calcolo delle dimensioni delle colonne (n)varchar(i) e varbinary(i), come evidenziato nella parte inferiore della tabella seguente.The only difference is the calculation of the size of (n)varchar(i) and varbinary(i) columns, as reflected at the bottom of the following table. Per le dimensioni calcolate del corpo delle righe viene usata la dimensione dichiarata i come dimensione della colonna, mentre per le dimensioni effettive del corpo delle righe viene usata la dimensione effettiva dei dati.The computed row body size uses the declared size i as the size of the column, while the actual row body size uses the actual size of the data.

    Nella tabella seguente viene descritto il calcolo delle dimensioni del corpo delle righe, fornito come [actual row body size] = SUM ([size of shallow types) + 2 + 2 * [number of deep type columns].The following table describes the calculation of the row body size, given as [actual row body size] = SUM([size of shallow types]) + 2 + 2 * [number of deep type columns].

SezioneSection DimensioneSize CommentiComments
Colonne di tipo superficialeShallow type columns SUM([size of shallow types]).SUM([size of shallow types]). Le dimensioni in byte dei singoli tipi sono le seguenti:Size in bytes of the individual types is as follows:

Bit: 1Bit: 1

Tinyint: 1Tinyint: 1

Smallint: 2Smallint: 2

Int: 4Int: 4

Real: 4Real: 4

Smalldatetime: 4Smalldatetime: 4

Smallmoney: 4Smallmoney: 4

Bigint: 8Bigint: 8

Datetime: 8Datetime: 8

Datetime2: 8Datetime2: 8

Float: 8Float: 8

Money: 8Money: 8

Numeric (precisione <=18): 8Numeric (precision <=18): 8

Time: 8Time: 8

Numeric(precisione >18): 16Numeric(precision>18): 16

Uniqueidentifier: 16Uniqueidentifier: 16
Riempimento delle colonne superficialiShallow column padding I valori possibili sono:Possible values are:

1 se esistono colonne di tipo approfondito e le dimensioni totali dei dati delle colonne superficiali sono un numero dispari.1 if there are deep type columns and the total data size of the shallow columns is as odd number.

In caso contrario, 00 otherwise
I tipi approfonditi sono i tipi (var)binary e (n)(var)char.Deep types are the types (var)binary and (n)(var)char.
Matrice di offset delle colonne di tipo approfonditoOffset array for deep type columns I valori possibili sono:Possible values are:

0 se non sono disponibili colonne di tipo approfondito0 if there are no deep type columns

2 + 2 * [number of deep type columns] in caso contrario2 + 2 * [number of deep type columns] otherwise
I tipi approfonditi sono i tipi (var)binary e (n)(var)char.Deep types are the types (var)binary and (n)(var)char.
Matrice NULLNULL array [number of nullable columns] / 8, arrotondato per eccesso ai byte completi.[number of nullable columns] / 8, rounded up to full bytes. La matrice dispone di un bit per ogni colonna che ammette i valori Null.The array has one bit per nullable column. Il valore viene arrotondato per eccesso ai byte completi.This is rounded up to full bytes.
Riempimento della matrice NULLNULL array padding I valori possibili sono:Possible values are:

1 se esistono colonne di tipo approfondito e le dimensioni della matrice NULL sono un numero dispari di byte.1 if there are deep type columns and the size of the NULL array is an odd number of bytes.

In caso contrario, 00 otherwise
I tipi approfonditi sono i tipi (var)binary e (n)(var)char.Deep types are the types (var)binary and (n)(var)char.
Spaziatura internaPadding 0 se non sono disponibili colonne di tipo approfonditoIf there are no deep type columns: 0

Se sono disponibili colonne di tipo approfondito, vengono aggiunti 0-7 byte di riempimento, in base al maggiore allineamento richiesto da una colonna superficiale.If there are deep type columns, 0-7 bytes of padding is added, based on the largest alignment required by a shallow column. Ogni colonna superficiale richiede un allineamento uguale alle sue dimensioni, come descritto in precedenza, ad eccezione delle colonne GUID che richiedono l'allineamento di 1 byte (non 16) e delle colonne numeriche che richiedono sempre l'allineamento di 8 byte (mai 16).Each shallow column requires alignment equal to its size as documented above, except that GUID columns need alignment of 1 byte (not 16) and numeric columns always need alignment of 8 bytes (never 16). Viene utilizzato il requisito di maggiore allineamento tra tutte le colonne superficiali e vengono aggiunti 0-7 byte di riempimento in modo tale che le dimensioni totali fino a questo punto (senza le colonne di tipo approfondito) siano un multiplo dell'allineamento richiesto.The largest alignment requirement among all shallow columns is used, and 0-7 bytes of padding is added in such a way that the total size so far (without the deep type columns) is a multiple of the required alignment.
I tipi approfonditi sono i tipi (var)binary e (n)(var)char.Deep types are the types (var)binary and (n)(var)char.
Colonne di tipo approfondito a lunghezza fissaFixed-length deep type columns SUM([size of fixed length deep type columns])SUM([size of fixed length deep type columns])

Le dimensioni di ogni colonna sono le seguenti:The size of each column is as follows:

i per char(i) e binary(i).i for char(i) and binary(i).

2 * i per nchar(i)2 * i for nchar(i)
Le colonne di tipo approfondito a lunghezza fissa sono le colonne di tipo char(i), nchar(i) o binary(i).Fixed-length deep type columns are columns of type char(i), nchar(i), or binary(i).
Colonne di tipo approfondito a lunghezza variabile [computed size]Variable length deep type columns [computed size] SUM([computed size of variable length deep type columns])SUM([computed size of variable length deep type columns])

Le dimensioni calcolate di ogni colonna sono le seguenti:The computed size of each column is as follows:

i per varchar(i) e varbinary(i)i for varchar(i) and varbinary(i)

2 * i per nvarchar(i)2 * i for nvarchar(i)
Questa riga si riferiva solo a [computed row body size].This row only applied to [computed row body size].

Le colonne di tipo approfondito a lunghezza variabile sono le colonne di tipo varchar(i), nvarchar(i) o varbinary(i).Variable-length deep type columns are columns of type varchar(i), nvarchar(i), or varbinary(i). Le dimensioni calcolate sono determinate dalla lunghezza massima (i) della colonna.The computed size is determined by the max length (i) of the column.
Colonne di tipo approfondito a lunghezza variabile [actual size]Variable length deep type columns [actual size] SUM([actual size of variable length deep type columns])SUM([actual size of variable length deep type columns])

Le dimensioni effettive di ogni colonna sono le seguenti:The actual size of each column is as follows:

n, dove n è il numero di caratteri archiviato nella colonna, per varchar(i).n, where n is the number of characters stored in the column, for varchar(i).

2 * n, dove n è il numero di caratteri archiviato nella colonna, per nvarchar(i).2 * n, where n is the number of characters stored in the column, for nvarchar(i).

n, dove n è il numero di byte archiviato nella colonna, per varbinary(i).n, where n is the number of bytes stored in the column, for varbinary(i).
Questa riga si riferiva solo a [actual row body size].This row only applied to [actual row body size].

Le dimensioni effettive sono determinate dai dati archiviati nelle colonne della riga.The actual size is determined by the data stored in the columns in the row.

Esempio: calcolo delle dimensioni della tabella e delle righe Example: Table and Row Size Computation

Per gli indici hash il numero effettivo di bucket viene arrotondato alla più vicina potenza di 2.For hash indexes, the actual bucket count is rounded up to the nearest power of 2. Ad esempio, se il valore di bucket_count specificato è 100.000, il numero effettivo di bucket per l'indice è 131.072.For example, if the specified bucket_count is 100000, the actual bucket count for the index is 131072.

Si consideri una tabella Orders con la definizione seguente:Consider an Orders table with the following definition:

CREATE TABLE dbo.Orders (  
     OrderID int NOT NULL   
           PRIMARY KEY NONCLUSTERED,  
     CustomerID int NOT NULL   
           INDEX IX_CustomerID HASH WITH (BUCKET_COUNT=10000),  
     OrderDate datetime NOT NULL,  
     OrderDescription nvarchar(1000)  
) WITH (MEMORY_OPTIMIZED=ON)  
GO  

Si noti che questa tabella include un indice hash e un indice non cluster (chiave primaria).Notice that this table has one hash index and a nonclustered index (the primary key). Dispone inoltre di tre colonne a lunghezza fissa e una colonna a lunghezza variabile; una delle colonne ammette i valori Null (OrderDescription).It also has three fixed-length columns and one variable-length column, with one of the columns being NULLable (OrderDescription). Si supponga che la tabella Orders contenga 8379 righe e che la lunghezza media dei valori della colonna OrderDescription sia 78 caratteri.Let’s assume the Orders table has 8379 rows, and the average length of the values in the OrderDescription column is 78 characters.

Per determinare le dimensioni della tabella, è innanzitutto necessario determinare le dimensioni degli indici.To determine the table size, first determine the size of the indexes. Il valore di bucket_count per entrambi gli indici è specificato come 10.000.The bucket_count for both indexes is specified as 10000. Questo valore viene arrotondato per eccesso alla più vicina potenza di 2: 16.384.This is rounded up to the nearest power of 2: 16384. Pertanto, le dimensioni totali degli indici della tabella Orders sono:Therefore, the total size of the indexes for the Orders table is:

8 * 16384 = 131072 bytes  

Il valore restante corrisponde alle dimensioni dei dati della tabella, ovvero:What remains is the table data size, which is,

[row size] * [row count] = [row size] * 8379  

(La tabella di esempio contiene 8.379 righe). A questo punto:(The example table has 8379 rows.) Now, we have:

[row size] = [row header size] + [actual row body size]  
[row header size] = 24 + 8 * [number of indices] = 24 + 8 * 1 = 32 bytes  

Si calcoli quindi [actual row body size]:Next, let’s calculate [actual row body size]:

  • Colonne di tipo superficiale:Shallow type columns:

    SUM([size of shallow types]) = 4 [int] + 4 [int] + 8 [datetime] = 16  
    
  • Il riempimento delle colonne superficiali è 0, in quanto le dimensioni totali delle colonne superficiali sono un numero pari.Shallow column padding is 0, as the total shallow column size is even.

  • Matrice di offset delle colonne di tipo approfondito:Offset array for deep type columns:

    2 + 2 * [number of deep type columns] = 2 + 2 * 1 = 4  
    
  • Matrice NULL = 1NULL array = 1

  • Riempimento matrice NULL = 1, in quanto le dimensioni della matrice NULL sono un numero dispari ed è presente una colonna di tipo approfondito.NULL array padding = 1, as the NULL array size is odd and there is a deep type column.

  • Spaziatura internaPadding

    • 8 è il requisito di allineamento maggiore.8 is the largest alignment requirement.

    • Fino a questo punto le dimensioni corrispondono a 16 + 0 + 4 + 1 + 1 = 22.Size so far is 16 + 0 + 4 + 1 + 1 = 22.

    • Il multiplo più vicino di 8 è 24.Nearest multiple of 8 is 24.

    • Il riempimento totale è 24 - 22 = 2 byte.Total padding is 24 – 22 = 2 bytes.

  • Non sono presenti colonne di tipo approfondito a lunghezza fissa (colonne di tipo approfondito a lunghezza fissa: 0).There are no fixed-length deep type columns (Fixed-length deep type columns: 0.).

  • Le dimensioni effettive della colonna di tipo approfondito sono 2 * 78 = 156.The actual size of deep type column is 2 * 78 = 156. La sola colonna di tipo approfondito OrderDescription è di tipo nvarchar.The single deep type column OrderDescription has type nvarchar.

[actual row body size] = 24 + 156 = 180 bytes  

Per completare il calcolo:To complete the calculation:

[row size] = 32 + 180 = 212 bytes  
[table size] = 8 * 16384 + 212 * 8379 = 131072 + 1776348 = 1907420  

Le dimensioni totali in memoria della tabella sono quindi 2 MB circa.Total table size in memory is thus approximately 2 megabytes. Questo calcolo non tiene conto del potenziale overhead sostenuto dall'allocazione di memoria nonché dell'eventuale controllo delle versioni delle righe richiesto per le transazioni che accedono a questa tabella.This does not account for potential overhead incurred by memory allocation as well as any row versioning required for the transactions accessing this table.

L'effettiva memoria allocata e utilizzata dalla tabella e dai relativi indici può essere ottenuta tramite la query seguente:The actual memory allocated for and used by this table and its indexes can be obtained through the following query:

select * from sys.dm_db_xtp_table_memory_stats  
where object_id = object_id('dbo.Orders')  

Limitazioni relative alle colonne all'esterno di righe Off-row Column Limitations

Di seguito sono elencate alcune limitazioni e avvertenze relative all'uso di colonne all'esterno di righe in una tabella ottimizzata per la memoria:Certain limitations and caveats to using off-row columns in a memory-optimized table are listed below:

  • Se per la tabella ottimizzata per la memoria esiste un indice columnstore, tutte le colonne devono essere contenute all'interno delle righe.If there is a columnstore index on a memory-optimized table, then all the columns must fit in-row.
  • Tutte le colonne chiave di indice devono essere archiviate all'interno delle righe.All index key columns must be stored in-row. Se una colonna chiave di indice non può essere contenuta all'interno delle righe, non è possibile aggiungere l'indice.If an index key column doesn't fit in-row, adding the index fails.
  • Avvertenze relative alla modifica di una tabella ottimizzata per la memoria con colonne all'esterno di righe.Caveats on altering a memory-optimized table with off-row columns.
  • Per le colonne LOB, la limitazione prevista per le dimensioni è la stessa valida per le tabelle basate su disco (limite di 2 GB per colonne LOB).For LOBs the size limitation mirrors that of disk based tables (2GB limit on LOB values).
  • Per prestazioni ottimali, è consigliabile usare per lo più colonne con dimensioni non superiori a 8.060 byte.For optimal performance, it is recommended to have most columns fit within 8060 bytes.

Il post di blog What's new for In-Memory OLTP in SQL Server 2016 since CTP3 (Novità di OLTP in memoria in SQL Server 2016 a partire da CTP3) spiega nel dettaglio alcuni di questi aspetti complessi.What's new for In-Memory OLTP in SQL Server 2016 since CTP3 blog post further details some of these intricacies.

Vedere ancheSee Also

Tabelle con ottimizzazione per la memoriaMemory-Optimized Tables