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.
Package
@google-cloud/datastoreExample
const
{
Datastore
}
=
require
(
' @google-cloud/datastore
'
);
const
datastore
=
new
Datastore
();
const
transaction
=
datastore
.
transaction
();
Constructors
(constructor)(datastore, options)
constructor
(
datastore
:
Datastore
,
options
?:
TransactionOptions
);
Constructs a new instance of the Transaction
class
Properties
modifiedEntities_
modifiedEntities_
:
ModifiedEntities
;
namespace
namespace
?:
string
;
readOnly
readOnly
:
boolean
;
request
request
:
Function
;
skipCommit
skipCommit
?:
boolean
;
Methods
commit(gaxOptions)
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.
gaxOptions
CallOptions
Request configuration options, outlined here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.
Promise
< CommitResponse
>
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)
commit
(
callback
:
CommitCallback
)
:
void
;
callback
CommitCallback
void
commit(gaxOptions, callback)
commit
(
gaxOptions
:
CallOptions
,
callback
:
CommitCallback
)
:
void
;
gaxOptions
CallOptions
callback
CommitCallback
void
createAggregationQuery(query)
createAggregationQuery
(
query
:
Query
)
:
AggregateQuery
;
Create an aggregation query from the query specified. See {module:datastore/query} for all of the available methods.
AggregateQuery
createQuery(kind)
createQuery
(
kind
?:
string
)
:
Query
;
Create a query for the specified kind. See {module:datastore/query} for all of the available methods.
kind
string
The kind to 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)
createQuery
(
kind
?:
string
[])
:
Query
;
kind
string[]
createQuery(namespace, kind)
createQuery
(
namespace
:
string
,
kind
:
string
)
:
Query
;
namespace
string
kind
string
createQuery(namespace, kind)
createQuery
(
namespace
:
string
,
kind
:
string
[])
:
Query
;
namespace
string
kind
string[]
delete(entities)
delete
(
entities
?:
Entities
)
:
any
;
Delete all entities identified with the specified key(s) in the current transaction.
entities
Entities
any
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, options)
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.
keys
options
CreateReadStreamOptions
Optional configuration.
Promise
< GetResponse
>
get(keys, callback)
get
(
keys
:
entity
.
Key
|
entity
.
Key
[],
callback
:
GetCallback
)
:
void
;
void
get(keys, options, callback)
get
(
keys
:
entity
.
Key
|
entity
.
Key
[],
options
:
CreateReadStreamOptions
,
callback
:
GetCallback
)
:
void
;
keys
entity.Key
| entity.Key
[]
options
CreateReadStreamOptions
callback
GetCallback
void
insert(entities)
insert
(
entities
:
Entities
)
:
void
;
Maps to Datastore#save
, forcing the method to be insert
.
entities
Entities
Datastore key object(s).
void
rollback(callback)
rollback
(
callback
:
RollbackCallback
)
:
void
;
Reverse a transaction remotely and finalize the current transaction instance.
callback
RollbackCallback
The callback function.
void
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)
rollback
(
gaxOptions
?:
CallOptions
)
:
Promise<RollbackResponse>
;
gaxOptions
CallOptions
Promise
< RollbackResponse
>
rollback(gaxOptions, callback)
rollback
(
gaxOptions
:
CallOptions
,
callback
:
RollbackCallback
)
:
void
;
gaxOptions
CallOptions
callback
RollbackCallback
void
run(options)
run
(
options
?:
RunOptions
)
:
Promise<RunResponse>
;
Begin a remote transaction. In the callback provided, run your transactional commands.
options
RunOptions
Configuration object.
Promise
< RunResponse
>
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)
run
(
callback
:
RunCallback
)
:
void
;
callback
RunCallback
void
run(options, callback)
run
(
options
:
RunOptions
,
callback
:
RunCallback
)
:
void
;
options
RunOptions
callback
RunCallback
void
runAggregationQuery(query, options)
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.
query
AggregateQuery
AggregateQuery object.
options
RunQueryOptions
Optional configuration
Promise
< RunQueryResponse
>
runAggregationQuery(query, options, callback)
runAggregationQuery
(
query
:
AggregateQuery
,
options
:
RunQueryOptions
,
callback
:
RequestCallback
)
:
void
;
query
AggregateQuery
options
RunQueryOptions
callback
RequestCallback
void
runAggregationQuery(query, callback)
runAggregationQuery
(
query
:
AggregateQuery
,
callback
:
RequestCallback
)
:
void
;
query
AggregateQuery
callback
RequestCallback
void
runQuery(query, options)
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
options
RunQueryOptions
Optional configuration.
Promise
< RunQueryResponse
>
runQuery(query, options, callback)
runQuery
(
query
:
Query
,
options
:
RunQueryOptions
,
callback
:
RunQueryCallback
)
:
void
;
void
runQuery(query, callback)
runQuery
(
query
:
Query
,
callback
:
RunQueryCallback
)
:
void
;
void
save(entities)
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.
entities
Entities
Datastore key object(s).
void
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)
update
(
entities
:
Entities
)
:
void
;
Maps to Datastore#save
, forcing the method to be update
.
entities
Entities
Datastore key object(s).
void
upsert(entities)
upsert
(
entities
:
Entities
)
:
void
;
Maps to Datastore#save
, forcing the method to be upsert
.
entities
Entities
Datastore key object(s).
void
