Adaptive indexing initializes and optimizes indexes incrementally, as a side
effect of query processing. The goal is to achieve the benefits of indexes
while hiding or minimizing the costs of index creation. However,
index-optimizing side effects seem to turn read-only queries into update
transactions that might, for example, create lock contention. This paper
studies concurrency control in the context of adaptive indexing.
The three traditional failure classes are system, media, and transaction
failures. Sometimes, however, modern storage exhibits failures that differ from
all of those. In order to capture and describe such cases, single-page failures
are introduced as a fourth failure class. This class encompasses all failures
to read a data page correctly and with plausible contents despite all
correction attempts in lower system levels. Efficient recovery seems to require
a new data structure called the page recovery index.
In database query processing, actual run-time conditions (e.g., actual
selectivities and actual available memory) very often differ from compile-time
expectations of run-time conditions (e.g., estimated predicate selectivities
and anticipated memory availability). Robustness of query processing can be
defined as the ability to handle unexpected conditions. Robustness of query
execution, specifically, can be defined as the ability to process a specific
plan efficiently in an unexpected condition.