Delete data in a graph

  void 
  
 DeleteData 
 ( 
 google 
 :: 
 cloud 
 :: 
 spanner 
 :: 
 Client 
  
 client 
 ) 
  
 { 
  
 namespace 
  
 spanner 
  
 = 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 spanner 
 ; 
  
 // Delete the 'Owns' relationships with key (1,7) and (2,20). 
  
 auto 
  
 delete_ownerships 
  
 = 
  
 spanner 
 :: 
 DeleteMutationBuilder 
 ( 
 "PersonOwnAccount" 
 , 
  
 spanner 
 :: 
 KeySet 
 () 
  
 . 
 AddKey 
 ( 
 spanner 
 :: 
 MakeKey 
 ( 
 1 
 , 
  
 7 
 )) 
  
 . 
 AddKey 
 ( 
 spanner 
 :: 
 MakeKey 
 ( 
 2 
 , 
  
 20 
 ))) 
  
 . 
 Build 
 (); 
  
 // Delete transfers using the keys in the range [1, 8] 
  
 auto 
  
 delete_transfer_range 
  
 = 
  
 spanner 
 :: 
 DeleteMutationBuilder 
 ( 
  
 "AccountTransferAccount" 
 , 
  
 spanner 
 :: 
 KeySet 
 (). 
 AddRange 
 ( 
 spanner 
 :: 
 MakeKeyBoundClosed 
 ( 
 1 
 ), 
  
 spanner 
 :: 
 MakeKeyBoundOpen 
 ( 
 8 
 ))) 
  
 . 
 Build 
 (); 
  
 // Deletes rows from the Account table and the AccountTransferAccount 
  
 // table, because the AccountTransferAccount table is defined with 
  
 // ON DELETE CASCADE. 
  
 auto 
  
 delete_accounts_all 
  
 = 
  
 spanner 
 :: 
 MakeDeleteMutation 
 ( 
 "Account" 
 , 
  
 spanner 
 :: 
 KeySet 
 :: 
 All 
 ()); 
  
 // Deletes rows from the Person table and the PersonOwnAccount table, 
  
 // because the PersonOwnAccount table is defined with ON DELETE CASCADE. 
  
 auto 
  
 delete_persons_all 
  
 = 
  
 spanner 
 :: 
 MakeDeleteMutation 
 ( 
 "Person" 
 , 
  
 spanner 
 :: 
 KeySet 
 :: 
 All 
 ()); 
  
 auto 
  
 commit_result 
  
 = 
  
 client 
 . 
 Commit 
 ( 
  
 spanner 
 :: 
 Mutations 
 { 
 delete_ownerships 
 , 
  
 delete_transfer_range 
 , 
  
 delete_accounts_all 
 , 
  
 delete_persons_all 
 }); 
  
 if 
  
 ( 
 ! 
 commit_result 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 commit_result 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "Delete was successful [spanner_delete_graph_data] 
 \n 
 " 
 ; 
 } 
 

  import 
  
 ( 
  
 "context" 
  
 "io" 
  
 "cloud.google.com/go/spanner" 
 ) 
 func 
  
 deleteGraphData 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 db 
  
 string 
 ) 
  
 error 
  
 { 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 spanner 
 . 
 NewClient 
 ( 
 ctx 
 , 
  
 db 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 client 
 . 
 Close 
 () 
  
 // Apply a series of mutations to tables underpinning edges and nodes in the 
  
 // example graph. If there are referential integrity constraints defined 
  
 // between edges and the nodes they connect, the edge must be deleted 
  
 // before the nodes that the edge connects are deleted. 
  
 m 
  
 := 
  
 [] 
 * 
 spanner 
 . 
 Mutation 
 { 
  
 // spanner.Key can be used to delete a specific set of rows. 
  
 // Delete the PersonOwnAccount rows with the key values (1,7) and (2,20). 
  
 spanner 
 . 
 Delete 
 ( 
 "PersonOwnAccount" 
 , 
  
 spanner 
 . 
  Key 
 
 { 
 1 
 , 
  
 7 
 }), 
  
 spanner 
 . 
 Delete 
 ( 
 "PersonOwnAccount" 
 , 
  
 spanner 
 . 
  Key 
 
 { 
 2 
 , 
  
 20 
 }), 
  
 // spanner.KeyRange can be used to delete rows with a key in a specific range. 
  
 // Delete a range of rows where the key prefix is >=1 and <8 
  
 spanner 
 . 
 Delete 
 ( 
 "AccountTransferAccount" 
 , 
  
 spanner 
 . 
 KeyRange 
 { 
 Start 
 : 
  
 spanner 
 . 
  Key 
 
 { 
 1 
 }, 
  
 End 
 : 
  
 spanner 
 . 
  Key 
 
 { 
 8 
 }, 
  
 Kind 
 : 
  
 spanner 
 . 
  ClosedOpen 
 
 }), 
  
 // spanner.AllKeys can be used to delete all the rows in a table. 
  
 // Delete all Account rows, which will also delete the remaining 
  
 // AccountTransferAccount rows since it was defined with ON DELETE CASCADE. 
  
 spanner 
 . 
 Delete 
 ( 
 "Account" 
 , 
  
 spanner 
 . 
  AllKeys 
 
 ()), 
  
 // Delete remaining Person rows, which will also delete the remaining 
  
 // PersonOwnAccount rows since it was defined with ON DELETE CASCADE. 
  
 spanner 
 . 
 Delete 
 ( 
 "Person" 
 , 
  
 spanner 
 . 
  AllKeys 
 
 ()), 
  
 } 
  
 _ 
 , 
  
 err 
  
 = 
  
 client 
 . 
  Apply 
 
 ( 
 ctx 
 , 
  
 m 
 ) 
  
 return 
  
 err 
 } 
 

  static 
  
 void 
  
 deleteData 
 ( 
 DatabaseClient 
  
 dbClient 
 ) 
  
 { 
  
 List<Mutation> 
  
 mutations 
  
 = 
  
 new 
  
 ArrayList 
<> (); 
  
 // KeySet.Builder can be used to delete a specific set of rows. 
  
 // Delete the PersonOwnAccount rows with the key values (1,7) and (2,20). 
  
 mutations 
 . 
 add 
 ( 
  
 Mutation 
 . 
 delete 
 ( 
  
 "PersonOwnAccount" 
 , 
  
 KeySet 
 . 
 newBuilder 
 (). 
 addKey 
 ( 
 Key 
 . 
 of 
 ( 
 1 
 , 
  
 7 
 )). 
 addKey 
 ( 
 Key 
 . 
 of 
 ( 
 2 
 , 
  
 20 
 )). 
 build 
 ())); 
  
 // KeyRange can be used to delete rows with a key in a specific range. 
  
 // Delete a range of rows where the key prefix is >=1 and <8 
  
 mutations 
 . 
 add 
 ( 
  
 Mutation 
 . 
 delete 
 ( 
  
 "AccountTransferAccount" 
 , 
  
 KeySet 
 . 
 range 
 ( 
 KeyRange 
 . 
 closedOpen 
 ( 
 Key 
 . 
 of 
 ( 
 1 
 ), 
  
 Key 
 . 
 of 
 ( 
 8 
 ))))); 
  
 // KeySet.all() can be used to delete all the rows in a table. 
  
 // Delete all Account rows, which will also delete the remaining 
  
 // AccountTransferAccount rows since it was defined with ON DELETE CASCADE. 
  
 mutations 
 . 
 add 
 ( 
 Mutation 
 . 
 delete 
 ( 
 "Account" 
 , 
  
 KeySet 
 . 
 all 
 ())); 
  
 // KeySet.all() can be used to delete all the rows in a table. 
  
 // Delete all Person rows, which will also delete the remaining 
  
 // PersonOwnAccount rows since it was defined with ON DELETE CASCADE. 
  
 mutations 
 . 
 add 
 ( 
 Mutation 
 . 
 delete 
 ( 
 "Person" 
 , 
  
 KeySet 
 . 
 all 
 ())); 
  
 dbClient 
 . 
 write 
 ( 
 mutations 
 ); 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Records deleted.\n" 
 ); 
 } 
 

  def 
  
 delete_data 
 ( 
 instance_id 
 , 
 database_id 
 ): 
  
 """Deletes sample data from the given database. 
 The database, table, and data must already exist and can be created using 
 `create_database` and `insert_data`. 
 """ 
 spanner_client 
 = 
 spanner 
 . 
 Client 
 () 
 instance 
 = 
 spanner_client 
 . 
 instance 
 ( 
 instance_id 
 ) 
 database 
 = 
 instance 
 . 
 database 
 ( 
 database_id 
 ) 
 # Delete individual rows 
 ownerships_to_delete 
 = 
 spanner 
 . 
 KeySet 
 ( 
 keys 
 = 
 [[ 
 1 
 , 
 7 
 ], 
 [ 
 2 
 , 
 20 
 ]]) 
 # Delete a range of rows where the column key is >=1 and <8 
 transfers_range 
 = 
 spanner 
 . 
 KeyRange 
 ( 
 start_closed 
 = 
 [ 
 1 
 ], 
 end_open 
 = 
 [ 
 8 
 ]) 
 transfers_to_delete 
 = 
 spanner 
 . 
 KeySet 
 ( 
 ranges 
 = 
 [ 
 transfers_range 
 ]) 
 # Delete Account/Person rows, which will also delete the remaining 
 # AccountTransferAccount and PersonOwnAccount rows because 
 # AccountTransferAccount and PersonOwnAccount are defined with 
 # ON DELETE CASCADE 
 remaining_nodes 
 = 
 spanner 
 . 
 KeySet 
 ( 
 all_ 
 = 
 True 
 ) 
 with 
 database 
 . 
 batch 
 () 
 as 
 batch 
 : 
 batch 
 . 
 delete 
 ( 
 "PersonOwnAccount" 
 , 
 ownerships_to_delete 
 ) 
 batch 
 . 
 delete 
 ( 
 "AccountTransferAccount" 
 , 
 transfers_to_delete 
 ) 
 batch 
 . 
 delete 
 ( 
 "Account" 
 , 
 remaining_nodes 
 ) 
 batch 
 . 
 delete 
 ( 
 "Person" 
 , 
 remaining_nodes 
 ) 
 print 
 ( 
 "Deleted data." 
 )