Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/transaction below:

Class Transaction (9.1.0) | Node.js client library

Stay organized with collections Save and categorize content based on your preferences.

• 9.1.0 (latest)
• 8.7.0
• 8.6.0
• 8.5.0
• 8.4.0
• 8.3.0
• 8.2.2
• 8.1.0
• 8.0.0
• 6.6.2
• 6.5.0
• 6.4.8
• 6.3.1

A transaction is a set of Datastore operations on one or more entities. Each transaction is guaranteed to be atomic, which means that transactions are never partially applied. Either all of the operations in the transaction are applied, or none of them are applied.

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

constructor(datastore: Datastore, options?: TransactionOptions);

Constructs a new instance of the Transaction class

modifiedEntities_: ModifiedEntities;

commit(gaxOptions?: CallOptions): Promise<CommitResponse>;

Commit the remote transaction and finalize the current transaction instance.

If the commit request fails, we will automatically rollback the transaction.

Request configuration options, outlined here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

transaction.commit((err, apiResponse) => {
  if (err) {
    // Transaction could not be committed.
  }
});

//-
// If the callback is omitted, we'll return a Promise.
//-
transaction.commit().then((data) => {
  const apiResponse = data[0];
});

commit(callback: CommitCallback): void;

commit(gaxOptions: CallOptions, callback: CommitCallback): void;

createAggregationQuery(query: Query): AggregateQuery;

Create an aggregation query from the query specified. See {module:datastore/query} for all of the available methods.

createQuery(kind?: string): Query;

Create a query for the specified kind. See {module:datastore/query} for all of the available methods.

The kind to query.

{Query}

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

// Run the query inside the transaction.
transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }
  const ancestorKey = datastore.key(['ParentCompany', 'Alphabet']);

  const query = transaction.createQuery('Company')
      .hasAncestor(ancestorKey);

  query.run((err, entities) => {
    if (err) {
      // Error handling omitted.
    }

    transaction.commit((err) => {
      if (!err) {
        // Transaction committed successfully.
      }
    });
  });
});

// Run the query inside the transaction.with namespace
transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }
  const ancestorKey = datastore.key(['ParentCompany', 'Alphabet']);

  const query = transaction.createQuery('CompanyNamespace', 'Company')
      .hasAncestor(ancestorKey);

  query.run((err, entities) => {
    if (err) {
      // Error handling omitted.
    }

    transaction.commit((err) => {
      if (!err) {
        // Transaction committed successfully.
      }
    });
  });
});

createQuery(kind?: string[]): Query;

createQuery(namespace: string, kind: string): Query;

createQuery(namespace: string, kind: string[]): Query;

delete(entities?: Entities): any;

Delete all entities identified with the specified key(s) in the current transaction.

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }

  // Delete a single entity.
  transaction.delete(datastore.key(['Company', 123]));

  // Delete multiple entities at once.
  transaction.delete([
    datastore.key(['Company', 123]),
    datastore.key(['Product', 'Computer'])
  ]);

  transaction.commit((err) => {
    if (!err) {
      // Transaction committed successfully.
    }
  });
});

get(keys: entity.Key | entity.Key[], options?: CreateReadStreamOptions): Promise<GetResponse>;

This function calls get on the super class. If the transaction has not been started yet then the transaction is started before the get call is made.

Datastore key object(s).

Optional configuration.

get(keys: entity.Key | entity.Key[], callback: GetCallback): void;

get(keys: entity.Key | entity.Key[], options: CreateReadStreamOptions, callback: GetCallback): void;

insert(entities: Entities): void;

Maps to Datastore#save, forcing the method to be insert.

Datastore key object(s).

rollback(callback: RollbackCallback): void;

Reverse a transaction remotely and finalize the current transaction instance.

The callback function.

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }

  transaction.rollback((err) => {
    if (!err) {
      // Transaction rolled back successfully.
    }
  });
});

//-
// If the callback is omitted, we'll return a Promise.
//-
transaction.rollback().then((data) => {
  const apiResponse = data[0];
});

rollback(gaxOptions?: CallOptions): Promise<RollbackResponse>;

rollback(gaxOptions: CallOptions, callback: RollbackCallback): void;

run(options?: RunOptions): Promise<RunResponse>;

Begin a remote transaction. In the callback provided, run your transactional commands.

