

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 Typerhöhungen 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, gibt es einen Abfragehinweis namens `assumeConsistentDataTypes` (mit Wert `true/false`, wobei die Standardeinstellung ist `false`) kann verwendet werden. Wenn dieser Abfragehinweis mit einem Wert von geliefert wird `true`geht die Engine davon aus, dass die einzigen Eigenschaftswerte immer lang oder doppelt sind, und überspringt die Semantik zur Typerhöhung. In der Abfrage angegebene numerische Werte 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 gespeichert als `long`), dann mit dem `assumeConsistentDataTypes` hint kann die Abfrage optimieren, 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
```