Multi-version concurrency control across row store and column store

Patent metadata

Field	Value
Publication number	US-9483516-B2
Application number	US-201414213807-A
Country	US
Kind code	B2
Filing date	Mar 14, 2014
Priority date	Mar 14, 2014
Publication date	Nov 1, 2016
Grant date	Nov 1, 2016

Abstract

Techniques and solutions are provided for performing transactions within a database system that stores database data using a row store and a column store. For example, a transaction that performs operations to update data in both the row store and the column store can use the same transaction object. The state of the transaction can be atomically changed. For example, the state of the transaction object can be atomically changed from uncommitted to committed (e.g., set to a commit identifier to represent the committed state).

First claim

What is claimed is:

1. A method, implemented at least in part by computing device, for performing transactions within an in-memory database system that stores database data using, at least in part, a row store and a column store, the method comprising:
performing a transaction within the in-memory database system, comprising:
updating data in the row store;
creating an association between the updated row store data and a transaction object associated with the transaction;
updating data in the column store;
creating an association between the updated column store data and the transaction object associated with the transaction; and
atomically committing the transaction comprising the row store update and the column store update;
wherein the transaction object stores a transaction state for the transaction, and wherein the transaction object is a single transaction object that is shared across the row store and the column store for the transaction.

2. The method of claim 1 , wherein updating data in the row store comprises writing a new version of a row store data record, and wherein updating data in the column store comprises writing a new version of a column store data record.

3. The method of claim 1 , wherein updating the data in the row store comprises:
creating a new row store data record version in version space associated with the row store;
wherein the association between the updated row store data and the transaction object comprises a pointer from the new row store data record version to the transaction object.

4. The method of claim 1 , wherein the association between the updated column store data and the transaction object comprises one or more pointers, and wherein updating the data in the column store comprises:
creating a new column store data record version in table space associated with the column store;
creating a destroy timestamp, in version space associated with the column store, associated with an original version of the column store data record; and
creating a creation timestamp, in version space associated with the column store, associated with the new column store data record version.

5. The method of claim 4 , wherein the association between the updated column store data and the transaction object comprises:
a pointer from the destroy timestamp to the transaction object; and
a pointer from the creation timestamp to the transaction object.

6. The method of claim 1 , wherein atomically committing the transaction comprises:
changing the transaction object from an uncommitted state to a committed state.

7. The method of claim 1 , further comprising:
setting the transaction object to an uncommitted state;
wherein atomically committing the transaction comprises:
incrementing a global commit timestamp value; and
switching the transaction object to a committed state comprising assigning the incremented global commit timestamp value to the transaction object.

8. The method of claim 1 , further comprising:
performing a second transaction within the in-memory database system, comprising:
copying a current global commit timestamp value to the second transaction to create a copy of the current global commit timestamp value associated with the second transaction; and
determining a version of at least one of row store data and column store data that can be read by the second transaction by comparing the copy of the current global commit timestamp value to timestamp values associated with one or more versions of the one or more of row store data and column store data to be read by the second transaction.

9. A server environment comprising:
one or more computer servers comprising at least a processing unit and a memory; and
an in-memory database system configured to perform transactions using database data stored, at least in part, in a row store and a column store, the in-memory database system comprising:
the row store, wherein the row store is configured to:
store row store data;
store updated row store data; and
store pointers associating the updated row store data with transaction objects;

the column store, wherein the column store is configured to:
store column store data;
store updated column store data; and
store pointers associating the updated column store data with transaction objects; and

a transaction manager configured to:
create associations between the updated row store data and transaction objects stored by the transaction manager;
create associations between the updated column store data and transaction objects stored by the transaction manager; and
atomically commit transactions;
wherein each transaction is associated with a single transaction object that is shared across the row store and the column store, and wherein each transaction stores a transaction state for the transaction.

10. The server environment of claim 9 , wherein the row store is configured to store the updated row store data in version space associated with the row store, and wherein the column store is configured to store the updated column store data in table space associated with the column store.

11. The server environment of claim 9 , wherein the column store comprises column store version space storing:
destroy timestamps associated with the column store data which is being updated by the transactions; and
creation timestamps associated with the updated column store data.

12. The server environment of claim 9 , wherein the transaction manager atomically commits a transaction by changing a transaction object, associated with the transaction, from an uncommitted state to a committed state.

13. The server environment of claim 9 , wherein the transaction manager is configured to perform a transaction by:
setting the transaction object to an uncommitted state; and
atomically committing the transaction comprising:
incrementing a global commit timestamp value; and
switching the transaction object to a committed state comprising assigning the global commit timestamp value to the transaction object.

14. The server environment of claim 9 , wherein the transaction manger is further configured to commit a transaction associated with a transaction object by:
incrementing a global commit timestamp value maintained by the transaction manager;
switching the transaction object to a committed state comprising assigning the global commit timestamp value to the transaction object; and
copying the global commit timestamp value to updated column store data records and updated row store data records that are being updated by the transaction.

15. A computer-readable storage medium storing computer-executable instructions for causing a computing device to perform a method for implementing transactions within an in-memory database system that stores database data using, at least in part, a row store and a column store, the method comprising:
for each of a plurality of transaction within the in-memory database system:
updating data within at least one of the row store and the column store; and
creating an association between the updated data, within at least one of the row store and the column store, and a transaction object associated with the transaction;

associating each transaction object with a group commit object, wherein the group commit object is a single object that is shared by the plurality of transactions; and
atomically committing the plurality of transactions, comprising:
incrementing a global commit timestamp value; and
switching the group commit object to a committed state comprising setting the group commit object to the global commit tim

Assignees

• Lee Juchang
• Schreter Ivan
• Park Chang Gyoo
• Noh Jaeyun
• Kim Eunsang
• Cha Sang Kyun
• Sap Se

Inventors

• Lee Juchang
• Schreter Ivan
• Park Chang Gyoo
• Noh Jaeyun
• Kim Eunsang
• Cha Sang Kyun

Classifications

• G06F16/2322 Primary

  using timestamps · CPC title

• G06F16/2329

  using versioning · CPC title

• G06F16/2365

  Ensuring data consistency and integrity · CPC title

• G06F17/30353 Primary

  Physics · mapped topic

• G06F17/30371

  Physics · mapped topic