Transactions

View on GitHub

function transferFunds (fromKey, toKey, amount, callback) {
  var transaction = datastore.transaction();

  transaction.run(function (err) {
    if (err) {
      return callback(err);
    }

    transaction.get([
      fromKey,
      toKey
    ], function (err, accounts) {
      if (err) {
        return transaction.rollback(function (_err) {
          return callback(_err || err);
        });
      }

      accounts[0].data.balance -= amount;
      accounts[1].data.balance += amount;

      transaction.save(accounts);

      transaction.commit(function (err) {
        if (err) {
          return callback(err);
        }

        // The transaction completed successfully.
        callback();
      });
    });
  });
}

Go

View on GitHub

type BankAccount struct {
	Balance int
}

const amount = 50
keys := []*datastore.Key{to, from}
tx, err := client.NewTransaction(ctx)
if err != nil {
	log.Fatalf("client.NewTransaction: %v", err)
}
accs := make([]BankAccount, 2)
if err := tx.GetMulti(keys, accs); err != nil {
	tx.Rollback()
	log.Fatalf("tx.GetMulti: %v", err)
}
accs[0].Balance += amount
accs[1].Balance -= amount
if _, err := tx.PutMulti(keys, accs); err != nil {
	tx.Rollback()
	log.Fatalf("tx.PutMulti: %v", err)
}
if _, err = tx.Commit(); err != nil {
	log.Fatalf("tx.Commit: %v", err)
}

Python

View on GitHub

def transfer_funds(client, from_key, to_key, amount):
    with client.transaction():
        from_account, to_account = client.get_multi([from_key, to_key])

        from_account['balance'] -= amount
        to_account['balance'] += amount

        client.put_multi([from_account, to_account])

C#

datastore/src/main/java/com/google/datastore/snippets/Concepts.java

View on GitHub

private void TransferFunds(Key fromKey, Key toKey, long amount)
{
    using (var transaction = _db.BeginTransaction())
    {
        var entities = transaction.Lookup(fromKey, toKey);
        entities[0]["balance"].IntegerValue -= amount;
        entities[1]["balance"].IntegerValue += amount;
        transaction.Update(entities);
        transaction.Commit();
    }
}

Note that in order to keep our examples more succinct we sometimes omit the rollback if the transaction fails. In production code it is important to ensure that every transaction is either explicitly committed or rolled back.

What can be done in a transaction

All Cloud Datastore operations in a transaction can operate on a maximum of twenty-five entity groups. This includes querying for entities by ancestor, retrieving entities by key, updating entities, and deleting entities.

When two or more transactions simultaneously attempt to modify entities in one or more common entity groups, only the first transaction to commit its changes can succeed; all the others will fail on commit. Because of this design, using entity groups limits the number of concurrent writes you can do on any entity in the groups. When a transaction starts, Cloud Datastore uses optimistic concurrency control by checking the last update time for the entity groups used in the transaction. Upon commiting a transaction for the entity groups, Cloud Datastore again checks the last update time for the entity groups used in the transaction. If it has changed since our initial check, an error is returned. For an explanation of entity groups, see Ancestor paths.

Isolation and consistency

Outside of transactions, Cloud Datastore's isolation level is closest to read committed. Inside of transactions, serializable isolation is enforced. This means that another transaction cannot concurrently modify the data that is read or modified by this transaction. Read the serializable isolation wiki and the Transaction Isolation article for more information on isolation levels.

In a transaction, all reads reflect the current, consistent state of Cloud Datastore at the time the transaction started. Queries and lookups inside a transaction are guaranteed to see a single, consistent snapshot of Cloud Datastore as of the beginning of the transaction. Entities and index rows in the transaction's entity group are fully updated so that queries return the complete, correct set of result entities, without the false positives or false negatives described in Transaction Isolation that can occur in queries outside of transactions.

This consistent snapshot view also extends to reads after writes inside transactions. Unlike with most databases, queries and gets inside a Cloud Datastore transaction do not see the results of previous writes inside that transaction. Specifically, if an entity is modified or deleted within a transaction, a query or lookup returns the original version of the entity as of the beginning of the transaction, or nothing if the entity did not exist then.

