Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Stima del consumo di capacità per le colonne statiche in Amazon Keyspaces
In una tabella Amazon Keyspaces con colonne di clustering, puoi utilizzare la `STATIC` parola chiave per creare una colonna statica. Il valore memorizzato in una colonna statica è condiviso tra tutte le righe di una partizione logica. Quando aggiorni il valore di questa colonna, Amazon Keyspaces applica automaticamente la modifica a tutte le righe della partizione.
Questa sezione descrive come calcolare la dimensione codificata dei dati quando scrivi su colonne statiche. Questo processo viene gestito separatamente dal processo di scrittura dei dati nelle colonne non statiche di una riga. Oltre alle quote di dimensione per i dati statici, le operazioni di lettura e scrittura sulle colonne statiche influiscono anche sulla capacità di misurazione e di velocità effettiva delle tabelle in modo indipendente. Per le differenze funzionali con Apache Cassandra quando si utilizzano colonne statiche e risultati di lettura con intervalli di pagine, vedere. [Paginazione](functional-differences.md#functional-differences.paging)
**Topics**
+ [Calcola la dimensione statica delle colonne per partizione logica in Amazon Keyspaces](static-columns-estimate.md)
+ [Stima dei requisiti di capacità e throughput per read/write le operazioni su dati statici in Amazon Keyspaces](static-columns-metering.md)
# Calcola la dimensione statica delle colonne per partizione logica in Amazon Keyspaces
Questa sezione fornisce dettagli su come stimare la dimensione codificata delle colonne statiche in Amazon Keyspaces. La dimensione codificata viene utilizzata per il calcolo della bolletta e dell'utilizzo delle quote. È inoltre necessario utilizzare la dimensione codificata quando si calcolano i requisiti di capacità di throughput assegnati per le tabelle. Per calcolare la dimensione codificata delle colonne statiche in Amazon Keyspaces, puoi utilizzare le seguenti linee guida.
+ Le chiavi di partizione possono contenere fino a 2048 byte di dati. Ogni colonna chiave nella chiave di partizione richiede fino a 3 byte di metadati. Questi byte di metadati vengono conteggiati ai fini della quota di dimensione dei dati statici di 1 MB per partizione. Quando si calcola la dimensione dei dati statici, è necessario presupporre che ogni colonna chiave di partizione utilizzi tutti i 3 byte di metadati.
+ Utilizza la dimensione grezza dei valori dei dati della colonna statica in base al tipo di dati. Per ulteriori informazioni sui tipi di dati, consulta [Tipi di dati](cql.elements.md#cql.data-types).
+ Aggiungi 104 byte alla dimensione dei dati statici per i metadati.
+ Le colonne di clustering e le colonne con chiavi non primarie regolari non vengono conteggiate ai fini della dimensione dei dati statici. Per informazioni su come stimare la dimensione dei dati non statici all'interno delle righe, consulta. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md)
La dimensione totale codificata di una colonna statica si basa sulla seguente formula:
```
partition key columns + static columns + metadata = total encoded size of static data
```
Considerate il seguente esempio di tabella in cui tutte le colonne sono di tipo intero. La tabella ha due colonne chiave di partizione, due colonne di clustering, una colonna normale e una colonna statica.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
In questo esempio, calcoliamo la dimensione dei dati statici della seguente dichiarazione:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, static_col1) values(1,2,6);
```
Per stimare i byte totali richiesti da questa operazione di scrittura, è possibile utilizzare i seguenti passaggi.
1. Calcola la dimensione di una colonna chiave di partizione aggiungendo i byte per il tipo di dati archiviato nella colonna e i byte dei metadati. Ripeti questa operazione per tutte le colonne chiave di partizione.
1. Calcola la dimensione della prima colonna della chiave di partizione (pk\$1col1):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Calcola la dimensione della seconda colonna della chiave di partizione (pk\$1col2):
```
4 bytes for the integer data type + 3 bytes for partition key metadata = 7 bytes
```
1. Aggiungi entrambe le colonne per ottenere la dimensione totale stimata delle colonne chiave di partizione:
```
7 bytes + 7 bytes = 14 bytes for the partition key columns
```
1. Aggiungi la dimensione delle colonne statiche. In questo esempio, abbiamo solo una colonna statica che memorizza un numero intero (che richiede 4 byte).
1. Infine, per ottenere la dimensione totale codificata dei dati delle colonne statiche, sommate i byte per le colonne chiave primarie e le colonne statiche e aggiungete i 104 byte aggiuntivi per i metadati:
```
14 bytes for the partition key columns + 4 bytes for the static column + 104 bytes for metadata = 122 bytes.
```
È inoltre possibile aggiornare dati statici e non statici con la stessa istruzione. Per stimare la dimensione totale dell'operazione di scrittura, è necessario innanzitutto calcolare la dimensione dell'aggiornamento dei dati non statici. Quindi calcola la dimensione dell'aggiornamento della riga come mostrato nell'esempio in [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md) e aggiungi i risultati.
In questo caso, è possibile scrivere un totale di 2 MB: 1 MB è la quota massima per la dimensione delle righe e 1 MB è la quota per la dimensione massima dei dati statici per partizione logica.
Per calcolare la dimensione totale di un aggiornamento di dati statici e non statici nella stessa istruzione, è possibile utilizzare la formula seguente:
```
(partition key columns + static columns + metadata = total encoded size of static data) + (partition key columns + clustering columns + regular columns + row metadata = total encoded size of row)
= total encoded size of data written
```
Considerate il seguente esempio di tabella in cui tutte le colonne sono di tipo intero. La tabella ha due colonne chiave di partizione, due colonne di clustering, una colonna normale e una colonna statica.
```
CREATE TABLE mykeyspace.mytable(pk_col1 int, pk_col2 int, ck_col1 int, ck_col2 int, reg_col1 int, static_col1 int static, primary key((pk_col1, pk_col2),ck_col1, ck_col2));
```
In questo esempio, calcoliamo la dimensione dei dati quando scriviamo una riga nella tabella, come illustrato nella seguente dichiarazione:
```
INSERT INTO mykeyspace.mytable (pk_col1, pk_col2, ck_col1, ck_col2, reg_col1, static_col1) values(2,3,4,5,6,7);
```
Per stimare i byte totali richiesti da questa operazione di scrittura, è possibile utilizzare i seguenti passaggi.
1. Calcola la dimensione totale codificata dei dati statici come mostrato in precedenza. In questo esempio, sono 122 byte.
1. Aggiungi la dimensione della dimensione totale codificata della riga in base all'aggiornamento dei dati non statici, seguendo la procedura descritta in. [Stima della dimensione delle righe in Amazon Keyspaces](calculating-row-size.md) In questo esempio, la dimensione totale dell'aggiornamento della riga è di 134 byte.
```
122 bytes for static data + 134 bytes for nonstatic data = 256 bytes.
```
# Stima dei requisiti di capacità e throughput per read/write le operazioni su dati statici in Amazon Keyspaces
I dati statici sono associati alle partizioni logiche in Cassandra, non a singole righe. Le partizioni logiche in Amazon Keyspaces possono avere dimensioni praticamente illimitate se si estendono su più partizioni di storage fisiche. Di conseguenza, i contatori di Amazon Keyspaces scrivono le operazioni su dati statici e non statici separatamente. Inoltre, le scritture che includono dati statici e non statici richiedono operazioni sottostanti aggiuntive per garantire la coerenza dei dati.
Se si esegue un'operazione di scrittura mista di dati statici e non statici, si ottengono due operazioni di scrittura separate, una per dati non statici e una per dati statici. Ciò vale sia per le modalità di capacità on-demand che per quelle con capacità assegnata. read/write
L'esempio seguente fornisce dettagli su come stimare le unità di capacità di lettura (RCUs) e le unità di capacità di scrittura (WCUs) richieste quando si calcolano i requisiti di capacità di throughput assegnata per le tabelle in Amazon Keyspaces con colonne statiche. Puoi stimare la capacità necessaria alla tua tabella per elaborare scritture che includono dati statici e non statici utilizzando la seguente formula:
```
2 x WCUs required for nonstatic data + 2 x WCUs required for static data
```
Ad esempio, se l'applicazione scrive 27 KBs dati al secondo e ogni scrittura include 25,5 KBs di dati non statici e 1,5 KBs di dati statici, la tabella ne richiede 56 WCUs (2 x 26 WCUs \$1 2 x 2). WCUs
Amazon Keyspaces misura le letture di dati statici e non statici allo stesso modo delle letture di più righe. Di conseguenza, il prezzo della lettura di dati statici e non statici nella stessa operazione si basa sulla dimensione aggregata dei dati elaborati per eseguire la lettura.
Per scoprire come monitorare le risorse serverless con Amazon CloudWatch, consulta[Monitoraggio di Amazon Keyspaces con Amazon CloudWatch](monitoring-cloudwatch.md).