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 Aurora My SQL DB 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 dall'autore, 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.
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 .
Esempio 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)
Esempio 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)
Esempio 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)