Uses for transactions

One use of transactions is updating an entity with a new property value relative to its current value. The transferFunds example above does that for two entities, by withdrawing money from one account and transferring it to another. The Cloud Datastore API does not automatically retry transactions, but you can add your own logic to retry them, for instance to handle conflicts when another request updates the same entity at the same time.

Java

View on GitHub

int retries = 5;
while (true) {
  try {
    transferFunds(fromKey, toKey, 10);
    break;
  } catch (DatastoreException e) {
    if (retries == 0) {
      throw e;
    }
    --retries;
  }
}
// Retry handling can also be configured and automatically applied using gcloud-java.

Node.js

View on GitHub

var async = require('async');

function attemptTransfer (callback) {
  transferFunds(fromKey, toKey, 10, callback);
}

async.retry(5, attemptTransfer, callback);

Go

View on GitHub

type BankAccount struct {
	Balance int
}

const amount = 50
_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
	keys := []*datastore.Key{to, from}
	accs := make([]BankAccount, 2)
	if err := tx.GetMulti(keys, accs); err != nil {
		return err
	}
	accs[0].Balance += amount
	accs[1].Balance -= amount
	_, err := tx.PutMulti(keys, accs)
	return err
})

Python

View on GitHub

for _ in range(5):
    try:
        transfer_funds(client, account1.key, account2.key, 50)
    except gcloud.exceptions.Conflict:
        continue

C#

datastore/src/main/java/com/google/datastore/snippets/Concepts.java

View on GitHub

        /// <summary>
        /// Retry the action when a Grpc.Core.RpcException is thrown.
        /// </summary>
        private T RetryRpc<T>(Func<T> action)
        {
            List<Grpc.Core.RpcException> exceptions = null;
            var delayMs = _retryDelayMs;
            for (int tryCount = 0; tryCount < _retryCount; ++tryCount)
            {
                try
                {
                    return action();
                }
                catch (Grpc.Core.RpcException e)
                {
                    if (exceptions == null)
                        exceptions = new List<Grpc.Core.RpcException>();
                    exceptions.Add(e);
                }
                System.Threading.Thread.Sleep(delayMs);
                delayMs *= 2;  // Exponential back-off.
            }
            throw new AggregateException(exceptions);
        }

        private void RetryRpc(Action action)
        {
            RetryRpc(() => { action(); return 0; });
        }

        [Fact]
        public void TestTransactionalRetry()
        {
            int tryCount = 0;
            var keys = UpsertBalances();
            RetryRpc(() =>
            {
                using (var transaction = _db.BeginTransaction())
                {
                    TransferFunds(keys[0], keys[1], 10, transaction);
                    // Insert a conflicting transaction on the first try.
                    if (tryCount++ == 0)
                        TransferFunds(keys[1], keys[0], 5);
                    transaction.Commit();
                }
            });
            Assert.Equal(2, tryCount);
        }

This requires a transaction because the value of balance in an entity may be updated by another user after this code fetches the object, but before it saves the modified object. Without a transaction, the user's request uses the value of balance prior to the other user's update, and the save overwrites the new value. With a transaction, the application is told about the other user's update.

Another common use for transactions is to fetch an entity with a named key, or create it if it doesn't yet exist (this example builds on the TaskList example from creating an entity):

Java

View on GitHub

Entity task;
Transaction txn = datastore.newTransaction();
try {
  task = txn.get(taskKey);
  if (task == null) {
    task = Entity.builder(taskKey).build();
    txn.put(task);
    txn.commit();
  }
} finally {
  if (txn.active()) {
    txn.rollback();
  }
}

Node.js

View on GitHub

function getOrCreate (taskKey, taskData, callback) {
  var taskEntity = {
    key: taskKey,
    data: taskData
  };

  var transaction = datastore.transaction();

  transaction.run(function (err) {
    if (err) {
      return callback(err);
    }

    transaction.get(taskKey, function (err, task) {
      if (err) {
        // An error occurred while getting the values.
        return transaction.rollback(function (_err) {
          return callback(_err || err);
        });
      }

      if (task) {
        // The task entity already exists.
        transaction.rollback(callback);
      } else {
        // Create the task entity.
        transaction.save(taskEntity);
        transaction.commit(function (err) {
          if (err) {
            return callback(err);
          }
          // The transaction completed successfully.
          callback(null, taskEntity);
        });
      }
    });
  });
}

