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à.

# Memorizzazione nella cache dei risultati delle query del database
<a name="caching-database-query-results"></a>

Un modello comune per ridurre le latenze delle query del database è la memorizzazione nella cache delle query. Le applicazioni implementano la memorizzazione nella cache delle query interrogando la cache per individuare i risultati associati a una query del database e restituendo tali risultati se sono memorizzati nella cache. Se non viene trovato alcun risultato memorizzato nella cache, la query viene eseguita sul database, i risultati vengono inseriti nella cache e i risultati vengono quindi restituiti all'applicazione che avvia la query. Le successive interrogazioni al database restituiranno quindi i risultati memorizzati nella cache purché rimangano nella cache.

## Quando utilizzare la memorizzazione nella cache delle query
<a name="caching-database-query-results-when-to-use"></a>

La memorizzazione nella cache delle query con ElastiCache è più efficace per i seguenti tipi di carico di lavoro:
+ **Read-heavy applicazioni in cui le** stesse query vengono eseguite ripetutamente con dati che vengono modificati raramente.
+ **Query costose come ricerche** non indicizzate, aggregazioni o join multitabella in cui i tempi di esecuzione delle query sono lunghi.
+ **High-concurrency scenari** in cui l'offloading delle letture riduce la pressione della CPU del database e migliora il throughput complessivo. ElastiCache 

La memorizzazione nella cache delle query non è consigliata per le query in cui è richiesta una forte coerenza o per le query all'interno di transazioni con più istruzioni che richiedono una coerenza tra lettura e scrittura.

## Utilizzo di AWS Wrapper JDBC avanzato
<a name="caching-database-query-results-jdbc-wrapper"></a>

[Se l'applicazione utilizza un driver JDBC per interrogare un database relazionale, è possibile implementare la memorizzazione nella cache delle query con il [Remote](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheRemoteQueryCachePlugin.md) Query Cache Plugin nell'Advanced JDBC Wrapper.AWS](https://github.com/aws/aws-advanced-jdbc-wrapper) Il plug-in memorizza automaticamente nella cache i set di risultati delle query SQL selezionatiElastiCache, restituendo il set di risultati dalla cache anziché dal database per le query future. La memorizzazione nella cache dei risultati delle query può ridurre il carico del database e ridurre le latenze medie delle query con modifiche minime al codice dell'applicazione.

## Come funziona la memorizzazione nella cache delle query con il plugin
<a name="caching-database-query-results-how-it-works"></a>

Il Remote Query Cache Plugin consente alle applicazioni Java che interrogano database PostgreSQL, MySQL o MariadB di memorizzare automaticamente nella cache i risultati delle query. ElastiCache È possibile configurare il plug-in con le informazioni sull'endpoint della cache e indicare quali query del codice memorizzare nella cache utilizzando i suggerimenti di interrogazione. Quando il plugin rileva una query suggerita, restituisce il risultato della query dalla cache, se presente (un risultato della cache). Se i risultati non sono nella cache (perdita della cache), il plugin esegue la query sul database, archivia i risultati nella cache e restituisce i risultati all'applicazione in modo che la prossima volta che la query viene eseguita, i risultati possano essere serviti dalla cache.

## Suggerimenti per la memorizzazione nella cache
<a name="caching-database-query-results-hints"></a>

È possibile controllare le query da memorizzare nella cache impostando suggerimenti su ciascuna query. Puoi applicare i suggerimenti di query direttamente alle stringhe di query nel codice dell'applicazione con un prefisso di commento:

```
/* CACHE_PARAM(ttl=300s) */ SELECT * FROM my_table WHERE id = 42
```

`ttl`dov'è il tempo di vita in secondi. È inoltre possibile impostare suggerimenti di interrogazione nelle istruzioni preparate utilizzando framework comuni come Hibernate e Spring Boot.

## Prerequisiti
<a name="caching-database-query-results-prerequisites"></a>

Per utilizzare il Remote Query Cache Plugin nell'applicazione, è necessaria una cache ElastiCache for Valkey o Redis OSS (sono supportate sia Serverless che basata su nodi) insieme alle seguenti dipendenze:
+ [AWS Advanced JDBC](https://github.com/aws/aws-advanced-jdbc-wrapper) Wrapper versione 3.3.0 o successiva.
+ [Apache Commons](https://commons.apache.org/proper/commons-pool/) Pool versione 2.11.1 o successiva.
+ [Valkey Glide](https://glide.valkey.io/) versione 2.3.0 o successiva.

## Esempio: memorizzazione nella cache di una query con il plugin
<a name="caching-database-query-results-example"></a>

L'esempio seguente mostra come abilitare il plug-in e memorizzare nella cache il risultato di una query per 300 secondi (5 minuti) con una cache serverless ElastiCache for Valkey:

```
import java.sql.*;
import java.util.Properties;

public class QueryCacheExample {
    public static void main(String[] args) throws SQLException {
        Properties props = new Properties();
        props.setProperty("user", "myuser");
        props.setProperty("password", "mypassword");

        // Enable the remote query cache plugin
        props.setProperty("wrapperPlugins", "remoteQueryCache");

        // Point to your ElastiCache endpoint
        props.setProperty("cacheEndpointAddrRw", "my-cache.serverless.use1.cache.amazonaws.com:6379");

        Connection conn = DriverManager.getConnection(
            "jdbc:aws-wrapper:postgresql://my-database.cluster-abc123.us-east-1.rds.amazonaws.com:5432/mydb",
            props
        );

        Statement stmt = conn.createStatement();

        // The SQL comment hint tells the plugin to cache this query for 300 seconds
        ResultSet rs = stmt.executeQuery(
            "/* CACHE_PARAM(ttl=300s) */ SELECT product_name, price FROM products WHERE category = 'electronics'"
        );

        while (rs.next()) {
            System.out.println(rs.getString("product_name") + ": $" + rs.getBigDecimal("price"));
        }

        rs.close();
        stmt.close();
        conn.close();
    }
}
```

La prima volta che viene eseguita questa query, il risultato viene restituito dal database e memorizzato nella cache. ElastiCache Per i successivi 300 secondi, le esecuzioni successive di tale query vengono fornite direttamente dalla cache.

## Risorse correlate
<a name="caching-database-query-results-related"></a>

Puoi trovare esempi più completi e informazioni dettagliate sulla configurazione del plugin nella [documentazione del plugin Remote Query Cache](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheRemoteQueryCachePlugin.md).