Insert, update, and delete data using data manipulation language (DML)

voidDmlStructs(google::cloud::spanner::Clientclient){
namespacespanner=::google::cloud::spanner;
std::int64_trows_modified=0;
autocommit_result=
client.Commit([&client,&rows_modified](spanner::Transactionconst&txn)
->google::cloud::StatusOr<spanner::Mutations>{
autosinger_info=std::make_tuple("Marc","Richards");
autosql=spanner::SqlStatement(
"UPDATE Singers SET FirstName = 'Keith' WHERE "
"STRUCT<FirstName String, LastName String>(FirstName, LastName) "
"= @name",
{{"name", spanner::Value(std::move(singer_info))}});
autodml_result=client.ExecuteDml(txn,std::move(sql));
if(!dml_result)returnstd::move(dml_result).status();
rows_modified=dml_result->RowsModified();
returnspanner::Mutations{};
});
if(!commit_result)throwstd::move(commit_result).status();
std::cout << rows_modified
 << " update was successful [spanner_dml_structs]\n";
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem;
usingSystem.Threading.Tasks;
publicclassUpdateUsingDmlWithStructCoreAsyncSample
{
publicasyncTask<int>UpdateUsingDmlWithStructCoreAsync(stringprojectId,stringinstanceId,stringdatabaseId)
{
varnameStruct=newSpannerStruct
{
{"FirstName",SpannerDbType .String ,"Timothy"},
{"LastName",SpannerDbType .String ,"Campbell"}
};
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
usingvarconnection=newSpannerConnection (connectionString);
awaitconnection.OpenAsync ();
usingvarcmd=connection.CreateDmlCommand ("UPDATE Singers SET LastName = 'Grant' WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName) = @name");
cmd.Parameters .Add("name",nameStruct.GetSpannerDbType (),nameStruct);
introwCount=awaitcmd.ExecuteNonQueryAsync();
Console.WriteLine($"{rowCount} row(s) updated...");
returnrowCount;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
)
funcupdateUsingDMLStruct(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
_,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{
typenamestruct{
FirstNamestring
LastNamestring
}
varsingerInfo=name{"Timothy","Campbell"}
stmt:=spanner.Statement {
SQL:`Update Singers Set LastName = 'Grant'
				WHERE STRUCT<FirstName String, LastName String>(Firstname, LastName) = @name`,
Params:map[string]interface{}{"name":singerInfo},
}
rowCount,err:=txn.Update(ctx,stmt)
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"%d record(s) inserted.\n",rowCount)
returnnil
})
returnerr
}

staticvoidupdateUsingDmlWithStruct(DatabaseClientdbClient){
Structname=
Struct.newBuilder().set("FirstName").to("Timothy").set("LastName").to("Campbell").build();
Statements=
Statement.newBuilder(
"UPDATE Singers SET LastName = 'Grant' "
+"WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName) "
+"= @name")
.bind("name")
.to(name)
.build();
dbClient
.readWriteTransaction()
.run(transaction->{
longrowCount=transaction.executeUpdate(s);
System.out.printf("%d record updated.\n",rowCount);
returnnull;
});
}

// Imports the Google Cloud client library
const{Spanner}=require('@google-cloud/spanner');
constnameStruct=Spanner .struct ({
FirstName:'Timothy',
LastName:'Campbell',
});
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner instance and database
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
database.runTransaction (async(err,transaction)=>{
if(err){
console.error(err);
return;
}
try{
const[rowCount]=awaittransaction.runUpdate ({
sql:`UPDATE Singers SET LastName = 'Grant'
 WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName) = @name`,
params:{
name:nameStruct,
},
});
console.log(`Successfully updated ${rowCount} record.`);
awaittransaction.commit();
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}
});

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Database;
use Google\Cloud\Spanner\Transaction;
use Google\Cloud\Spanner\StructType;
use Google\Cloud\Spanner\StructValue;
/**
 * Update data with a DML statement using Structs.
 *
 * The database and table must already exist and can be created using
 * `create_database`.
 * Example:
 * ```
 * insert_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function update_data_with_dml_structs(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 $database->runTransaction(function (Transaction $t) {
 $nameValue = (new StructValue)
 ->add('FirstName', 'Timothy')
 ->add('LastName', 'Campbell');
 $nameType = (new StructType)
 ->add('FirstName', Database::TYPE_STRING)
 ->add('LastName', Database::TYPE_STRING);
 $rowCount = $t->executeUpdate(
 "UPDATE Singers SET LastName = 'Grant' "
 . 'WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName) '
 . '= @name',
 [
 'parameters' => [
 'name' => $nameValue
 ],
 'types' => [
 'name' => $nameType
 ]
 ]);
 $t->commit();
 printf('Updated %d row(s).' . PHP_EOL, $rowCount);
 });
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
record_type = param_types.Struct(
 [
 param_types.StructField("FirstName", param_types.STRING),
 param_types.StructField("LastName", param_types.STRING),
 ]
)
record_value = ("Timothy", "Campbell")
defwrite_with_struct(transaction):
 row_ct = transaction.execute_update(
 "UPDATE Singers SET LastName = 'Grant' "
 "WHERE STRUCT<FirstName STRING, LastName STRING>"
 "(FirstName, LastName) = @name",
 params={"name": record_value},
 param_types={"name": record_type},
 )
 print("{} record(s) updated.".format(row_ct))
database.run_in_transaction(write_with_struct)

# project_id = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"
require"google/cloud/spanner"
spanner=Google::Cloud::Spanner.newproject:project_id
client=spanner.clientinstance_id,database_id
row_count=0
name_struct={FirstName:"Timothy",LastName:"Campbell"}
client.transactiondo|transaction|
row_count=transaction.execute_update(
"UPDATE Singers SET LastName = 'Grant'
 WHERE STRUCT<FirstName STRING, LastName STRING>(FirstName, LastName) = @name",
params:{name:name_struct}
)
end
puts"#{row_count} record updated."

voidInsertUsingDmlReturning(google::cloud::spanner::Clientclient){
//InsertrecordsintoSINGERStableandreturnthegeneratedcolumn
//FullNameoftheinsertedrecordsusing`THEN RETURN FullName`.
autocommit=client.Commit(
[&client](google::cloud::spanner::Transactiontxn)
->google::cloud::StatusOr<google::cloud::spanner::Mutations>{
autosql=google::cloud::spanner::SqlStatement(R"""(
 INSERT INTO Singers (SingerId, FirstName, LastName)
 VALUES (12, 'Melissa', 'Garcia'),
 (13, 'Russell', 'Morales'),
 (14, 'Jacqueline', 'Long'),
 (15, 'Dylan', 'Shaw')
 THEN RETURN FullName
 )""");
usingRowType=std::tuple<std::string>;
autorows=client.ExecuteQuery(std::move(txn),std::move(sql));
//Note:Thismutatormightbere-run,oritseffectsdiscarded,so
//changingnon-transactionalstate(e.g.,byproducingoutput)is,
//ingeneral,notsomethingtobeimitated.
for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){
if(!row)returnstd::move(row).status();
std::cout << "FullName: " << std::get<0>(*row) << "\n";
}
std::cout << "Inserted row(s) count: " << rows.RowsModified() << "\n";
returngoogle::cloud::spanner::Mutations{};
});
if(!commit)throwstd::move(commit).status();
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
publicclassInsertUsingDmlReturningAsyncSample
{
publicasyncTask<List<string>>InsertUsingDmlReturningAsync(stringprojectId,stringinstanceId,stringdatabaseId)
{
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
usingvarconnection=newSpannerConnection (connectionString);
awaitconnection.OpenAsync ();
// Insert records into the SINGERS table and return the
// generated column FullName of the inserted records using
// 'THEN RETURN FullName'.
// It is also possible to return all columns of all the
// inserted records by using 'THEN RETURN *'.
usingvarcmd=connection.CreateDmlCommand (
@"INSERT INTO Singers(SingerId, FirstName, LastName) VALUES
 (6, 'Melissa', 'Garcia'), 
 (7, 'Russell', 'Morales'), 
 (8, 'Jacqueline', 'Long'), 
 (9, 'Dylan', 'Shaw') THEN RETURN FullName");
varreader=awaitcmd.ExecuteReaderAsync ();
varinsertedSingerNames=newList<string>();
while(awaitreader.ReadAsync ())
{
insertedSingerNames.Add(reader.GetFieldValue<string>("FullName"));
}
Console.WriteLine($"{insertedSingerNames.Count} row(s) inserted...");
returninsertedSingerNames;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
)
funcinsertUsingDMLReturning(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
// Insert records into the SINGERS table and returns the
// generated column FullName of the inserted records using
// 'THEN RETURN FullName'.
// It is also possible to return all columns of all the
// inserted records by using 'THEN RETURN *'.
_,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{
stmt:=spanner.Statement {
SQL:`INSERT INTO Singers (SingerId, FirstName, LastName)
			 VALUES (21, 'Melissa', 'Garcia'),
			 (22, 'Russell', 'Morales'),
			 (23, 'Jacqueline', 'Long'),
			 (24, 'Dylan', 'Shaw')
			 THEN RETURN FullName`,
}
iter:=txn.Query(ctx,stmt)
deferiter.Stop()
for{
row,err:=iter.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
varfullNamestring
iferr:=row.Columns (&fullName);err!=nil{
returnerr
}
fmt.Fprintf(w,"%s\n",fullName)
}
fmt.Fprintf(w,"%d record(s) inserted.\n",iter.RowCount)
returnnil
})
returnerr
}

importcom.google.cloud.spanner.DatabaseClient ;
importcom.google.cloud.spanner.DatabaseId ;
importcom.google.cloud.spanner.ResultSet ;
importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.Statement ;
publicclass InsertUsingDmlReturningSample{
staticvoidinsertUsingDmlReturning(){
// TODO(developer): Replace these variables before running the sample.
finalStringprojectId="my-project";
finalStringinstanceId="my-instance";
finalStringdatabaseId="my-database";
insertUsingDmlReturning(projectId,instanceId,databaseId);
}
staticvoidinsertUsingDmlReturning(StringprojectId,StringinstanceId,StringdatabaseId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService()){
finalDatabaseClient dbClient=
spanner.getDatabaseClient(DatabaseId .of(projectId,instanceId,databaseId));
// Insert records into the SINGERS table and returns the
// generated column FullName of the inserted records using
// ‘THEN RETURN FullName’.
// It is also possible to return all columns of all the
// inserted records by using ‘THEN RETURN *’.
dbClient
.readWritreadWriteTransaction .run(
transaction->{
Stringsql=
"INSERT INTO Singers (SingerId, FirstName, LastName) VALUES "
+"(12, 'Melissa', 'Garcia'), "
+"(13, 'Russell', 'Morales'), "
+"(14, 'Jacqueline', 'Long'), "
+"(15, 'Dylan', 'Shaw') THEN RETURN FullName";
// readWriteTransaction.executeQuery(..) API should be used for executing
// DML statements with RETURNING clause.
try(ResultSeResultSetet=transaction.executeQuery(StatemenStatement )){
while(resultSet.next()){
System.out.println(resultSet.getString(0));
}
System.out.printf(
"Inserted row(s) count: %d\n",resultSet.getStats().getRowCountExact());
}
returnnull;
});
}
}
}

// Imports the Google Cloud client library.
const{Spanner}=require('@google-cloud/spanner');
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
functioninsertUsingDmlReturning(instanceId,databaseId){
// Gets a reference to a Cloud Spanner instance and database.
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
database.runTransaction (async(err,transaction)=>{
if(err){
console.error(err);
return;
}
try{
const[rows,stats]=awaittransaction.run({
sql:'INSERT Singers (SingerId, FirstName, LastName) VALUES (@id, @firstName, @lastName) THEN RETURN FullName',
params:{
id:18,
firstName:'Virginia',
lastName:'Watson',
},
});
constrowCount=Math.floor(stats[stats.rowCount ]);
console.log(
`Successfully inserted ${rowCount} record into the Singers table.`,
);
rows.forEach(row=>{
console.log(row.toJSON().FullName);
});
awaittransaction.commit();
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}
});
}
insertUsingDmlReturning(instanceId,databaseId);

use Google\Cloud\Spanner\SpannerClient;
/**
 * Inserts sample data into the given database using DML returning.
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function insert_dml_returning(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 // Insert records into SINGERS table and returns the generated column
 // FullName of the inserted records using ‘THEN RETURN FullName’. It is also
 // possible to return all columns of all the inserted records by using
 // ‘THEN RETURN *’.
 $sql = 'INSERT INTO Singers (SingerId, FirstName, LastName) '
 . "VALUES (12, 'Melissa', 'Garcia'), "
 . "(13, 'Russell', 'Morales'), "
 . "(14, 'Jacqueline', 'Long'), "
 . "(15, 'Dylan', 'Shaw') "
 . 'THEN RETURN FullName';
 $transaction = $database->transaction();
 $result = $transaction->execute($sql);
 foreach ($result->rows() as $row) {
 printf(
 '%s inserted.' . PHP_EOL,
 $row['FullName'],
 );
 }
 printf(
 'Inserted row(s) count: %d' . PHP_EOL,
 $result->stats()['rowCountExact']
 );
 $transaction->commit();
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
# Insert records into the SINGERS table and returns the
# generated column FullName of the inserted records using
# 'THEN RETURN FullName'.
# It is also possible to return all columns of all the
# inserted records by using 'THEN RETURN *'.
definsert_singers(transaction):
 results = transaction.execute_sql(
 "INSERT INTO Singers (SingerId, FirstName, LastName) VALUES "
 "(21, 'Luann', 'Chizoba'), "
 "(22, 'Denis', 'Patricio'), "
 "(23, 'Felxi', 'Ronan'), "
 "(24, 'Dominik', 'Martyna') "
 "THEN RETURN FullName"
 )
 for result in results:
 print("FullName: {}".format(*result))
 print("{} record(s) inserted.".format(results.stats.row_count_exact))
database.run_in_transaction(insert_singers)

require"google/cloud/spanner"
##
# This is a snippet for showcasing how to use DML return feature with insert
# operation.
#
# @param project_id [String] The ID of the Google Cloud project.
# @param instance_id [String] The ID of the spanner instance.
# @param database_id [String] The ID of the database.
#
defspanner_insert_dml_returningproject_id:,instance_id:,database_id:
spanner=Google::Cloud::Spanner.newproject:project_id
client=spanner.clientinstance_id,database_id
client.transactiondo|transaction|
# Insert records into the SINGERS table and returns the generated column
# FullName of the inserted records using ‘THEN RETURN FullName’.
# It is also possible to return all columns of all the inserted records
# by using ‘THEN RETURN *’.
results=transaction.execute_query"INSERT INTO Singers (SingerId, FirstName, LastName)
 VALUES (12, 'Melissa', 'Garcia'), (13, 'Russell', 'Morales'), (14, 'Jacqueline', 'Long'), (15, 'Dylan', 'Shaw')
 THEN RETURN FullName"
results.rows.eachdo|row|
puts"Inserted singers with FullName: #{row[:FullName]}"
end
puts"Inserted row(s) count: #{results.row_count}"
end
end

voidInsertUsingDmlReturning(google::cloud::spanner::Clientclient){
//InsertrecordsintoSINGERStableandreturnthegeneratedcolumn
//FullNameoftheinsertedrecordsusing`RETURNINGFullName`.
autocommit=client.Commit(
[&client](google::cloud::spanner::Transactiontxn)
->google::cloud::StatusOr<google::cloud::spanner::Mutations>{
autosql=google::cloud::spanner::SqlStatement(R"""(
 INSERT INTO Singers (SingerId, FirstName, LastName)
 VALUES (12, 'Melissa', 'Garcia'),
 (13, 'Russell', 'Morales'),
 (14, 'Jacqueline', 'Long'),
 (15, 'Dylan', 'Shaw')
 RETURNING FullName
 )""");
usingRowType=std::tuple<std::string>;
autorows=client.ExecuteQuery(std::move(txn),std::move(sql));
for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){
if(!row)returnstd::move(row).status();
std::cout << "FullName: " << std::get<0>(*row) << "\n";
}
std::cout << "Inserted row(s) count: " << rows.RowsModified() << "\n";
returngoogle::cloud::spanner::Mutations{};
});
if(!commit)throwstd::move(commit).status();
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
publicclassInsertUsingDmlReturningAsyncPostgresSample
{
publicasyncTask<List<string>>InsertUsingDmlReturningAsyncPostgres(stringprojectId,stringinstanceId,stringdatabaseId)
{
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
usingvarconnection=newSpannerConnection (connectionString);
awaitconnection.OpenAsync ();
// Insert records into SINGERS table and return the
// generated column FullName of the inserted records
// using 'RETURNING FullName'.
// It is also possible to return all columns of all the
// inserted records by using 'RETURNING *'.
usingvarcmd=connection.CreateDmlCommand (
@"INSERT INTO Singers(SingerId, FirstName, LastName) VALUES
 (6, 'Melissa', 'Garcia'), 
 (7, 'Russell', 'Morales'), 
 (8, 'Jacqueline', 'Long'), 
 (9, 'Dylan', 'Shaw') RETURNING FullName");
varreader=awaitcmd.ExecuteReaderAsync ();
varinsertedSingerNames=newList<string>();
while(awaitreader.ReadAsync ())
{
insertedSingerNames.Add(reader.GetFieldValue<string>("fullname"));
}
Console.WriteLine($"{insertedSingerNames.Count} row(s) inserted...");
returninsertedSingerNames;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
)
funcpgInsertUsingDMLReturning(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
// Insert records into the SINGERS table and returns the
// generated column FullName of the inserted records using
// 'RETURNING FullName'.
// It is also possible to return all columns of all the
// inserted records by using 'RETURNING *'.
_,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{
stmt:=spanner.Statement {
SQL:`INSERT INTO Singers (SingerId, FirstName, LastName)
			 VALUES (21, 'Melissa', 'Garcia'),
			 (22, 'Russell', 'Morales'),
			 (23, 'Jacqueline', 'Long'),
			 (24, 'Dylan', 'Shaw')
			 RETURNING FullName`,
}
iter:=txn.Query(ctx,stmt)
deferiter.Stop()
for{
row,err:=iter.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
varfullNamestring
iferr:=row.Columns (&fullName);err!=nil{
returnerr
}
fmt.Fprintf(w,"%s\n",fullName)
}
fmt.Fprintf(w,"%d record(s) inserted.\n",iter.RowCount)
returnnil
})
returnerr
}

importcom.google.cloud.spanner.DatabaseClient ;
importcom.google.cloud.spanner.DatabaseId ;
importcom.google.cloud.spanner.ResultSet ;
importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.Statement ;
publicclass PgInsertUsingDmlReturningSample{
staticvoidinsertUsingDmlReturning(){
// TODO(developer): Replace these variables before running the sample.
finalStringprojectId="my-project";
finalStringinstanceId="my-instance";
finalStringdatabaseId="my-database";
insertUsingDmlReturning(projectId,instanceId,databaseId);
}
staticvoidinsertUsingDmlReturning(StringprojectId,StringinstanceId,StringdatabaseId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService()){
finalDatabaseClient dbClient=
spanner.getDatabaseClient(DatabaseId .of(projectId,instanceId,databaseId));
// Insert records into SINGERS table and returns the
// generated column FullName of the inserted records
// using ‘RETURNING FullName’.
// It is also possible to return all columns of all the
// inserted records by using ‘RETURNING *’.
dbClient
.readWritreadWriteTransaction .run(
transaction->{
Stringsql=
"INSERT INTO Singers (SingerId, FirstName, LastName) VALUES "
+"(12, 'Melissa', 'Garcia'), "
+"(13, 'Russell', 'Morales'), "
+"(14, 'Jacqueline', 'Long'), "
+"(15, 'Dylan', 'Shaw') RETURNING FullName";
// readWriteTransaction.executeQuery(..) API should be used for executing
// DML statements with RETURNING clause.
try(ResultSeResultSetet=transaction.executeQuery(StatemenStatement )){
while(resultSet.next()){
System.out.println(resultSet.getString(0));
}
System.out.printf(
"Inserted row(s) count: %d\n",resultSet.getStats().getRowCountExact());
}
returnnull;
});
}
}
}

// Imports the Google Cloud client library.
const{Spanner}=require('@google-cloud/spanner');
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
functionpgInsertUsingDmlReturning(instanceId,databaseId){
// Gets a reference to a Cloud Spanner instance and database.
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
database.runTransaction (async(err,transaction)=>{
if(err){
console.error(err);
return;
}
try{
const[rows,stats]=awaittransaction.run({
sql:'INSERT Into Singers (SingerId, FirstName, LastName) VALUES (1,ドル 2,ドル 3ドル) RETURNING FullName',
params:{
p1:18,
p2:'Virginia',
p3:'Watson',
},
});
constrowCount=Math.floor(stats[stats.rowCount ]);
console.log(
`Successfully inserted ${rowCount} record into the Singers table.`,
);
rows.forEach(row=>{
console.log(row.toJSON().fullname);
});
awaittransaction.commit();
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}
});
}
pgInsertUsingDmlReturning(instanceId,databaseId);

use Google\Cloud\Spanner\SpannerClient;
/**
 * Inserts sample data into the given postgresql database using DML returning.
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function pg_insert_dml_returning(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 // Insert records into SINGERS table and returns the generated column
 // FullName of the inserted records using ‘RETURNING FullName’. It is also
 // possible to return all columns of all the inserted records by using
 // ‘RETURNING *’.
 $sql = 'INSERT INTO Singers (Singerid, FirstName, LastName) '
 . "VALUES (12, 'Melissa', 'Garcia'), "
 . "(13, 'Russell', 'Morales'), "
 . "(14, 'Jacqueline', 'Long'), "
 . "(15, 'Dylan', 'Shaw') "
 . 'RETURNING FullName';
 $transaction = $database->transaction();
 $result = $transaction->execute($sql);
 foreach ($result->rows() as $row) {
 printf(
 '%s inserted.' . PHP_EOL,
 $row['fullname'],
 );
 }
 printf(
 'Inserted row(s) count: %d' . PHP_EOL,
 $result->stats()['rowCountExact']
 );
 $transaction->commit();
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
# Insert records into the SINGERS table and returns the
# generated column FullName of the inserted records using
# 'RETURNING FullName'.
# It is also possible to return all columns of all the
# inserted records by using 'RETURNING *'.
definsert_singers(transaction):
 results = transaction.execute_sql(
 "INSERT INTO Singers (SingerId, FirstName, LastName) VALUES "
 "(21, 'Luann', 'Chizoba'), "
 "(22, 'Denis', 'Patricio'), "
 "(23, 'Felxi', 'Ronan'), "
 "(24, 'Dominik', 'Martyna') "
 "RETURNING FullName"
 )
 for result in results:
 print("FullName: {}".format(*result))
 print("{} record(s) inserted.".format(results.stats.row_count_exact))
database.run_in_transaction(insert_singers)

require"google/cloud/spanner"
##
# This is a snippet for showcasing how to use DML return feature with insert
# operation in PostgreSql.
#
# @param project_id [String] The ID of the Google Cloud project.
# @param instance_id [String] The ID of the spanner instance.
# @param database_id [String] The ID of the database.
#
defspanner_postgresql_insert_dml_returningproject_id:,instance_id:,database_id:
spanner=Google::Cloud::Spanner.newproject:project_id
client=spanner.clientinstance_id,database_id
client.transactiondo|transaction|
# Insert records into SINGERS table and returns the generated column
# FullName of the inserted records using ‘RETURNING FullName’.
# It is also possible to return all columns of all the inserted
# records by using ‘RETURNING *’.
results=transaction.execute_query"INSERT INTO Singers (SingerId, FirstName, LastName)
 VALUES (12, 'Melissa', 'Garcia'), (13, 'Russell', 'Morales'), (14, 'Jacqueline', 'Long'), (15, 'Dylan', 'Shaw')
 RETURNING FullName"
results.rows.eachdo|row|
puts"Inserted singers with FullName: #{row[:fullname]}"
end
puts"Inserted row(s) count: #{results.row_count}"
end
end

voidUpdateUsingDmlReturning(google::cloud::spanner::Clientclient){
//UpdateMarketingBudgetcolumnforrecordssatisfyingaparticular
//conditionandreturnthemodifiedMarketingBudgetcolumnofthe
//updatedrecordsusing`THEN RETURN MarketingBudget`.
autocommit=client.Commit(
[&client](google::cloud::spanner::Transactiontxn)
->google::cloud::StatusOr<google::cloud::spanner::Mutations>{
autosql=google::cloud::spanner::SqlStatement(R"""(
 UPDATE Albums SET MarketingBudget = MarketingBudget * 2
 WHERE SingerId = 1 AND AlbumId = 1
 THEN RETURN MarketingBudget
 )""");
usingRowType=std::tuple<absl::optional<std::int64_t>>;
autorows=client.ExecuteQuery(std::move(txn),std::move(sql));
//Note:Thismutatormightbere-run,oritseffectsdiscarded,so
//changingnon-transactionalstate(e.g.,byproducingoutput)is,
//ingeneral,notsomethingtobeimitated.
for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){
if(!row)returnstd::move(row).status();
std::cout << "MarketingBudget: ";
if(std::get<0>(*row).has_value()){
std::cout << *std::get<0>(*row);
}else{
std::cout << "NULL";
}
std::cout << "\n";
}
std::cout << "Updated row(s) count: " << rows.RowsModified() << "\n";
returngoogle::cloud::spanner::Mutations{};
});
if(!commit)throwstd::move(commit).status();
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
publicclassUpdateUsingDmlReturningAsyncSample
{
publicasyncTask<List<long>>UpdateUsingDmlReturningAsync(stringprojectId,stringinstanceId,stringdatabaseId)
{
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
usingvarconnection=newSpannerConnection (connectionString);
awaitconnection.OpenAsync ();
// Update MarketingBudget column for records satisfying
// a particular condition and return the modified
// MarketingBudget column of the updated records using
// 'THEN RETURN MarketingBudget'.
// It is also possible to return all columns of all the
// updated records by using 'THEN RETURN *'.
usingvarcmd=connection.CreateDmlCommand ("UPDATE Albums SET MarketingBudget = MarketingBudget * 2 WHERE SingerId = 1 and AlbumId = 1 THEN RETURN MarketingBudget");
varreader=awaitcmd.ExecuteReaderAsync ();
varupdatedMarketingBudgets=newList<long>();
while(awaitreader.ReadAsync ())
{
updatedMarketingBudgets.Add(reader.GetFieldValue<long>("MarketingBudget"));
}
Console.WriteLine($"{updatedMarketingBudgets.Count} row(s) updated...");
returnupdatedMarketingBudgets;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
)
funcupdateUsingDMLReturning(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
// Update MarketingBudget column for records satisfying
// a particular condition and returns the modified
// MarketingBudget column of the updated records using
// 'THEN RETURN MarketingBudget'.
// It is also possible to return all columns of all the
// updated records by using 'THEN RETURN *'.
_,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{
stmt:=spanner.Statement {
SQL:`UPDATE Albums
				SET MarketingBudget = MarketingBudget * 2
				WHERE SingerId = 1 and AlbumId = 1
				THEN RETURN MarketingBudget`,
}
iter:=txn.Query(ctx,stmt)
deferiter.Stop()
for{
row,err:=iter.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
varmarketingBudgetint64
iferr:=row.Columns (&marketingBudget);err!=nil{
returnerr
}
fmt.Fprintf(w,"%d\n",marketingBudget)
}
fmt.Fprintf(w,"%d record(s) updated.\n",iter.RowCount)
returnnil
})
returnerr
}

importcom.google.cloud.spanner.DatabaseClient ;
importcom.google.cloud.spanner.DatabaseId ;
importcom.google.cloud.spanner.ResultSet ;
importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.Statement ;
publicclass UpdateUsingDmlReturningSample{
staticvoidupdateUsingDmlReturning(){
// TODO(developer): Replace these variables before running the sample.
finalStringprojectId="my-project";
finalStringinstanceId="my-instance";
finalStringdatabaseId="my-database";
updateUsingDmlReturning(projectId,instanceId,databaseId);
}
staticvoidupdateUsingDmlReturning(StringprojectId,StringinstanceId,StringdatabaseId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService()){
finalDatabaseClient dbClient=
spanner.getDatabaseClient(DatabaseId .of(projectId,instanceId,databaseId));
// Update MarketingBudget column for records satisfying
// a particular condition and returns the modified
// MarketingBudget column of the updated records using
// ‘THEN RETURN MarketingBudget’.
// It is also possible to return all columns of all the
// updated records by using ‘THEN RETURN *’.
dbClient
.readWritreadWriteTransaction .run(
transaction->{
Stringsql=
"UPDATE Albums "
+"SET MarketingBudget = MarketingBudget * 2 "
+"WHERE SingerId = 1 and AlbumId = 1 "
+"THEN RETURN MarketingBudget";
// readWriteTransaction.executeQuery(..) API should be used for executing
// DML statements with RETURNING clause.
try(ResultSeResultSetet=transaction.executeQuery(StatemenStatement )){
while(resultSet.next()){
System.out.printf("%d\n",resultSet.getLong(0));
}
System.out.printf(
"Updated row(s) count: %d\n",resultSet.getStats().getRowCountExact());
}
returnnull;
});
}
}
}

// Imports the Google Cloud client library.
const{Spanner}=require('@google-cloud/spanner');
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
functionupdateUsingDmlReturning(instanceId,databaseId){
// Gets a reference to a Cloud Spanner instance and database.
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
database.runTransaction (async(err,transaction)=>{
if(err){
console.error(err);
return;
}
try{
const[rows,stats]=awaittransaction.run({
sql:'UPDATE Albums SET MarketingBudget = 2000000 WHERE SingerId = 1 and AlbumId = 1 THEN RETURN MarketingBudget',
});
constrowCount=Math.floor(stats[stats.rowCount ]);
console.log(
`Successfully updated ${rowCount} record into the Albums table.`,
);
rows.forEach(row=>{
console.log(row.toJSON().MarketingBudget);
});
awaittransaction.commit();
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}
});
}
updateUsingDmlReturning(instanceId,databaseId);

use Google\Cloud\Spanner\SpannerClient;
/**
 * Update the given database using DML returning.
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function update_dml_returning(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 $transaction = $database->transaction();
 // Update MarketingBudget column for records satisfying a particular
 // condition and returns the modified MarketingBudget column of the updated
 // records using ‘THEN RETURN MarketingBudget’. It is also possible to return
 // all columns of all the updated records by using ‘THEN RETURN *’.
 $result = $transaction->execute(
 'UPDATE Albums '
 . 'SET MarketingBudget = MarketingBudget * 2 '
 . 'WHERE SingerId = 1 and AlbumId = 1 '
 . 'THEN RETURN MarketingBudget'
 );
 foreach ($result->rows() as $row) {
 printf('MarketingBudget: %s' . PHP_EOL, $row['MarketingBudget']);
 }
 printf(
 'Updated row(s) count: %d' . PHP_EOL,
 $result->stats()['rowCountExact']
 );
 $transaction->commit();
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
# Update MarketingBudget column for records satisfying
# a particular condition and returns the modified
# MarketingBudget column of the updated records using
# 'THEN RETURN MarketingBudget'.
# It is also possible to return all columns of all the
# updated records by using 'THEN RETURN *'.
defupdate_albums(transaction):
 results = transaction.execute_sql(
 "UPDATE Albums "
 "SET MarketingBudget = MarketingBudget * 2 "
 "WHERE SingerId = 1 and AlbumId = 1 "
 "THEN RETURN MarketingBudget"
 )
 for result in results:
 print("MarketingBudget: {}".format(*result))
 print("{} record(s) updated.".format(results.stats.row_count_exact))
database.run_in_transaction(update_albums)

require"google/cloud/spanner"
##
# This is a snippet for showcasing how to use DML return feature with update
# operation.
#
# @param project_id [String] The ID of the Google Cloud project.
# @param instance_id [String] The ID of the spanner instance.
# @param database_id [String] The ID of the database.
#
defspanner_update_dml_returningproject_id:,instance_id:,database_id:
spanner=Google::Cloud::Spanner.newproject:project_id
client=spanner.clientinstance_id,database_id
client.transactiondo|transaction|
# Update MarketingBudget column for records satisfying a particular
# condition and returns the modified MarketingBudget column of the
# updated records using ‘THEN RETURN MarketingBudget’.
#
# It is also possible to return all columns of all the updated records
# by using ‘THEN RETURN *’.
results=transaction.execute_query"UPDATE Albums SET MarketingBudget = MarketingBudget * 2
 WHERE SingerId = 1 and AlbumId = 1
 THEN RETURN MarketingBudget"
results.rows.eachdo|row|
puts"Updated Album with MarketingBudget: #{row[:MarketingBudget]}"
end
puts"Updated row(s) count: #{results.row_count}"
end
end

voidUpdateUsingDmlReturning(google::cloud::spanner::Clientclient){
//UpdateMarketingBudgetcolumnforrecordssatisfyingaparticular
//conditionandreturnthemodifiedMarketingBudgetcolumnofthe
//updatedrecordsusing`RETURNINGMarketingBudget`.
autocommit=client.Commit(
[&client](google::cloud::spanner::Transactiontxn)
->google::cloud::StatusOr<google::cloud::spanner::Mutations>{
autosql=google::cloud::spanner::SqlStatement(R"""(
 UPDATE Albums SET MarketingBudget = MarketingBudget * 2
 WHERE SingerId = 1 AND AlbumId = 1
 RETURNING MarketingBudget
 )""");
usingRowType=std::tuple<absl::optional<std::int64_t>>;
autorows=client.ExecuteQuery(std::move(txn),std::move(sql));
for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){
if(!row)returnstd::move(row).status();
std::cout << "MarketingBudget: ";
if(std::get<0>(*row).has_value()){
std::cout << *std::get<0>(*row);
}else{
std::cout << "NULL";
}
std::cout << "\n";
}
std::cout << "Updated row(s) count: " << rows.RowsModified() << "\n";
returngoogle::cloud::spanner::Mutations{};
});
if(!commit)throwstd::move(commit).status();
}

usingGoogle.Cloud.Spanner.Data ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
publicclassUpdateUsingDmlReturningAsyncPostgresSample
{
publicasyncTask<List<long>>UpdateUsingDmlReturningAsyncPostgres(stringprojectId,stringinstanceId,stringdatabaseId)
{
stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
usingvarconnection=newSpannerConnection (connectionString);
awaitconnection.OpenAsync ();
// Update MarketingBudget column for records satisfying
// a particular condition and return the modified
// MarketingBudget column of the updated records using
// 'RETURNING MarketingBudget'.
// It is also possible to return all columns of all the
// updated records by using 'RETURNING *'.
usingvarcmd=connection.CreateDmlCommand ("UPDATE Albums SET MarketingBudget = MarketingBudget * 2 WHERE SingerId = 14 and AlbumId = 20 RETURNING MarketingBudget");
varreader=awaitcmd.ExecuteReaderAsync ();
varupdatedMarketingBudgets=newList<long>();
while(awaitreader.ReadAsync ())
{
updatedMarketingBudgets.Add(reader.GetFieldValue<long>("marketingbudget"));
}
Console.WriteLine($"{updatedMarketingBudgets.Count} row(s) updated...");
returnupdatedMarketingBudgets;
}
}

import(
"context"
"fmt"
"io"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
)
funcpgUpdateUsingDMLReturning(wio.Writer,dbstring)error{
ctx:=context.Background()
client,err:=spanner.NewClient(ctx,db)
iferr!=nil{
returnerr
}
deferclient.Close()
// Update MarketingBudget column for records satisfying
// a particular condition and returns the modified
// MarketingBudget column of the updated records using
// 'RETURNING MarketingBudget'.
// It is also possible to return all columns of all the
// updated records by using 'RETURNING *'.
_,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{
stmt:=spanner.Statement {
SQL:`UPDATE Albums
				SET MarketingBudget = MarketingBudget * 2
				WHERE SingerId = 1 and AlbumId = 1
				RETURNING MarketingBudget`,
}
iter:=txn.Query(ctx,stmt)
deferiter.Stop()
for{
row,err:=iter.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
varmarketingBudgetint64
iferr:=row.Columns (&marketingBudget);err!=nil{
returnerr
}
fmt.Fprintf(w,"%d\n",marketingBudget)
}
fmt.Fprintf(w,"%d record(s) updated.\n",iter.RowCount)
returnnil
})
returnerr
}

importcom.google.cloud.spanner.DatabaseClient ;
importcom.google.cloud.spanner.DatabaseId ;
importcom.google.cloud.spanner.ResultSet ;
importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.Statement ;
publicclass PgUpdateUsingDmlReturningSample{
staticvoidupdateUsingDmlReturning(){
// TODO(developer): Replace these variables before running the sample.
finalStringprojectId="my-project";
finalStringinstanceId="my-instance";
finalStringdatabaseId="my-database";
updateUsingDmlReturning(projectId,instanceId,databaseId);
}
staticvoidupdateUsingDmlReturning(StringprojectId,StringinstanceId,StringdatabaseId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService()){
finalDatabaseClient dbClient=
spanner.getDatabaseClient(DatabaseId .of(projectId,instanceId,databaseId));
// Update MarketingBudget column for records satisfying
// a particular condition and returns the modified
// MarketingBudget column of the updated records using
// ‘RETURNING MarketingBudget’.
// It is also possible to return all columns of all the
// updated records by using ‘RETURNING *’.
dbClient
.readWritreadWriteTransaction .run(
transaction->{
Stringsql=
"UPDATE Albums "
+"SET MarketingBudget = MarketingBudget * 2 "
+"WHERE SingerId = 1 and AlbumId = 1 "
+"RETURNING MarketingBudget";
// readWriteTransaction.executeQuery(..) API should be used for executing
// DML statements with RETURNING clause.
try(ResultSeResultSetet=transaction.executeQuery(StatemenStatement )){
while(resultSet.next()){
System.out.printf("%d\n",resultSet.getLong(0));
}
System.out.printf(
"Updated row(s) count: %d\n",resultSet.getStats().getRowCountExact());
}
returnnull;
});
}
}
}

// Imports the Google Cloud client library.
const{Spanner}=require('@google-cloud/spanner');
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
functionpgUpdateUsingDmlReturning(instanceId,databaseId){
// Gets a reference to a Cloud Spanner instance and database.
constinstance=spanner.instance(instanceId);
constdatabase=instance.database(databaseId);
database.runTransaction (async(err,transaction)=>{
if(err){
console.error(err);
return;
}
try{
const[rows,stats]=awaittransaction.run({
sql:'UPDATE singers SET FirstName = 1,ドル LastName = 2ドル WHERE singerid = 3ドル RETURNING FullName',
params:{
p1:'Virginia1',
p2:'Watson1',
p3:18,
},
});
constrowCount=Math.floor(stats[stats.rowCount ]);
console.log(
`Successfully updated ${rowCount} record into the Singers table.`,
);
rows.forEach(row=>{
console.log(row.toJSON().fullname);
});
awaittransaction.commit();
}catch(err){
console.error('ERROR:',err);
}finally{
// Close the database when finished.
database.close();
}
});
}
pgUpdateUsingDmlReturning(instanceId,databaseId);

use Google\Cloud\Spanner\SpannerClient;
/**
 * Update the given postgresql database using DML returning.
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function pg_update_dml_returning(string $instanceId, string $databaseId): void
{
 $spanner = new SpannerClient();
 $instance = $spanner->instance($instanceId);
 $database = $instance->database($databaseId);
 $transaction = $database->transaction();
 // Update MarketingBudget column for records satisfying a particular
 // condition and returns the modified MarketingBudget column of the updated
 // records using ‘RETURNING MarketingBudget’. It is also possible to return
 // all columns of all the updated records by using ‘RETURNING *’.
 $result = $transaction->execute(
 'UPDATE Albums '
 . 'SET MarketingBudget = MarketingBudget * 2 '
 . 'WHERE SingerId = 1 and AlbumId = 1 '
 . 'RETURNING MarketingBudget'
 );
 foreach ($result->rows() as $row) {
 printf('MarketingBudget: %s' . PHP_EOL, $row['marketingbudget']);
 }
 printf(
 'Updated row(s) count: %d' . PHP_EOL,
 $result->stats()['rowCountExact']
 );
 $transaction->commit();
}

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
# Update MarketingBudget column for records satisfying
# a particular condition and returns the modified
# MarketingBudget column of the updated records using
# 'RETURNING MarketingBudget'.
# It is also possible to return all columns of all the
# updated records by using 'RETURNING *'.
defupdate_albums(transaction):
 results = transaction.execute_sql(
 "UPDATE Albums "
 "SET MarketingBudget = MarketingBudget * 2 "
 "WHERE SingerId = 1 and AlbumId = 1 "
 "RETURNING MarketingBudget"
 )
 for result in results:
 print("MarketingBudget: {}".format(*result))
 print("{} record(s) updated.".format(results.stats.row_count_exact))
database.run_in_transaction(update_albums)