Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
AssumeConsistentDataTypes Hinweis
OpenCypher folgt einem Paradigma, bei dem Übereinstimmungen numerischer Datentypen (z. B. int, byte, short, long usw.) unter der Semantik der Typförderung durchgeführt werden. Wenn zum Beispiel nach allen Eigenschaften mit einem Eingabewert 10 mit Kurztyp gesucht wird, würde es unter Typaufstiegssemantik auch Eigenschaften abgleichen, die 10 als langen Wert haben. In einigen Fällen kann die Typumwandlung zu einem Mehraufwand führen und zu Abfrageplänen führen, die weniger effizient sind, als wenn keine Typumwandlung durchgeführt worden wäre. Insbesondere in Fällen, in denen Datentypen konsistent in den Daten verwendet werden (z. B. wenn das Alter aller Personen als langer Wert gespeichert ist), verursacht die Durchführung von Typ-Heraufstufungen einen Overhead, ohne das Abfrageergebnis zu beeinflussen.
Um eine Optimierung für Fälle zu ermöglichen, in denen bekannt ist, dass in der Datenbank gespeicherte numerische Eigenschaftsdatenwerte einen konsistenten Typ haben, kann ein Abfragehinweis namens assumeConsistentDataTypes (mit Werttrue/false, wobei der Standardwert istfalse) verwendet werden. Wenn dieser Abfragehinweis den Wert von hat, geht die Engine davon austrue, dass die einzigen Eigenschaftswerte immer lang oder doppelt sind, und überspringt die Semantik der Typerhöhung. Numerische Werte, die in der Abfrage angegeben werden, werden entweder als lange Werte (für Nichtfließkommawerte) oder als doppelte Werte (für Fließkommawerte) betrachtet.
Wenn die Daten konsistent einen einzigen Datentyp verwenden (z. B. werden alle Altersgruppen als gespeichertlong), kann die Abfrage mithilfe des assumeConsistentDataTypes Hinweises optimiert werden, indem unnötige Gleichheitsprüfungen für verschiedene numerische Typen übersprungen werden. Wenn die Daten jedoch inkonsistente Datentypen für dieselbe Eigenschaft haben, kann die Verwendung des Hinweises dazu führen, dass einige Ergebnisse übersehen werden, da die Abfrage nur dem einzigen Datentyp entspricht, den der Hinweis annimmt.
# 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.
Der Unterschied kann auch mithilfe der Erläuterung validiert werden.
Ohne die Erklärung:
# 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
Mit dem Hinweis:
# 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
