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à.
AssumeConsistentDataTypes suggerimento
OpenCypher segue un paradigma in cui le corrispondenze di tipi di dati numerici (ad esempio, int, byte, short, long, ecc.) vengono eseguite secondo la semantica di promozione dei tipi. Ad esempio, quando si cercano tutte le proprietà con un valore di input 10 con un tipo breve, nella semantica di promozione del tipo, vengono trovate anche le proprietà che hanno 10 come valore lungo. In alcuni casi, il trasferimento del tipo può comportare un sovraccarico e comportare piani di interrogazione meno efficienti di quanto potrebbero essere se non fosse eseguita alcuna trasmissione del tipo. In particolare, nei casi in cui i tipi di dati vengono utilizzati in modo coerente nei dati (ad esempio, se tutte le età degli utenti sono memorizzate come valore lungo) l'esecuzione di promozioni relative ai tipi di dati causa un sovraccarico senza influire sul risultato della query.
Per consentire l'ottimizzazione nei casi in cui è noto che i valori dei dati delle proprietà numeriche memorizzati nel database sono di tipo coerente, è possibile utilizzare un suggerimento di query chiamato assumeConsistentDataTypes (con valoretrue/false, con valore predefinito). false Quando questo suggerimento di interrogazione viene fornito con il valore ditrue, il motore presume che gli unici valori delle proprietà siano sempre lunghi o doppi e salterà la semantica di promozione del tipo. I valori numerici specificati nella query sono considerati valori lunghi (per valori non in virgola mobile) e doppi (per valori in virgola mobile).
Se i dati utilizzano costantemente un singolo tipo di dati (ad esempio, tutte le età vengono archiviate comelong), l'utilizzo del assumeConsistentDataTypes suggerimento può ottimizzare la query saltando i controlli di uguaglianza non necessari per i diversi tipi numerici. Tuttavia, se i dati hanno tipi di dati non coerenti per la stessa proprietà, l'utilizzo del suggerimento potrebbe causare la perdita di alcuni risultati, poiché la query corrisponderà solo al singolo tipo di dati presupposto dal suggerimento.
# Database loaded with following openCypher CSV's # File 1 :ID,age:Int n1,20 n2,25 # File 2 :ID,age:Long n3,25 # Example (no hint) MATCH (n:Person) WHERE n.age >= 25 RETURN n # Result n2 n3 Returns all person whose age is >= 25 and the values >= 25 can be with any of these datatypes i.e. byte, short, int, long, double or float ----------------------------------------------------------------------------------- # Example (with hint present) USING QUERY:assumeConsistentDataTypes "true" MATCH (n:Person) WHERE n.age >= 25 RETURN n # Result n3 Returns only "n3" and not "n2". The reason is that even though the numerical value matches (25), the datatype is "int" and is considered a non-match.
La differenza può essere convalidata anche tramite la spiegazione.
Senza la spiegazione:
# Query MATCH (n) WHERE n.age = 20 RETURN n # Explain Snippet ╔═════╤══════════╤══════════╤══════════════════════════════╤═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤════════╤════════════╤══════════════╤═════════╤══════════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode │ Units In │ Units Out │ Ratio │ Time (ms) ║ ╠═════╪══════════╪══════════╪══════════════════════════════╪═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╪════════╪════════════╪══════════════╪═════════╪══════════════╣ ║ 0 │ 1 │ - │ DFEPipelineScan (DFX) │ pattern=Node(?n) with property 'age' as ?n_age2 and label 'ALL' │ - │ 0 │ 1 │ 0.00 │ 0.10 ║ ║ │ │ │ │ inlineFilters=[(?n_age2 IN ["20"^^xsd:byte, "20"^^xsd:int, "20"^^xsd:long, "20"^^xsd:short, "20.0"^^xsd:double, "20.0"^^xsd:float])] │ │ │ │ │ ║ ║ │ │ │ │ patternEstimate=1 │ │ │ │ │ ║ ╟─────┼──────────┼──────────┼──────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼────────┼────────────┼──────────────┼─────────┼──────────────╢ # The inFilters field contains all numeric types
Con il suggerimento:
# Query MATCH (n) WHERE n.age = 20 RETURN n # Explain Snippet ╔═════╤══════════╤══════════╤══════════════════════════════╤═════════════════════════════════════════════════════════════════════════════════╤════════╤════════════╤══════════════╤═════════╤══════════════╗ ║ ID │ Out #1 │ Out #2 │ Name │ Arguments │ Mode │ Units In │ Units Out │ Ratio │ Time (ms) ║ ╠═════╪══════════╪══════════╪══════════════════════════════╪═════════════════════════════════════════════════════════════════════════════════╪════════╪════════════╪══════════════╪═════════╪══════════════╣ ║ 0 │ 1 │ - │ DFEPipelineScan (DFX) │ pattern=Node(?n) with property 'age' as ?n_age2 and label 'ALL' │ - │ 0 │ 1 │ 0.00 │ 0.07 ║ ║ │ │ │ │ inlineFilters=[(?n_age2 IN ["20"^^xsd:long])] │ │ │ │ │ ║ ║ │ │ │ │ patternEstimate=1 │ │ │ │ │ ║ ╟─────┼──────────┼──────────┼──────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────┼────────┼────────────┼──────────────┼─────────┼──────────────╢ # The inFilters field only contains long datatype
