Coherencia de los datos de consulta de Datastore
Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Niveles de coherencia de datos
Las consultas en Datastore pueden arrojar resultados en uno de los dos niveles de coherencia:
- Coherencia sólida: Estas consultas garantizan que los resultados incluyan la información más reciente, pero pueden tomar más tiempo en completarse.
- Coherencia eventual: Estas consultas suelen ejecutarse más rápido, pero a veces pueden mostrar resultados obsoletos.
En una consulta de coherencia eventual, también se accede a los índices usados para reunir los resultados con coherencia eventual. Por lo tanto, esas consultas, a veces, pueden mostrar entidades que ya no coinciden con los criterios originales de la consulta, al tiempo que las consultas de coherencia sólida siempre son coherentes entre las transacciones.
Coherencia de los datos de consulta de Datastore
Las consultas muestran sus resultados con distintos niveles de garantía de coherencia, según la naturaleza de la consulta.
- De forma predeterminada, las consultas principales (las que están dentro de un grupo de entidades) tienen coherencia sólida. Sin embargo, se puede modificar la política de lectura de Datastore (detallada a continuación) para hacer que tengan coherencia eventual.
- Las consultas que no son principales siempre son de coherencia eventual.
La recuperación de una entidad por clave, también denominada “búsqueda por clave”, es de coherencia sólida.
Configura la política de lectura de Datastore
Para mejorar el rendimiento, puedes configurar la política de lectura de Datastore de modo que todas las lecturas y consultas tengan una coherencia eventual. (La API también te permite establecer de forma explícita una política de coherencia sólida, pero esta configuración no tendrá efectos prácticos, ya que las consultas que no son principales son siempre de coherencia eventual sin importar la política).
También puedes establecer el
plazo de llamada de Datastore, que es el tiempo máximo, en segundos, que la aplicación esperará para que Datastore muestre un resultado antes de abortar con un error. El plazo predeterminado es de 60 segundos. En este momento, no se puede establecer un plazo más largo, pero sí puedes reducirlo a fin de asegurarte de que una operación determinada falle rápido (por ejemplo, para mostrarle una respuesta más rápida al usuario).
Para establecer la política de lectura de Datastore y la fecha límite de la llamada en Python, pásalas como argumentos a los métodos
run()
,
get()
,
fetch()
y
count()
de las clases
Query
o
GqlQuery
. Por ejemplo:
for result in Employee.all().run(limit=5,
read_policy=db.EVENTUAL_CONSISTENCY,
deadline=5):
# Body of iterative loop
Pasos siguientes
Salvo que se indique lo contrario, el contenido de esta página está sujeto a la licencia Atribución 4.0 de Creative Commons, y los ejemplos de código están sujetos a la licencia Apache 2.0. Para obtener más información, consulta las políticas del sitio de Google Developers. Java es una marca registrada de Oracle o sus afiliados.
Última actualización: 2025-09-04 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Información o código de muestra incorrectos","incorrectInformationOrSampleCode","thumb-down"],["Faltan la información o los ejemplos que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-09-04 (UTC)"],[[["\u003cp\u003eDatastore queries operate at two consistency levels: strongly consistent, which guarantees the freshest data but may take longer, and eventually consistent, which is generally faster but might return stale data.\u003c/p\u003e\n"],["\u003cp\u003eAncestor queries, which occur within an entity group, are strongly consistent by default but can be made eventually consistent by adjusting the Datastore read policy, whereas non-ancestor queries are always eventually consistent.\u003c/p\u003e\n"],["\u003cp\u003eFetching an entity by key, also known as "lookup by key", provides strong consistency in retrieving data.\u003c/p\u003e\n"],["\u003cp\u003eThe Datastore read policy can be set to ensure all reads and queries are eventually consistent, optimizing performance, and while a strong consistency policy can be set, it has no effect on non-ancestor queries, as they remain eventually consistent.\u003c/p\u003e\n"],["\u003cp\u003eThe Datastore call deadline, the maximum time an application waits for a result, defaults to 60 seconds but can be reduced to ensure faster operation failures, thus allowing the possibility of faster user responses.\u003c/p\u003e\n"]]],[],null,["# Data Consistency in Datastore Queries\n\nData consistency levels\n-----------------------\n\nDatastore queries can deliver their results at either of two consistency\nlevels:\n\n- [*Strongly consistent*](https://en.wikipedia.org/wiki/Strong_consistency) queries guarantee the freshest results, but may take longer to complete.\n- [*Eventually consistent*](https://en.wikipedia.org/wiki/Eventual_consistency) queries generally run faster, but may occasionally return stale results.\n\nIn an eventually consistent query, the indexes used to gather the results are also accessed with eventual consistency. Consequently, such queries may sometimes return entities that no longer match the original query criteria, while strongly consistent queries are always transactionally consistent.\n\nDatastore query data consistency\n--------------------------------\n\nQueries return their results with different levels of consistency guarantee, depending on the nature of the query:\n\n- [Ancestor queries](/appengine/docs/legacy/standard/python/datastore/queries#ancestor_queries) (those within an [entity group](/appengine/docs/legacy/standard/python/datastore/entities#Ancestor_paths)) are strongly consistent by default, but can instead be made eventually consistent by setting the Datastore read policy (see below).\n- Non-ancestor queries are always eventually consistent.\n\nFetching an entity by key, which is also called \"lookup by key\", is strongly\nconsistent.\n\n\u003cbr /\u003e\n\nSetting the Datastore read policy\n---------------------------------\n\nTo improve performance, you can set the Datastore *read policy* so that all reads and queries are eventually consistent. (The API also allows you to explicitly set a strong consistency policy, but this setting will have no practical effect, since non-ancestor queries are always eventually consistent regardless of policy.)\nYou can also set the Datastore *call deadline* , which is the maximum time, in seconds, that the application will wait for Datastore to return a result before aborting with an error. The default deadline is 60 seconds; it is not currently possible to set it higher, but you can adjust it downward to ensure that a particular operation fails quickly (for instance, to return a faster response to the user).\n\n\u003cbr /\u003e\n\nTo set the Datastore read policy and call deadline in Python, you pass them as arguments to the [`run()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_run), [`get()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_get), [`fetch()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_fetch), and [`count()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_count) methods of class [`Query`](/appengine/docs/legacy/standard/python/datastore/queryclass) or [`GqlQuery`](/appengine/docs/legacy/standard/python/datastore/gqlqueryclass). For example:\n\n\u003cbr /\u003e\n\n for result in Employee.all().run(limit=5,\n read_policy=db.EVENTUAL_CONSISTENCY,\n deadline=5):\n # Body of iterative loop\n\nWhat's next?\n------------\n\n- [Learn how to specify what a query returns and further control query results](/appengine/docs/legacy/standard/python/datastore/retrieving-query-results).\n- Learn the [common restrictions](/appengine/docs/legacy/standard/python/datastore/query-restrictions) for queries on Datastore.\n- Learn about [query cursors](/appengine/docs/legacy/standard/python/datastore/query-cursors), which allow an application to retrieve a query's results in convenient batches.\n- Learn the [basic syntax and structure of queries](/appengine/docs/legacy/standard/python/datastore/queries) for Datastore."]]