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à. # Cache del piano di query in Amazon Neptune Quando una query viene inviata a Neptune, la stringa di query viene analizzata, ottimizzata e trasformata in un piano di query, che viene quindi eseguito dal motore. Le applicazioni sono spesso supportate da modelli di query comuni istanziati con valori diversi. La cache del piano di query può ridurre la latenza complessiva memorizzando nella cache i piani di query ed evitando così l'analisi e l'ottimizzazione di tali schemi ripetuti. Query Plan Cache può essere utilizzata per le query, sia quelle non **OpenCypher**parametrizzate che quelle parametrizzate. È abilitato per READ e per HTTP e Bolt. **Non** è supportato per le query di mutazione OC. **Non** è supportato per le query Gremlin o SPARQL. ## Come forzare l'attivazione o la disabilitazione della cache del piano di query La cache del piano di query è abilitata di default per le query parametrizzate a bassa latenza. **Un piano per una query con parametri viene memorizzato nella cache solo quando la latenza è inferiore alla soglia di 100 ms.** Questo comportamento può essere sovrascritto per singola query (parametrizzata o meno) dal Query Hint a livello di query. `QUERY:PLANCACHE` Deve essere usato con la clausola. `USING` Il suggerimento di interrogazione accetta `enabled` or `disabled` come valore. ------ #### [ AWS CLI ] Forzare il piano a essere memorizzato nella cache o riutilizzato: ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://your-neptune-endpoint:port \ --open-cypher-query "Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" ``` Con parametri: ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://your-neptune-endpoint:port \ --open-cypher-query "Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \ --parameters '{"arg": 123}' ``` Imporre al piano di non essere né memorizzato nella cache né riutilizzato: ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://your-neptune-endpoint:port \ --open-cypher-query "Using QUERY:PLANCACHE \"disabled\" MATCH(n) RETURN n LIMIT 1" ``` Per ulteriori informazioni, vedere [execute-open-cypher-query](https://docs.aws.amazon.com/cli/latest/reference/neptunedata/execute-open-cypher-query.html)nel AWS CLI Command Reference. ------ #### [ SDK ] ``` import boto3 from botocore.config import Config client = boto3.client( 'neptunedata', endpoint_url='https://your-neptune-endpoint:port', config=Config(read_timeout=None, retries={'total_max_attempts': 1}) ) # Forcing plan to be cached or reused response = client.execute_open_cypher_query( openCypherQuery='Using QUERY:PLANCACHE "enabled" MATCH(n) RETURN n LIMIT 1' ) print(response['results']) ``` Per esempi AWS SDK in altre lingue, consulta[AWS SDK](access-graph-opencypher-sdk.md). ------ #### [ awscurl ] Forzare il piano a essere memorizzato nella cache o riutilizzato: ``` awscurl https://your-neptune-endpoint:port/openCypher \ --region us-east-1 \ --service neptune-db \ -X POST \ -d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" ``` **Nota** Questo esempio presuppone che le AWS credenziali siano configurate nel proprio ambiente. Sostituisci *us-east-1* con la regione del tuo cluster Neptune. ------ #### [ curl ] Forzare il piano a essere memorizzato nella cache o riutilizzato: ``` curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" ``` Con parametri: ``` curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \ -d "parameters={\"arg\": 123}" ``` Imporre al piano di non essere né memorizzato nella cache né riutilizzato: ``` curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"disabled\" MATCH(n) RETURN n LIMIT 1" ``` ------ ## Come determinare se un piano è memorizzato nella cache o meno Per HTTP READ, se la query è stata inviata e il piano è stato memorizzato nella cache, `explain` mostrerebbe i dettagli relativi alla cache del piano di query. ------ #### [ AWS CLI ] ``` aws neptunedata execute-open-cypher-explain-query \ --endpoint-url https://your-neptune-endpoint:port \ --open-cypher-query "Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" \ --explain-mode details ``` Per ulteriori informazioni, vedere [execute-open-cypher-explain-query](https://docs.aws.amazon.com/cli/latest/reference/neptunedata/execute-open-cypher-explain-query.html) nel AWS CLI Command Reference. ------ #### [ SDK ] ``` import boto3 from botocore.config import Config client = boto3.client( 'neptunedata', endpoint_url='https://your-neptune-endpoint:port', config=Config(read_timeout=None, retries={'total_max_attempts': 1}) ) response = client.execute_open_cypher_explain_query( openCypherQuery='Using QUERY:PLANCACHE "enabled" MATCH(n) RETURN n LIMIT 1', explainMode='details' ) print(response['results'].read().decode('utf-8')) ``` Per esempi AWS SDK in altre lingue, consulta. [AWS SDK](access-graph-opencypher-sdk.md) ------ #### [ awscurl ] ``` awscurl https://your-neptune-endpoint:port/openCypher \ --region us-east-1 \ --service neptune-db \ -X POST \ -d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" \ -d "explain=details" ``` **Nota** Questo esempio presuppone che le AWS credenziali siano configurate nel proprio ambiente. Sostituisci *us-east-1* con la regione del tuo cluster Neptune. ------ #### [ curl ] ``` curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"enabled\" MATCH(n) RETURN n LIMIT 1" \ -d "explain=details" ``` ------ Se il piano è stato memorizzato nella cache, l'`explain`output mostra: ``` Query: Plan cached by request: Plan cached at: Parameters: Plan cache hits: First query evaluation time: The query has been executed based on a cached query plan. Detailed explain with operator runtime statistics can be obtained by running the query with plan cache disabled (using HTTP parameter planCache=disabled). ``` Quando si utilizza Bolt, la funzione di spiegazione non è supportata. ## Sfratto Un piano di query viene eliminato dal cache time to live (TTL) o quando è stato raggiunto un numero massimo di piani di query memorizzati nella cache. Quando il piano di query viene raggiunto, il TTL viene aggiornato. Le impostazioni predefinite sono: + 1000: il numero massimo di piani che possono essere memorizzati nella cache per istanza. + TTL: 300.000 millisecondi o 5 minuti. L'accesso alla cache riavvia il TTL e lo reimposta a 5 minuti. ## Condizioni che impediscono la memorizzazione del piano nella cache La cache del piano di query non verrebbe utilizzata nelle seguenti condizioni: 1. Quando viene inviata una query utilizzando il suggerimento `QUERY:PLANCACHE "disabled"` di interrogazione. È possibile eseguire nuovamente la query e rimuoverla `QUERY:PLANCACHE "disabled"` per abilitare la cache del piano di interrogazione. 1. Se la query inviata non è un'interrogazione con parametri e non contiene il suggerimento. `QUERY:PLANCACHE "enabled"` 1. Se il tempo di valutazione della query è superiore alla soglia di latenza, la query non viene memorizzata nella cache e viene considerata una query di lunga durata che non trarrebbe vantaggio dalla cache del piano di query. 1. Se la query contiene uno schema che non restituisce alcun risultato. + cioè `MATCH (n:nonexistentLabel) return n` quando ci sono zero nodi con l'etichetta specificata. + cioè `MATCH (n {name: $param}) return n` con `parameters={"param": "abcde"}` quando non ci sono nodi contenenti`name=abcde`. 1. Se il parametro di interrogazione è di tipo composito, ad esempio a `list` o a`map`. ``` curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \ -d "parameters={\"arg\": [1, 2, 3]}" curl https://your-neptune-endpoint:port/openCypher \ -d "query=Using QUERY:PLANCACHE \"enabled\" RETURN \$arg" \ -d "parameters={\"arg\": {\"a\": 1}}" ``` 1. Se il parametro di query è una stringa che non ha fatto parte di un'operazione di caricamento o inserimento di dati. Ad esempio, se `CREATE (n {name: "X"})` viene eseguito per inserire`"X"`, `RETURN "X"` viene memorizzato nella cache, mentre non `RETURN "Y"` verrebbe memorizzato nella cache, poiché `"Y"` non è stato inserito e non esiste nel database.