src/main/site/asciidoc/acid-semantics.adoc

////
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
////

= Apache HBase (TM) ACID Properties

== About this Document

Apache HBase (TM) is not an ACID compliant database. However, it does guarantee certain specific properties.

This specification enumerates the ACID properties of HBase.

== Definitions

For the sake of common vocabulary, we define the following terms:
Atomicity::
  An operation is atomic if it either completes entirely or not at all.

Consistency::
  All actions cause the table to transition from one valid state directly to another (eg a row will not disappear during an update, etc).

Isolation::
  an operation is isolated if it appears to complete independently of any other concurrent transaction.

Durability::
  Any update that reports "successful" to the client will not be lost.

Visibility::
  An update is considered visible if any subsequent read will see the update as having been committed.


The terms _must_ and _may_ are used as specified by link:[RFC 2119].

In short, the word "must" implies that, if some case exists where the statement is not true, it is a bug. The word _may_ implies that, even if the guarantee is provided in a current release, users should not rely on it.

== APIs to Consider
- Read APIs
* get
* scan
- Write APIs
* put
* batch put
* delete
- Combination (read-modify-write) APIs
* incrementColumnValue
* checkAndPut

== Guarantees Provided

.Atomicity
.  All mutations are atomic within a row. Any put will either wholely succeed or wholely fail.footnoteref[Puts will either wholely succeed or wholely fail, provided that they are actually sent to the RegionServer.  If the writebuffer is used, Puts will not be sent until the writebuffer is filled or it is explicitly flushed.]
.. An operation that returns a _success_ code has completely succeeded.
.. An operation that returns a _failure_ code has completely failed.
.. An operation that times out may have succeeded and may have failed. However, it will not have partially succeeded or failed.
. This is true even if the mutation crosses multiple column families within a row.
. APIs that mutate several rows will _not_ be atomic across the multiple rows. For example, a multiput that operates on rows 'a','b', and 'c' may return having mutated some but not all of the rows. In such cases, these APIs will return a list of success codes, each of which may be succeeded, failed, or timed out as described above.
. The checkAndPut API happens atomically like the typical _compareAndSet (CAS)_ operation found in many hardware architectures.
. The order of mutations is seen to happen in a well-defined order for each row, with no interleaving. For example, if one writer issues the mutation `a=1,b=1,c=1` and another writer issues the mutation `a=2,b=2,c=`, the row must either be `a=1,b=1,c=1` or `a=2,b=2,c=2` and must *not* be something like `a=1,b=2,c=1`. +
NOTE:This is not true _across rows_ for multirow batch mutations.

== Consistency and Isolation
. All rows returned via any access API will consist of a complete row that existed at some point in the table's history.
. This is true across column families - i.e a get of a full row that occurs concurrent with some mutations 1,2,3,4,5 will return a complete row that existed at some point in time between mutation i and i+1 for some i between 1 and 5.
. The state of a row will only move forward through the history of edits to it.

== Consistency of Scans
A scan is *not* a consistent view of a table. Scans do *not* exhibit _snapshot isolation_.

Rather, scans have the following properties:
. Any row returned by the scan will be a consistent view (i.e. that version of the complete row existed at some point in time)footnoteref[consistency,A consistent view is not guaranteed intra-row scanning -- i.e. fetching a portion of a row in one RPC then going back to fetch another portion of the row in a subsequent RPC. Intra-row scanning happens when you set a limit on how many values to return per Scan#next (See link:http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/client/Scan.html#setBatch(int)"[Scan#setBatch(int)]).]
. A scan will always reflect a view of the data _at least as new as_ the beginning of the scan. This satisfies the visibility guarantees enumerated below.
.. For example, if client A writes data X and then communicates via a side channel to client B, any scans started by client B will contain data at least as new as X.
.. A scan _must_ reflect all mutations committed prior to the construction of the scanner, and _may_ reflect some mutations committed subsequent to the construction of the scanner.
.. Scans must include _all_ data written prior to the scan (except in the case where data is subsequently mutated, in which case it _may_ reflect the mutation)

Those familiar with relational databases will recognize this isolation level as "read committed".

NOTE: The guarantees listed above regarding scanner consistency are referring to "transaction commit time", not the "timestamp" field of each cell. That is to say, a scanner started at time _t_ may see edits with a timestamp value greater than _t_, if those edits were committed with a "forward dated" timestamp before the scanner was constructed.

== Visibility

. When a client receives a "success" response for any mutation, that mutation is immediately visible to both that client and any client with whom it later communicates through side channels.footnoteref[consistency]
. A row must never exhibit so-called "time-travel" properties. That is to say, if a series of mutations moves a row sequentially through a series of states, any sequence of concurrent reads will return a subsequence of those states. +
For example, if a row's cells are mutated using the `incrementColumnValue` API, a client must never see the value of any cell decrease. +
This is true regardless of which read API is used to read back the mutation.
. Any version of a cell that has been returned to a read operation is guaranteed to be durably stored.

== Durability
. All visible data is also durable data. That is to say, a read will never return data that has not been made durable on disk.footnoteref[durability,In the context of Apache HBase, _durably on disk_; implies an `hflush()` call on the transaction log. This does not actually imply an `fsync()` to magnetic media, but rather just that the data has been written to the OS cache on all replicas of the log. In the case of a full datacenter power loss, it is possible that the edits are not truly durable.]
. Any operation that returns a "success" code (eg does not throw an exception) will be made durable.footnoteref[durability]
. Any operation that returns a "failure" code will not be made durable (subject to the Atomicity guarantees above).
. All reasonable failure scenarios will not affect any of the guarantees of this document.

== Tunability

All of the above guarantees must be possible within Apache HBase. For users who would like to trade off some guarantees for performance, HBase may offer several tuning options. For example:

* Visibility may be tuned on a per-read basis to allow stale reads or time travel.
* Durability may be tuned to only flush data to disk on a periodic basis.

== More Information

For more information, see the link:book.html#client[client architecture] and  link:book.html#datamodel[data model] sections in the Apache HBase Reference Guide.