Configuration object.

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

transaction.run((err, transaction) => {
  // Perform Datastore transactional operations.
  const key = datastore.key(['Company', 123]);

  transaction.get(key, (err, entity) => {
    entity.name = 'Google';

    transaction.save({
      key: key,
      data: entity
    });

    transaction.commit((err) => {
      if (!err) {
        // Data saved successfully.
      }
    });
  });
});

//-
// If the callback is omitted, we'll return a Promise.
//-
transaction.run().then((data) => {
  const transaction = data[0];
  const apiResponse = data[1];
});

run(callback: RunCallback): void;

run(options: RunOptions, callback: RunCallback): void;

runAggregationQuery(query: AggregateQuery, options?: RunQueryOptions): Promise<RunQueryResponse>;

This function calls runAggregationQuery on the super class. If the transaction has not been started yet then the transaction is started before the runAggregationQuery call is made.

AggregateQuery object.

Optional configuration

runAggregationQuery(query: AggregateQuery, options: RunQueryOptions, callback: RequestCallback): void;

runAggregationQuery(query: AggregateQuery, callback: RequestCallback): void;

runQuery(query: Query, options?: RunQueryOptions): Promise<RunQueryResponse>;

This function calls runQuery on the super class. If the transaction has not been started yet then the transaction is started before the runQuery call is made.

Query object.

Optional configuration.

runQuery(query: Query, options: RunQueryOptions, callback: RunQueryCallback): void;

runQuery(query: Query, callback: RunQueryCallback): void;

save(entities: Entities): void;

Insert or update the specified object(s) in the current transaction. If a key is incomplete, its associated object is inserted and the original Key object is updated to contain the generated ID.

This method will determine the correct Datastore method to execute (upsert, insert, or update) by using the key(s) provided. For example, if you provide an incomplete key (one without an ID), the request will create a new entity and have its ID automatically assigned. If you provide a complete key, the entity will be updated with the data specified.

By default, all properties are indexed. To prevent a property from being included in *all* indexes, you must supply an excludeFromIndexes array. See below for an example.

Datastore key object(s).

Save a single entity.
const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

// Notice that we are providing an incomplete key. After the transaction is
// committed, the Key object held by the `key` variable will be populated
// with a path containing its generated ID.
//-
const key = datastore.key('Company');

transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }

  transaction.save({
    key: key,
    data: {
      rating: '10'
    }
  });

  transaction.commit((err) => {
    if (!err) {
      // Data saved successfully.
    }
  });
});

const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();

// Use an array, `excludeFromIndexes`, to exclude properties from indexing.
// This will allow storing string values larger than 1500 bytes.

transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }

  transaction.save({
    key: key,
    excludeFromIndexes: [
      'description',
      'embeddedEntity.description',
      'arrayValue[].description'
    ],
    data: {
      description: 'Long string (...)',
      embeddedEntity: {
        description: 'Long string (...)'
      },
      arrayValue: [
        {
          description: 'Long string (...)'
        }
      ]
    }
  });

  transaction.commit((err) => {
    if (!err) {
      // Data saved successfully.
    }
  });
});

Save multiple entities at once.
const {Datastore} = require('@google-cloud/datastore');
const datastore = new Datastore();
const transaction = datastore.transaction();
const companyKey = datastore.key(['Company', 123]);
const productKey = datastore.key(['Product', 'Computer']);

transaction.run((err) => {
  if (err) {
    // Error handling omitted.
  }

  transaction.save([
    {
      key: companyKey,
      data: {
        HQ: 'Dallas, TX'
      }
    },
    {
      key: productKey,
      data: {
        vendor: 'Dell'
      }
    }
  ]);

  transaction.commit((err) => {
    if (!err) {
      // Data saved successfully.
    }
  });
});

update(entities: Entities): void;

Maps to Datastore#save, forcing the method to be update.

Datastore key object(s).

upsert(entities: Entities): void;

Maps to Datastore#save, forcing the method to be upsert.

Datastore key object(s).

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2025-08-07 UTC.

[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Hard to understand","hardToUnderstand","thumb-down"],["Incorrect information or sample code","incorrectInformationOrSampleCode","thumb-down"],["Missing the information/samples I need","missingTheInformationSamplesINeed","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-08-07 UTC."],[],[]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4