/// <summary>Snippet for MutateRows</summary> public async Task MutateRows() { // Snippet: MutateRows(MutateRowsRequest,CallSettings) // Create client BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create(); // Initialize request argument MutateRowsRequest request = new MutateRowsRequest { TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"), Entries = { }, }; // Make the request, returning a streaming response BigtableServiceApiClient.MutateRowsStream streamingResponse = bigtableServiceApiClient.MutateRows(request); // Read streaming responses from server until complete IAsyncEnumerator <MutateRowsResponse> responseStream = streamingResponse.ResponseStream; while (await responseStream.MoveNext()) { MutateRowsResponse response = responseStream.Current; // Do something with streamed response } // The response stream has completed // End snippet }
/// <summary>Snippet for MutateRows</summary> public async Task MutateRows2ResourceNames() { // Snippet: MutateRows(TableName, IEnumerable<MutateRowsRequest.Types.Entry>, string, CallSettings) // Create client BigtableClient bigtableClient = BigtableClient.Create(); // Initialize request argument(s) TableName tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"); IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[] { new MutateRowsRequest.Types.Entry(), }; string appProfileId = ""; // Make the request, returning a streaming response BigtableClient.MutateRowsStream response = bigtableClient.MutateRows(tableName, entries, appProfileId); // Read streaming responses from server until complete // Note that C# 8 code can use await foreach AsyncResponseStream <MutateRowsResponse> responseStream = response.GetResponseStream(); while (await responseStream.MoveNextAsync()) { MutateRowsResponse responseItem = responseStream.Current; // Do something with streamed response } // The response stream has completed // End snippet }
/// <summary>Snippet for MutateRows</summary> public async Task MutateRows1() { // Snippet: MutateRows(string, IEnumerable<MutateRowsRequest.Types.Entry>, CallSettings) // Create client BigtableClient bigtableClient = BigtableClient.Create(); // Initialize request argument(s) string tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]"; IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[] { new MutateRowsRequest.Types.Entry(), }; // Make the request, returning a streaming response BigtableClient.MutateRowsStream response = bigtableClient.MutateRows(tableName, entries); // Read streaming responses from server until complete // Note that C# 8 code can use await foreach AsyncResponseStream <MutateRowsResponse> responseStream = response.GetResponseStream(); while (await responseStream.MoveNextAsync()) { MutateRowsResponse responseItem = responseStream.Current; // Do something with streamed response } // The response stream has completed // End snippet }
/// <summary>Snippet for MutateRows</summary> public async Task MutateRows2_ResourceNames() { // Snippet: MutateRows(TableName, IEnumerable<MutateRowsRequest.Types.Entry>, string, CallSettings) // Create client BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create(); // Initialize request argument(s) TableName tableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"); IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[] { new MutateRowsRequest.Types.Entry(), }; string appProfileId = ""; // Make the request, returning a streaming response BigtableServiceApiClient.MutateRowsStream response = bigtableServiceApiClient.MutateRows(tableName, entries, appProfileId); // Read streaming responses from server until complete IAsyncEnumerator <MutateRowsResponse> responseStream = response.ResponseStream; while (await responseStream.MoveNext()) { MutateRowsResponse responseItem = responseStream.Current; // Do something with streamed response } // The response stream has completed // End snippet }
/// <summary>Snippet for MutateRows</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public async Task MutateRowsRequestObject() { // Create client BigtableClient bigtableClient = BigtableClient.Create(); // Initialize request argument(s) MutateRowsRequest request = new MutateRowsRequest { TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"), Entries = { new MutateRowsRequest.Types.Entry(), }, AppProfileId = "", }; // Make the request, returning a streaming response BigtableClient.MutateRowsStream response = bigtableClient.MutateRows(request); // Read streaming responses from server until complete // Note that C# 8 code can use await foreach AsyncResponseStream <MutateRowsResponse> responseStream = response.GetResponseStream(); while (await responseStream.MoveNextAsync()) { MutateRowsResponse responseItem = responseStream.Current; // Do something with streamed response } // The response stream has completed }
/// <summary> /// Mutate multiple rows in an existing table and column family. Updates multiple cells within each row. ///</summary> /// <param name="projectId">Your Google Cloud Project ID.</param> /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param> /// <param name="tableId">Your Google Cloud Bigtable table ID.</param> public string writeBatch( string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID") { BigtableClient bigtableClient = BigtableClient.Create(); TableName tableName = new TableName(projectId, instanceId, tableId); BigtableVersion timestamp = new BigtableVersion(DateTime.UtcNow); String COLUMN_FAMILY = "stats_summary"; MutateRowsRequest.Types.Entry mutations1 = Mutations.CreateEntry(new BigtableByteString("tablet#a0b81f74#20190501"), Mutations.SetCell(COLUMN_FAMILY, "connected_cell", 1, timestamp), Mutations.SetCell(COLUMN_FAMILY, "os_build", "12155.0.0-rc1", timestamp) ); MutateRowsRequest.Types.Entry mutations2 = Mutations.CreateEntry(new BigtableByteString("tablet#a0b81f74#20190502"), Mutations.SetCell(COLUMN_FAMILY, "connected_cell", 1, timestamp), Mutations.SetCell(COLUMN_FAMILY, "os_build", "12145.0.0-rc6", timestamp) ); MutateRowsRequest.Types.Entry[] entries = { mutations1, mutations2 }; MutateRowsResponse mutateRowResponse = bigtableClient.MutateRows(tableName, entries); foreach (MutateRowsResponse.Types.Entry entry in mutateRowResponse.Entries) { if (entry.Status.Code == 0) { Console.WriteLine($"Row {entry.Index} written successfully"); } else { Console.WriteLine($"\tFailed to write row {entry.Index}"); Console.WriteLine(entry.Status.Message); return(entry.Status.Message); } } return("Successfully wrote 2 rows"); }
/// <summary> /// Reads MutateRowsResponse message and saves the statuses of all request Entries. /// </summary> /// <param name="response"> /// A MutateRowsResponse message received from MutateRows call.</param> internal void SetStatus(MutateRowsResponse response) { foreach (var entry in response.Entries) { int index = (int)entry.Index; if (_mapToOriginalIndex != null) { if (index >= _mapToOriginalIndex.Length || index < 0) { _messageIsInvalid = true; break; } index = _mapToOriginalIndex[index]; } if (index >= _results.Length || index < 0) { _messageIsInvalid = true; break; } // Set the result _results[index] = entry.Status; } }
/// <summary> /// Waits for complete <see cref="BigtableClient.MutateRowsStream"/> and checks <see cref="Google.Rpc.Status.Code"/> of every entry of the <see cref="MutateRowsRequest"/> /// </summary> /// <param name="response"> a <see cref="BigtableClient.MutateRowsStream"/></param> private async Task CheckWrittenAsync(BigtableClient.MutateRowsStream response) { IAsyncEnumerator <MutateRowsResponse> responseStream = response.ResponseStream; while (await responseStream.MoveNext()) { MutateRowsResponse current = responseStream.Current; // Check whether rows where written successfully foreach (var entry in current.Entries) { _greetingIndex = _mapToOriginalGreetingIndex[(int)entry.Index]; if (entry.Status.Code == 0) { Console.WriteLine($"\tGreeting: --{_settings.Greetings[_greetingIndex]}-- written successfully"); } else { Console.WriteLine($"\tFailed to write Greeting: --{_settings.Greetings[_greetingIndex]}"); Console.WriteLine(entry.Status.Message); } } } }
private static void DoHelloWorld() { try { // [START bigtable_hw_connect] // BigtableTableAdminClient API lets us create, manage and delete tables. BigtableTableAdminClient bigtableTableAdminClient = BigtableTableAdminClient.Create(); // BigtableClient API lets us read and write to a table. BigtableClient bigtableClient = BigtableClient.Create(); // [END bigtable_hw_connect] // [START bigtable_hw_create_table] // Create a table with a single column family. Console.WriteLine($"Create new table: {tableId} with column family: {columnFamily}, instance: {instanceId}"); // Check whether a table with given TableName already exists. if (!TableExist(bigtableTableAdminClient)) { bigtableTableAdminClient.CreateTable( new InstanceName(projectId, instanceId), tableId, new Table { Granularity = Table.Types.TimestampGranularity.Millis, ColumnFamilies = { { columnFamily, new ColumnFamily { GcRule = new GcRule { MaxNumVersions = 1 } } } } }); // Confirm that table was created successfully. Console.WriteLine(TableExist(bigtableTableAdminClient) ? $"Table {tableId} created successfully\n" : $"There was a problem creating a table {tableId}"); } else { Console.WriteLine($"Table: {tableId} already exists"); } // [END bigtable_hw_create_table] // [START bigtable_hw_write_rows] // Initialize Google.Cloud.Bigtable.V2.TableName object. Google.Cloud.Bigtable.Common.V2.TableName tableName = new Google.Cloud.Bigtable.Common.V2.TableName(projectId, instanceId, tableId); // Write some rows /* Each row has a unique row key. * * Note: This example uses sequential numeric IDs for simplicity, but * this can result in poor performance in a production application. * Since rows are stored in sorted order by key, sequential keys can * result in poor distribution of operations across nodes. * * For more information about how to design a Bigtable schema for the * best performance, see the documentation: * * https://cloud.google.com/bigtable/docs/schema-design */ Console.WriteLine($"Write some greetings to the table {tableId}"); // Insert 1 row using MutateRow() s_greetingIndex = 0; try { bigtableClient.MutateRow(tableName, rowKeyPrefix + s_greetingIndex, MutationBuilder()); Console.WriteLine($"\tGreeting: -- {s_greetings[s_greetingIndex],-18}-- written successfully"); } catch (Exception ex) { Console.WriteLine($"\tFailed to write greeting: --{s_greetings[s_greetingIndex]}"); Console.WriteLine(ex.Message); throw; } // Insert multiple rows using MutateRows() // Build a MutateRowsRequest (contains table name and a collection of entries). MutateRowsRequest request = new MutateRowsRequest { TableNameAsTableName = tableName }; s_mapToOriginalGreetingIndex = new List <int>(); while (++s_greetingIndex < s_greetings.Length) { s_mapToOriginalGreetingIndex.Add(s_greetingIndex); // Build an entry for every greeting (consists of rowkey and a collection of mutations). string rowKey = rowKeyPrefix + s_greetingIndex; request.Entries.Add(Mutations.CreateEntry(rowKey, MutationBuilder())); } // Make the request to write multiple rows. MutateRowsResponse response = bigtableClient.MutateRows(request); // Check the status code of each entry to ensure that it was written successfully. foreach (MutateRowsResponse.Types.Entry entry in response.Entries) { s_greetingIndex = s_mapToOriginalGreetingIndex[(int)entry.Index]; if (entry.Status.Code == 0) { Console.WriteLine($"\tGreeting: -- {s_greetings[s_greetingIndex],-18}-- written successfully"); } else { Console.WriteLine($"\tFailed to write greeting: --{s_greetings[s_greetingIndex]}"); Console.WriteLine(entry.Status.Message); } } Mutation MutationBuilder() => Mutations.SetCell(columnFamily, columnName, s_greetings[s_greetingIndex], new BigtableVersion(DateTime.UtcNow)); //[END bigtable_hw_write_rows] // [START bigtable_hw_create_filter] RowFilter filter = RowFilters.CellsPerRowLimit(1); // [END bigtable_hw_create_filter] // [START bigtable_hw_get_with_filter] // Read from the table. Console.WriteLine("Read the first row"); int rowIndex = 0; // Read a specific row. Apply a filter to return latest only cell value accross entire row. Row rowRead = bigtableClient.ReadRow( tableName, rowKey: rowKeyPrefix + rowIndex, filter: filter); Console.WriteLine( $"\tRow key: {rowRead.Key.ToStringUtf8()} " + $" -- Value: {rowRead.Families[0].Columns[0].Cells[0].Value.ToStringUtf8(),-16} " + $" -- Time Stamp: {rowRead.Families[0].Columns[0].Cells[0].TimestampMicros}"); // [END bigtable_hw_get_with_filter] // [START bigtable_hw_scan_with_filter] Console.WriteLine("Read all rows using streaming"); // stream the content of the whole table. Apply a filter to return latest only cell values accross all rows. ReadRowsStream responseRead = bigtableClient.ReadRows(tableName, filter: filter); Task printRead = PrintReadRowsAsync(); printRead.Wait(); async Task PrintReadRowsAsync() { await responseRead.ForEachAsync(row => { Console.WriteLine($"\tRow key: {row.Key.ToStringUtf8()} " + $" -- Value: {row.Families[0].Columns[0].Cells[0].Value.ToStringUtf8(),-16} " + $" -- Time Stamp: {row.Families[0].Columns[0].Cells[0].TimestampMicros}"); }); } // [END bigtable_hw_scan_with_filter] // [START bigtable_hw_delete_table] // Clean up. Delete the table. Console.WriteLine($"Delete table: {tableId}"); bigtableTableAdminClient.DeleteTable(name: tableName); if (!TableExist(bigtableTableAdminClient)) { Console.WriteLine($"Table: {tableId} deleted successfully"); } // [END bigtable_hw_delete_table] } catch (Exception ex) { Console.WriteLine($"Exception while running HelloWorld: {ex.Message}"); } }