Go

View on GitHub

_, err := client.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
	var task Task
	if err := tx.Get(key, &task); err != datastore.ErrNoSuchEntity {
		return err
	}
	_, err := tx.Put(key, &Task{
		Category:    "Personal",
		Done:        false,
		Priority:    4,
		Description: "Learn Cloud Datastore",
	})
	return err
})

Python

View on GitHub

with client.transaction():
    key = client.key('Task', datetime.datetime.utcnow().isoformat())

    task = client.get(key)

    if not task:
        task = datastore.Entity(key)
        task.update({
            'description': 'Example task'
        })
        client.put(task)

    return task

C#

datastore/src/main/java/com/google/datastore/snippets/Concepts.java

View on GitHub

Entity task;
using (var transaction = _db.BeginTransaction())
{
    task = transaction.Lookup(_sampleTask.Key);
    if (task == null)
    {
        transaction.Insert(_sampleTask);
        transaction.Commit();
    }
}

As before, a transaction is necessary to handle the case where another user is attempting to create or update an entity with the same string ID. Without a transaction, if the entity does not exist and two users attempt to create it, the second overwrites the first without knowing that it happened.

When a transaction fails, you can have your app retry the transaction until it succeeds, or you can let your users deal with the error by propagating it to your app's user interface level. You do not have to create a retry loop around every transaction.

Finally, you can use a transaction to read a consistent snapshot of Cloud Datastore. This can be useful when multiple reads are needed to render a page or export data that must be consistent. These kinds of transactions are often called read-only transactions, since they perform no writes. Read-only single-group transactions never fail due to concurrent modifications, so you don't have to implement retries upon failure. However, multi-entity-group transactions can fail due to concurrent modifications, so these should have retries.

Java

View on GitHub

Entity taskList;
QueryResults<Entity> tasks;
Transaction txn = datastore.newTransaction();
try {
  taskList = txn.get(taskListKey);
  Query<Entity> query = Query.entityQueryBuilder()
      .kind("Task")
      .filter(PropertyFilter.hasAncestor(taskListKey))
      .build();
  tasks = txn.run(query);
  txn.commit();
} finally {
  if (txn.active()) {
    txn.rollback();
  }
}

Node.js

View on GitHub

function getTaskListEntities (callback) {
  var taskListEntities;

  var transaction = datastore.transaction();

  transaction.run(function (err) {
    if (err) {
      return callback(err);
    }

    var taskListKey = datastore.key(['TaskList', 'default']);

    datastore.get(taskListKey, function (err) {
      if (err) {
        return transaction.rollback(function (_err) {
          return callback(_err || err);
        });
      }

      var query = datastore.createQuery('Task')
        .hasAncestor(taskListKey);

      datastore.runQuery(query, function (err, entities) {
        if (err) {
          // An error occurred while running the query.
          return transaction.rollback(function (_err) {
            return callback(_err || err);
          });
        }

        taskListEntities = entities;
        transaction.commit(function (err) {
          if (err) {
            return callback(err);
          }

          // The transaction completed successfully.
          callback(null, taskListEntities);
        });
      });
    });
  });
}

Go

View on GitHub

tx, err := client.NewTransaction(ctx)
if err != nil {
	log.Fatalf("client.NewTransaction: %v", err)
}
defer tx.Rollback() // Transaction only used for read.

ancestor := datastore.NewKey(ctx, "TaskList", "default", 0, nil)
query := datastore.NewQuery("Task").Ancestor(ancestor).Transaction(tx)
var tasks []Task
_, err = client.GetAll(ctx, query, &tasks)

Python

View on GitHub

with client.transaction():
    task_list_key = client.key('TaskList', 'default')

    task_list = client.get(task_list_key)

    query = client.query(kind='Task', ancestor=task_list_key)
    tasks_in_list = list(query.fetch())

    return task_list, tasks_in_list

C#