Class Transaction (6.16.0)

Package

Examples

const {Spanner} = require('@google-cloud/spanner');
const spanner = new Spanner();

const instance = spanner.instance('my-instance');
const database = instance.database('my-database');

database.runTransaction(function(err, transaction) {
  // The `transaction` object is ready for use.
});

To manually control retrying the transaction, use the getTransaction method.

database.getTransaction(function(err, transaction) {
  // The `transaction` object is ready for use.
});

Constructors

(constructor)(session, options, queryOptions, requestOptions)

constructor(session: Session, options?: spannerClient.spanner.v1.TransactionOptions.ReadWrite, queryOptions?: IQueryOptions, requestOptions?: Pick<IRequestOptions, 'transactionTag'>);

const query = 'UPDATE Account SET Balance = 1000 WHERE Key = 1';

transaction.runUpdate(query, (err, rowCount) => {
  if (err) {
    // Error handling omitted.
  }
});

Properties

commitTimestamp

commitTimestamp?: PreciseDate;

commitTimestampProto

commitTimestampProto?: spannerClient.protobuf.ITimestamp;

Methods

batchUpdate(queries, options)

batchUpdate(queries: Array<string | Statement>, options?: BatchUpdateOptions | CallOptions): Promise<BatchUpdateResponse>;

const queries = [
  {
    sql: 'INSERT INTO MyTable (Key, Value) VALUES (@key, @value)',
    params: {key: 'my-key', value: 'my-value'},
  },
  {
    sql: 'UPDATE MyTable t SET t.Value = @value WHERE t.KEY = @key',
    params: {key: 'my-other-key', value: 'my-other-value'}
  }
];

transaction.batchUpdate(queries, (err, rowCounts, apiResponse) => {
  if (err) {
    // Error handling omitted.
  }
});

If the callback is omitted, we'll return a Promise.

const [rowCounts, apiResponse] = await transaction.batchUpdate(queries);

batchUpdate(queries, callback)

batchUpdate(queries: Array<string | Statement>, callback: BatchUpdateCallback): void;

batchUpdate(queries, options, callback)

batchUpdate(queries: Array<string | Statement>, options: BatchUpdateOptions | CallOptions, callback: BatchUpdateCallback): void;

commit(options)

commit(options?: CommitOptions | CallOptions): Promise<CommitResponse>;

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue a mutation (note that there is no callback passed to `insert`).
  transaction.insert('Singers', {
    SingerId: 'Id3b',
    Name: 'Joe West'
  });

  // Commit the transaction.
  transaction.commit(function(err, apiResponse) {
    if (!err) {
      // Get the commit timestamp on successful commits.
      const {commitTimestamp} = apiResponse;
    }
  });
});

commit(callback)

commit(callback: CommitCallback): void;

commit(options, callback)

commit(options: CommitOptions | CallOptions, callback: CommitCallback): void;

deleteRows(table, keys)

deleteRows(table: string, keys: Key[]): void;

const keys = ['Id1', 'Id2', 'Id3'];

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue this mutation until later calling `commit`.
  // Note that a callback is not passed to `deleteRows`.
  transaction.deleteRows('Singers', keys);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The rows were deleted successfully.
    }
  });
});

Provide an array for keys to delete rows with a composite key.

const keys = [
  [
    'Id1',
    'Name1'
  ],
  [
    'Id2',
    'Name2'
  ]
];

getUniqueKeys(rows)

static getUniqueKeys(rows: object[]): string[];

insert(table, rows)

insert(table: string, rows: object | object[]): void;

const row = {
  SingerId: 'Id3',
  Name: 'Eddie Wilson'
};

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue this mutation until later calling `commit`.
  // Note that a callback is not passed to `insert`.
  transaction.insert('Singers', row);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The row was inserted successfully.
    }
  });
});

Multiple rows can be inserted at once.

const row2 = {
  SingerId: 'Id3b',
  Name: 'Joe West'
};

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue multiple mutations until later calling `commit`.
  // Note that a callback is not passed to `insert`.
  transaction.insert('Singers', [
    row,
    row2
  ]);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The rows were inserted successfully.
    }
  });
});

replace(table, rows)

replace(table: string, rows: object | object[]): void;

const row = {
  SingerId: 'Id3',
  Name: 'Joe West'
};

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue this mutation until later calling `commit`.
  // Note that a callback is not passed to `replace`.
  transaction.replace('Singers', row);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The row was replaced successfully.
    }
  });
});

rollback(gaxOptions)

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

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

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

rollback(callback)

rollback(callback: spannerClient.spanner.v1.Spanner.RollbackCallback): void;

rollback(gaxOptions, callback)

rollback(gaxOptions: CallOptions, callback: spannerClient.spanner.v1.Spanner.RollbackCallback): void;

update(table, rows)

update(table: string, rows: object | object[]): void;

const row = {
  SingerId: 'Id3',
  Name: 'Joe West'
};

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue this mutation until later calling `commit`.
  // Note that a callback is not passed to `update`.
  transaction.update('Singers', row);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The row was updated successfully.
    }
  });
});

upsert(table, rows)

upsert(table: string, rows: object | object[]): void;

const row = {
  SingerId: 'Id3',
  Name: 'Joe West'
};

database.runTransaction(function(err, transaction) {
  if (err) {
    // Error handling omitted.
  }

  // Queue this mutation until later calling `commit`.
  // Note that a callback is not passed to `upsert`.
  transaction.upsert('Singers', row);

  // Commit the transaction.
  transaction.commit(function(err) {
    if (!err) {
      // The row was updated or inserted successfully.
    }
  });
});

useInRunner()

useInRunner(): void;

useOptimisticLock()

useOptimisticLock(): void;