Import admin entities to Datastore

  using 
  
  Google.Cloud.Datastore.Admin.V1 
 
 ; 
 using 
  
  Google.LongRunning 
 
 ; 
 using 
  
  Google.Protobuf.WellKnownTypes 
 
 ; 
 using 
  
 System 
 ; 
 using 
  
 System.Collections.Generic 
 ; 
 public 
  
 class 
  
 ImportEntitiesSample 
 { 
  
 public 
  
 bool 
  
 ImportEntities 
 ( 
  
 string 
  
 projectId 
  
 = 
  
 "your-project-id" 
 , 
  
 // For information on accepted input URL formats, see 
  
 // https://cloud.google.com/datastore/docs/reference/admin/rpc/google.datastore.admin.v1#google.datastore.admin.v1.ImportEntitiesRequest 
  
 string 
  
 inputUrl 
  
 = 
  
 "[URL to file containing data]" 
 , 
  
 string 
  
 kind 
  
 = 
  
 "Task" 
 , 
  
 string 
  
 namespaceId 
  
 = 
  
 "default" 
 ) 
  
 { 
  
 // Create client 
  
  DatastoreAdminClient 
 
  
 datastoreAdminClient 
  
 = 
  
  DatastoreAdminClient 
 
 . 
  Create 
 
 (); 
  
 IDictionary<string 
 , 
  
 string 
>  
 labels 
  
 = 
  
 new 
  
 Dictionary<string 
 , 
  
 string 
>  
 { 
  
 { 
  
 "cloud_datastore_samples" 
 , 
  
 "true" 
  
 }, 
  
 }; 
  
  EntityFilter 
 
  
 entityFilter 
  
 = 
  
 new 
  
  EntityFilter 
 
 () 
  
 { 
  
 Kinds 
  
 = 
  
 { 
  
 kind 
  
 }, 
  
 NamespaceIds 
  
 = 
  
 { 
  
 namespaceId 
  
 } 
  
 }; 
  
 Operation<Empty 
 , 
  
 ImportEntitiesMetadata 
>  
 response 
  
 = 
  
 datastoreAdminClient 
 . 
  ImportEntities 
 
 ( 
 projectId 
 , 
  
 labels 
 , 
  
 inputUrl 
 , 
  
 entityFilter 
 ); 
  
 // Poll until the returned long-running operation is complete 
  
 Operation<Empty 
 , 
  
 ImportEntitiesMetadata 
>  
 completedResponse 
  
 = 
  
 response 
 . 
 PollUntilCompleted 
 (); 
  
 if 
  
 ( 
 completedResponse 
 . 
 IsFaulted 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Error while Importing Entities: {completedResponse.Exception}" 
 ); 
  
 throw 
  
 completedResponse 
 . 
 Exception 
 ; 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Entities imported successfully." 
 ); 
  
 return 
  
 completedResponse 
 . 
 IsCompleted 
 ; 
  
 } 
 } 
 

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 admin 
  
 "cloud.google.com/go/datastore/admin/apiv1" 
  
 "cloud.google.com/go/datastore/admin/apiv1/adminpb" 
 ) 
 // entitiesImport imports entities into Datastore. 
 func 
  
 entitiesImport 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
 , 
  
 inputURL 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectID := "project-id" 
  
 // inputURL := "gs://bucket-name/overall-export-metadata-file" 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 admin 
 . 
 NewDatastoreAdminClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "admin.NewDatastoreAdminClient: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
  Close 
 
 () 
  
 req 
  
 := 
  
& adminpb 
 . 
 ImportEntitiesRequest 
 { 
  
 ProjectId 
 : 
  
 projectID 
 , 
  
 InputUrl 
 : 
  
 inputURL 
 , 
  
 } 
  
 op 
 , 
  
 err 
  
 := 
  
 client 
 . 
 ImportEntities 
 ( 
 ctx 
 , 
  
 req 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "ImportEntities: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 if 
  
 err 
  
 = 
  
 op 
 . 
 Wait 
 ( 
 ctx 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "Wait: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Entities were imported\n" 
 ) 
  
 return 
  
 nil 
 } 
 

  const 
  
 { 
 Datastore 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/datastore 
' 
 ); 
 const 
  
 datastore 
  
 = 
  
 new 
  
  Datastore 
 
 (); 
 async 
  
 function 
  
 importEntities 
 () 
  
 { 
  
 /** 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 // const file = 'YOUR_FILE_NAME'; 
  
 const 
  
 [ 
 importOperation 
 ] 
  
 = 
  
 await 
  
 datastore 
 . 
  import 
 
 ({ 
 file 
 }); 
  
 // Uncomment to await the results of the operation. 
  
 // await importOperation.promise(); 
  
 // Or cancel the operation. 
  
 await 
  
 importOperation 
 . 
 cancel 
 (); 
  
 // You may also choose to include only specific kinds and namespaces. 
  
 const 
  
 [ 
 specificImportOperation 
 ] 
  
 = 
  
 await 
  
 datastore 
 . 
  import 
 
 ({ 
  
 file 
 , 
  
 kinds 
 : 
  
 [ 
 'Employee' 
 , 
  
 'Task' 
 ], 
  
 namespaces 
 : 
  
 [ 
 'Company' 
 ], 
  
 }); 
  
 // Uncomment to await the results of the operation. 
  
 // await specificImportOperation.promise(); 
  
 // Or cancel the operation. 
  
 await 
  
 specificImportOperation 
 . 
 cancel 
 (); 
 } 
 importEntities 
 (); 
 

  def 
  
 import_entities 
 ( 
 project_id 
 , 
 input_url 
 ): 
  
 """Imports entities into Datastore.""" 
 # project_id := "project-id" 
 # input_url := "gs://bucket-name/overall-export-metadata-file" 
 client 
 = 
 DatastoreAdminClient 
 () 
 op 
 = 
 client 
 . 
 import_entities 
 ({ 
 "project_id" 
 : 
 project_id 
 , 
 "input_url" 
 : 
 input_url 
 }) 
 response 
 = 
 op 
 . 
 result 
 ( 
 timeout 
 = 
 300 
 ) 
 print 
 ( 
 "Entities were imported 
 \n 
 " 
 ) 
 return 
 response 
 

  # project_id = "project-id" 
 # input_url = "gs://bucket-name/overall-export-metadata-file" 
 op 
  
 = 
  
 client 
 . 
 import_entities 
  
 project_id 
 : 
  
 project_id 
 , 
  
 input_url 
 : 
  
 input_url 
 op 
 . 
 wait_until_done! 
 raise 
  
 op 
 . 
 error 
 . 
 message 
  
 if 
  
 op 
 . 
 error? 
 response 
  
 = 
  
 op 
 . 
 response 
 # Process the response. 
 metadata 
  
 = 
  
 op 
 . 
 metadata 
 # Process the metadata. 
 puts 
  
 "Entities were imported"