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à. # Coerenza di lettura per l'inoltro di scrittura È possibile controllare il grado di coerenza di lettura in un cluster database. Il livello di coerenza di lettura determina il tempo di attesa di un cluster database prima di ogni operazione di lettura per garantire che alcune o tutte le modifiche vengano replicate dall'istanza di scrittura. È possibile regolare il livello di coerenza di lettura per garantire che tutte le operazioni di scrittura inoltrate dalla sessione siano visibili nel cluster database prima di qualsiasi query successiva. Inoltre, è possibile utilizzare questa impostazione per garantire che le query sul cluster database visualizzino sempre gli aggiornamenti più recenti dall'istanza di scrittura. Questa impostazione si applica anche alle query inviate da altre sessioni o da altri cluster. Per specificare questo tipo di comportamento per l'applicazione, scegli un valore per il parametro database `aurora_replica_read_consistency` o il parametro cluster database. **Importante** Imposta sempre il parametro database `aurora_replica_read_consistency` o il parametro cluster database quando desideri inoltrare le scritture. In caso contrario, Aurora non inoltra le scritture. Questo parametro ha un valore vuoto per impostazione predefinita, quindi scegli un valore specifico quando utilizzi questo parametro. Il parametro `aurora_replica_read_consistency` influisce solo sui cluster o sulle istanze database in cui l'inoltro di scrittura è abilitato. All'aumentare del livello di coerenza, l'applicazione rimane più tempo in attesa della propagazione delle modifiche tra le istanze database. È possibile scegliere il giusto equilibrio tra tempi di risposta rapidi e garanzia che le modifiche apportate in altre istanze database siano completamente disponibili prima dell'esecuzione delle query. È possibile specificare i valori seguenti per il parametro `aurora_replica_read_consistency`: + `EVENTUAL`: i risultati delle operazioni di scrittura nella stessa sessione non sono visibili finché l'operazione di scrittura non viene eseguita sull'istanza database di scrittura. La query non attende la disponibilità dei risultati aggiornati. Pertanto, potrebbe recuperare i dati più vecchi o i dati aggiornati, a seconda della tempistica delle istruzioni e della quantità di ritardo di replica. Questa è la stessa coerenza dei cluster database Aurora MySQL che non utilizzano l'inoltro di scrittura. + `SESSION`: tutte le query che utilizzano l'inoltro di scrittura visualizzano i risultati di tutte le modifiche apportate in tale sessione. Le modifiche sono visibili indipendentemente dal fatto che la transazione sia stata impegnata. Se necessario, la query attende che i risultati delle operazioni di scrittura inoltrate vengano replicati. + `GLOBAL`: una sessione visualizza tutte le modifiche confermate in tutte le sessioni e le istanze nel cluster database. Ogni query potrebbe attendere un periodo che varia a seconda della quantità di ritardo della sessione. La query procede quando il cluster DB contiene tutti up-to-date i dati salvati dallo scrittore, a partire dal momento in cui è iniziata la query. Per informazioni su tutti i parametri di configurazione coinvolti nell'inoltro di scrittura, consulta [Parametri di configurazione per l'inoltro di scrittura](aurora-mysql-write-forwarding.md#aurora-mysql-write-forwarding-params). **Nota** È anche possibile usare `aurora_replica_read_consistency` come una variabile di sessione, ad esempio: ``` mysql> set aurora_replica_read_consistency = 'session'; ``` ## Esempi di utilizzo dell'inoltro di scrittura Negli esempi seguenti vengono illustrati gli effetti del parametro `aurora_replica_read_consistency` sull'esecuzione delle istruzioni `INSERT` seguite dalle istruzioni `SELECT`. I risultati possono variare, a seconda del valore di `aurora_replica_read_consistency` e della tempistica delle istruzioni. Per ottenere una maggiore coerenza, è possibile attendere brevemente prima di rilasciare l’istruzione `SELECT`. Oppure Aurora può attendere automaticamente il completamento della replica dei risultati prima di procedere con `SELECT`. Per informazioni sull'impostazione dei parametri database, consulta [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md). **Example con `aurora_replica_read_consistency` impostato su `EVENTUAL`** L'esecuzione di un'istruzione `INSERT`, immediatamente seguita da un'istruzione `SELECT`, restituisce un valore per `COUNT(*)` con il numero di righe prima dell'inserimento della nuova riga. Se poco dopo si esegue nuovamente `SELECT`, viene restituito il conteggio delle righe aggiornato. Le istruzioni `SELECT` non attendono. ``` mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 5 | +----------+ 1 row in set (0.00 sec) mysql> insert into t1 values (6); select count(*) from t1; +----------+ | count(*) | +----------+ | 5 | +----------+ 1 row in set (0.00 sec) mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 6 | +----------+ 1 row in set (0.00 sec) ``` **Example con `aurora_replica_read_consistency` impostato su `SESSION`** Un'istruzione `SELECT` subito dopo l'istruzione `INSERT` attende fino a quando le modifiche apportate dall'istruzione `INSERT` diventano visibili. Le istruzioni `SELECT` successive non attendono. ``` mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 6 | +----------+ 1 row in set (0.01 sec) mysql> insert into t1 values (6); select count(*) from t1; select count(*) from t1; Query OK, 1 row affected (0.08 sec) +----------+ | count(*) | +----------+ | 7 | +----------+ 1 row in set (0.37 sec) +----------+ | count(*) | +----------+ | 7 | +----------+ 1 row in set (0.00 sec) ``` Con l'impostazione di coerenza di lettura ancora impostata su `SESSION`, l'introduzione di una breve attesa dopo l'esecuzione di un'istruzione `INSERT` rende disponibile il conteggio delle righe aggiornate dal momento dell'esecuzione dell'istruzione `SELECT` successiva. ``` mysql> insert into t1 values (6); select sleep(2); select count(*) from t1; Query OK, 1 row affected (0.07 sec) +----------+ | sleep(2) | +----------+ | 0 | +----------+ 1 row in set (2.01 sec) +----------+ | count(*) | +----------+ | 8 | +----------+ 1 row in set (0.00 sec) ``` **Example con `aurora_replica_read_consistency` impostato su `GLOBAL`** Ogni istruzione `SELECT` attende che tutte le modifiche ai dati, a partire dall'ora di inizio dell'istruzione, diventino visibili prima di eseguire la query. Il tempo di attesa per ciascuna istruzione `SELECT` varia, a seconda dell'entità di ritardo di replica. ``` mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 8 | +----------+ 1 row in set (0.75 sec) mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 8 | +----------+ 1 row in set (0.37 sec) mysql> select count(*) from t1; +----------+ | count(*) | +----------+ | 8 | +----------+ 1 row in set (0.66 sec) ```