/// <summary>Snippet for ReadRows</summary>
public async Task ReadRowsRequestObject()
{
// Snippet: ReadRows(ReadRowsRequest, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
ReadRowsRequest request = new ReadRowsRequest
{
TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
Rows = new RowSet(),
Filter = new RowFilter(),
RowsLimit = 0L,
AppProfileId = "",
};
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
public async Task ReadRows()
{
// Snippet: ReadRows(ReadRowsRequest,CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument
ReadRowsRequest request = new ReadRowsRequest
{
TableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]").ToString(),
};
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream streamingResponse = bigtableClient.ReadRows(request);
// Read streaming responses from server until complete
IAsyncEnumerator <ReadRowsResponse> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
ReadRowsResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
private async Task PrintReadRowsAsync(BigtableClient.ReadRowsStream responseRead)
{
Console.WriteLine("Read all rows using streaming");
await responseRead.AsAsyncEnumerable().ForEachAsync(row =>
{
Console.WriteLine($"\tRow key: {row.Key.ToStringUtf8()}, Value: {row.Families[0].Columns[0].Cells[0].Value.ToStringUtf8()}");
});
}
/// <summary>Snippet for ReadRows</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 ReadRows1()
{
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
string tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(tableName);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for ReadRows</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 ReadRows2ResourceNames()
{
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
TableName tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
string appProfileId = "";
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(tableName, appProfileId);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
internal void DoHelloWorld()
{
#region 1. Create table with column family.
try
{
Console.WriteLine($"Create new table: {_settings.TableName} with column family {_settings.ColumnFamily}, Instance: {_settings.InstanceId}");
// Check whether a table with given TableName already exists.
if (!DoesTableExist(_bigtableTableAdminClient, _tableNameAdmin))
{
_bigtableTableAdminClient.CreateTable(
new InstanceName(_settings.ProjectId, _settings.InstanceId),
_settings.TableName,
new Table
{
Granularity = Table.Types.TimestampGranularity.Millis,
ColumnFamilies =
{
{
_settings.ColumnFamily, new ColumnFamily
{
GcRule = new GcRule
{
MaxNumVersions = 1
}
}
}
}
});
Console.WriteLine(DoesTableExist(_bigtableTableAdminClient, _tableNameAdmin)
? $"Table {_settings.TableName} created succsessfully\n"
: $"There was a problem creating a table {_settings.TableName}");
}
else
{
Console.WriteLine($"Table: {_settings.TableName} already exist");
}
#endregion
#region 2. Insert multiple 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 {_settings.TableName}");
// Insert 1 row using MutateRow()
_greetingIndex = 0;
try
{
_bigtableClient.MutateRow(_tableNameClient, _settings.RowKeyPrefix + _greetingIndex, MutationBuilder(_greetingIndex));
Console.WriteLine($"\tGreeting: --{_settings.Greetings[_greetingIndex]}-- written successfully");
}
catch (Exception ex)
{
Console.WriteLine($"\tFailed to write Greeting: --{_settings.Greetings[_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 = _tableNameClient
};
_mapToOriginalGreetingIndex = new List <int>();
while (++_greetingIndex < _settings.Greetings.Length)
{
_mapToOriginalGreetingIndex.Add(_greetingIndex);
// Build an entry for every greeting (contains of row key and a collection of mutations).
request.Entries.Add(Mutations.CreateEntry(_settings.RowKeyPrefix + _greetingIndex,
MutationBuilder(_greetingIndex)));
}
BigtableClient.MutateRowsStream response = _bigtableClient.MutateRows(request);
Task write = CheckWrittenAsync(response);
write.Wait();
#endregion
#region Read the first row
Console.WriteLine("Read the first row");
int rowIndex = 0;
Row rowRead = _bigtableClient.ReadRow(_tableNameClient, _settings.RowKeyPrefix + rowIndex);
Console.WriteLine(
$"\tRow key: {rowRead.Key.ToStringUtf8()}, Value: {rowRead.Families[0].Columns[0].Cells[0].Value.ToStringUtf8()}");
#endregion
#region Read all rows.
BigtableClient.ReadRowsStream responseRead = _bigtableClient.ReadRows(_tableNameClient);
Task printRead = PrintReadRowsAsync(responseRead);
printRead.Wait();
#endregion
#region Delete table.
Console.WriteLine($"Delete table: {_settings.TableName}");
_bigtableTableAdminClient.DeleteTable(_tableNameAdmin);
if (DoesTableExist(_bigtableTableAdminClient, _tableNameAdmin) == false)
{
Console.WriteLine($"Table: {_settings.TableName} deleted succsessfully");
}
#endregion
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
