Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
AssumeConsistentDataTypes indice
OpenCypher suit un paradigme dans lequel les correspondances de types de données numériques (par exemple, int, byte, short, long, etc.) sont effectuées selon une sémantique de promotion de type. Par exemple, lors de la recherche de toutes les propriétés avec une valeur d'entrée 10 avec un type court, dans la rubrique Sémantique de promotion de type, cela ferait également correspondre les propriétés dont la valeur longue est 10. Dans certains cas, la conversion de type peut entraîner une surcharge et entraîner des plans de requête moins efficaces qu'ils ne pourraient l'être si aucune conversion de type n'était effectuée. En particulier, dans les cas où les types de données sont utilisés de manière cohérente dans les données (par exemple, si l'âge de toutes les personnes est stocké sous forme de valeur longue), l'exécution de promotions de type entraîne une surcharge sans affecter le résultat de la requête.
Pour permettre l'optimisation dans les cas où l'on sait que les valeurs numériques des données de propriété stockées dans la base de données sont de type cohérent, un indice de requête appelé assumeConsistentDataTypes (avec valeurtrue/false, la valeur par défaut étantfalse) peut être utilisé. Lorsque cet indice de requête est fourni avec une valeur detrue, le moteur suppose que les seules valeurs de propriété sont toujours longues ou doubles et ignore la sémantique de promotion du type. Les valeurs numériques spécifiées dans la requête sont considérées comme des valeurs longues (pour les valeurs non flottantes) ou comme des valeurs doubles (pour les valeurs à virgule flottante).
Si les données utilisent systématiquement un seul type de données (par exemple, tous les âges sont stockés sous cette formelong), l'utilisation de l'assumeConsistentDataTypesastuce peut optimiser la requête en évitant les contrôles d'égalité inutiles pour les différents types numériques. Toutefois, si les données présentent des types de données incohérents pour la même propriété, l'utilisation de l'astuce peut entraîner l'échec de certains résultats, car la requête ne correspondra qu'au type de données unique supposé par l'astuce.
# 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 différence peut également être validée via l'explication.
Sans explication :
# 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
Avec un indice :
# 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
