Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
AssumeConsistentDataTypes sugerencia
OpenCypher sigue un paradigma en el que las coincidencias de tipos de datos numéricos (p. ej., int, byte, short, long, etc.) se llevan a cabo según la semántica de promoción de tipos. Por ejemplo, al buscar todas las propiedades con un valor de entrada 10 con texto corto, en el tipo Semántica de promoción, también encontrará propiedades que tengan 10 como valor largo. En algunos casos, la conversión tipográfica puede generar una sobrecarga y dar lugar a planes de consulta menos eficientes de lo que serían si no se hubiera realizado ninguna conversión tipográfica. 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 largos), la realización de promociones tipográficas genera una sobrecarga sin afectar al resultado de la consulta.
Para permitir la optimización en los casos en los que se sepa que los valores de los datos de propiedades numéricas almacenados en la base de datos son de un tipo coherente, se puede utilizar una sugerencia de consulta denominada assumeConsistentDataTypes (con valortrue/false, siendo el valor predeterminadofalse). Cuando esta sugerencia de consulta se proporciona con un valor detrue, el motor asume que los únicos valores de las propiedades son siempre largos o dobles y omitirá la semántica de promoción del tipo. Los valores numéricos especificados en la consulta se consideran valores largos (para valores que no son de punto flotante) o dobles (para valores de punto flotante).
Si los datos utilizan un solo tipo de datos de forma coherente (por ejemplo, todas las edades se almacenan comolong), el uso de la assumeConsistentDataTypes sugerencia puede optimizar la consulta al omitir las comprobaciones de igualdad innecesarias para los distintos 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 pista:
# 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
