Sugerencia AssumeConsistentDataTypes
openCypher sigue un paradigma en el que las coincidencias de tipos de datos numéricos (por ejemplo, int, byte, short, long, etc.) se llevan a cabo bajo la semántica de promoción de tipos. Por ejemplo, al buscar todas las propiedades con un valor de entrada 10 con tipo short, bajo la semántica de promoción de tipos, también coincidiría con las propiedades que tienen 10 como valor long. En algunos casos, la conversión de tipos puede generar una sobrecarga y dar lugar a planes de consulta menos eficientes de lo que podrían ser si no se hubiera realizado la conversión de tipos. En particular, en los casos en que los tipos de datos se utilizan de forma coherente en los datos (por ejemplo, si todas las edades de las personas se almacenan como valores long), la promoción de tipos genera una sobrecarga sin afectar al resultado de la consulta.
Para permitir la optimización en los casos en los que se sabe que los valores de los datos de propiedades numéricas almacenados en la base de datos son de tipo coherente, se puede utilizar una sugerencia de consulta denominada assumeConsistentDataTypes (con valor true/false, siendo false el valor predeterminado). Cuando esta sugerencia de consulta se proporciona con un valor true, el motor asume que los únicos valores de las propiedades son siempre long o double y omite la semántica de promoción de tipos. Los valores numéricos especificados en la consulta se consideran valores long (para valores que no son de coma flotante) o double (para valores de coma flotante).
Si los datos utilizan de forma coherente un único tipo de datos (por ejemplo, todas las edades se almacenan como long), el uso de la sugerencia assumeConsistentDataTypes puede optimizar la consulta al omitir comprobaciones de igualdad innecesarias para diferentes tipos numéricos. Sin embargo, si los datos tienen tipos de datos incoherentes para la misma propiedad, el uso de la sugerencia puede provocar que se pierdan algunos resultados, ya que la consulta solo coincidirá con el único tipo de datos que asume la sugerencia.
# 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 diferencia también se puede validar mediante la explicación.
Sin la explicación:
# 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 la sugerencia:
# 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
