此页面由 Cloud Translation API 翻译。

更新

在事务中使用更新。

深入探索

如需查看包含此代码示例的详细文档，请参阅以下内容：

代码示例

C#

如需了解如何安装和使用适用于 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。如需了解详情，请参阅 Datastore 模式 C# API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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();
    }
}

Go

如需了解如何安装和使用适用于 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。有关详情，请参阅 Datastore 模式 Go API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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)
}

Java

如需了解如何安装和使用 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。有关详情，请参阅 Datastore 模式 Java API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

void transferFunds(Key fromKey, Key toKey, long amount) {
  Transaction txn = datastore.newTransaction();
  try {
    List<Entity> entities = txn.fetch(fromKey, toKey);
    Entity from = entities.get(0);
    Entity updatedFrom =
        Entity.newBuilder(from).set("balance", from.getLong("balance") - amount).build();
    Entity to = entities.get(1);
    Entity updatedTo =
        Entity.newBuilder(to).set("balance", to.getLong("balance") + amount).build();
    txn.put(updatedFrom, updatedTo);
    txn.commit();
  } finally {
    if (txn.isActive()) {
      txn.rollback();
    }
  }
}

Node.js

如需了解如何安装和使用适用于 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。有关详情，请参阅 Datastore 模式 Node.js API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

async function transferFunds(fromKey, toKey, amount) {
  const transaction = datastore.transaction();
  await transaction.run();
  const results = await Promise.all([
    transaction.get(fromKey),
    transaction.get(toKey),
  ]);
  const accounts = results.map(result => result[0]);

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

  transaction.save([
    {
      key: fromKey,
      data: accounts[0],
    },
    {
      key: toKey,
      data: accounts[1],
    },
  ]);

  return await transaction.commit();
}

PHP

如需了解如何安装和使用 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。如需了解详情，请参阅 Datastore 模式 PHP API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

/**
 * Update two entities in a transaction.
 *
 * @param string $fromKeyId
 * @param string $toKeyId
 * @param int $amount
 * @param string $namespaceId
 */
function transfer_funds(
    string $fromKeyId,
    string $toKeyId,
    int $amount,
    string $namespaceId = null
) {
    $datastore = new DatastoreClient(['namespaceId' => $namespaceId]);
    $transaction = $datastore->transaction();
    $fromKey = $datastore->key('Account', $fromKeyId);
    $toKey = $datastore->key('Account', $toKeyId);
    // The option 'sort' is important here, otherwise the order of the result
    // might be different from the order of the keys.
    $result = $transaction->lookupBatch([$fromKey, $toKey], ['sort' => true]);
    if (count($result['found']) != 2) {
        $transaction->rollback();
    }
    $fromAccount = $result['found'][0];
    $toAccount = $result['found'][1];
    $fromAccount['balance'] -= $amount;
    $toAccount['balance'] += $amount;
    $transaction->updateBatch([$fromAccount, $toAccount]);
    $transaction->commit();
}

Python

如需了解如何安装和使用适用于 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。有关详情，请参阅 Datastore 模式 Python API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

from google.cloud import datastore

# For help authenticating your client, visit
# https://cloud.google.com/docs/authentication/getting-started
client = datastore.Client()

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

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

        client.put_multi([from_account, to_account])

Ruby

如需了解如何安装和使用 Datastore 模式的客户端库，请参阅 Datastore 模式客户端库。有关详情，请参阅 Datastore 模式 Ruby API 参考文档。

如需向 Datastore 模式进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

def transfer_funds from_key, to_key, amount
  datastore.transaction do |tx|
    from = tx.find from_key
    from["balance"] -= amount
    to = tx.find to_key
    to["balance"] += amount
    tx.save from, to
  end
end

后续步骤

如需搜索和过滤其他 Google Cloud 产品的代码示例，请参阅 Google Cloud 示例浏览器。