/// <summary>
/// Asynchronously mutates a row atomically based on the output of a predicate Reader filter.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="CheckAndMutateRowAsync(CheckAndMutateRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the conditional mutation should be
/// applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the conditional mutation should be applied.
/// Must not be empty.
/// </param>
/// <param name="predicateFilter">
/// The filter to be applied to the contents of the specified row. Depending
/// on whether or not any results are yielded, <paramref name="trueMutations"/> may or may not
/// be executed. If null, checks that the row contains any values at all.
/// </param>
/// <param name="trueMutations">
/// Changes to be atomically applied to the specified row if <paramref name="predicateFilter"/>
/// yields at least one cell when applied to <paramref name="rowKey"/>. Entries are applied in
/// order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry and at most 100000. Must not be null, or contain null elements.
/// </param>
/// <returns>
/// The response from trying to mutate the row.
/// </returns>
public virtual Task <CheckAndMutateRowResponse> CheckAndMutateRowAsync(
TableName tableName,
BigtableByteString rowKey,
RowFilter predicateFilter,
params Mutation[] trueMutations) =>
CheckAndMutateRowAsync(
CreateCheckAndMutateRowRequest(tableName, rowKey, predicateFilter, trueMutations, falseMutations: null));
private static CheckAndMutateRowRequest CreateCheckAndMutateRowRequest(
TableName tableName,
BigtableByteString rowKey,
RowFilter predicateFilter,
IEnumerable <Mutation> trueMutations,
IEnumerable <Mutation> falseMutations)
{
GaxPreconditions.CheckNotNull(tableName, nameof(tableName));
GaxPreconditions.CheckArgument(rowKey.Length != 0, nameof(rowKey), "The row key must not empty");
var request = new CheckAndMutateRowRequest
{
TableNameAsTableName = tableName,
RowKey = rowKey.Value,
PredicateFilter = predicateFilter,
TrueMutations = { Utilities.ValidateCollection(trueMutations, nameof(trueMutations), allowNullCollection: true) },
FalseMutations = { Utilities.ValidateCollection(falseMutations, nameof(falseMutations), allowNullCollection: true) }
};
GaxPreconditions.CheckArgument(
request.TrueMutations.Count + request.FalseMutations.Count != 0,
nameof(trueMutations),
"There must be at least one mutation.");
return(request);
}
/// <summary>
/// Asynchronously modifies a row atomically on the server. The method reads the latest existing version
/// and value from the specified columns and writes a new entry based on
/// pre-defined read/modify/write rules. The new value for the version is the
/// greater of the previous value's version or the current server version. The method
/// returns the new contents of all modified cells.
/// </summary>
/// <remarks>
/// <para>
/// Note that the server version is based on the current timestamp since the Unix epoch, so for
/// columns which are updated using ReadModifyWriteRow, other reads and writes of those columns
/// should use <see cref="BigtableVersion"/> values constructed from DateTime values, as opposed
/// to using a custom versioning scheme with 64-bit values.
/// </para>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="ReadModifyWriteRowAsync(ReadModifyWriteRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the read/modify/write rules should be
/// applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the read/modify/write rules should be applied.
/// Must not be empty.
/// </param>
/// <param name="rules">
/// Rules specifying how the specified row's contents are to be transformed
/// into writes. Entries are applied in order, meaning that earlier rules will
/// affect the results of later ones. Must not be null, or contain null
/// elements.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The response from modifying the row.
/// </returns>
public virtual Task <ReadModifyWriteRowResponse> ReadModifyWriteRowAsync(
TableName tableName,
BigtableByteString rowKey,
IEnumerable <ReadModifyWriteRule> rules,
CallSettings callSettings = null) =>
ReadModifyWriteRowAsync(
CreateReadModifyWriteRowRequest(tableName, rowKey, rules),
callSettings);
/// <summary>
/// Rule specifying that <paramref name="incrementAmount"/> be added to the existing value.
/// If the targeted cell is unset, it will be treated as containing a zero.
/// Otherwise, the targeted cell must contain an 8-byte value (interpreted
/// as a 64-bit big-endian signed integer), or the entire request will fail.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="columnQualifier"/> can be specified using a string as well and
/// its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="familyName">
/// The name of the family to which the read/modify/write should be applied.
/// Must match `[-_.a-zA-Z0-9]+`
/// </param>
/// <param name="columnQualifier">
/// The qualifier of the column to which the read/modify/write should be
/// applied. Can be any byte string, including the empty string.
/// </param>
/// <param name="incrementAmount">
/// The amount to increment the existing cell value.
/// </param>
/// <returns>
/// The increment amount rule.
/// </returns>
public static ReadModifyWriteRule Increment(
string familyName, BigtableByteString columnQualifier, long incrementAmount) =>
new ReadModifyWriteRule
{
FamilyName = Utilities.ValidateFamilyName(familyName),
ColumnQualifier = columnQualifier.Value,
IncrementAmount = incrementAmount
};
/// <summary>
/// Rule specifying that <paramref name="appendValue"/> be appended to the existing value.
/// If the targeted cell is unset, it will be treated as containing the empty string.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="columnQualifier"/> can be specified using a string as well and
/// its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="familyName">
/// The name of the family to which the read/modify/write should be applied.
/// Must match `[-_.a-zA-Z0-9]+`
/// </param>
/// <param name="columnQualifier">
/// The qualifier of the column to which the read/modify/write should be
/// applied. Can be any byte string, including the empty string.
/// </param>
/// <param name="appendValue">
/// The value to append to the existing cell value.
/// </param>
/// <returns>
/// The append value rule.
/// </returns>
public static ReadModifyWriteRule Append(
string familyName, BigtableByteString columnQualifier, BigtableByteString appendValue) =>
new ReadModifyWriteRule
{
FamilyName = Utilities.ValidateFamilyName(familyName),
ColumnQualifier = columnQualifier.Value,
AppendValue = appendValue.Value
};
/// <summary>
/// Asynchronously mutates a row atomically. Cells already present in the row are left
/// unchanged unless explicitly changed by <paramref name="mutations"/>.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="MutateRowAsync(MutateRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the mutation should be applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the mutation should be applied. Must not be empty.
/// </param>
/// <param name="mutations">
/// Changes to be atomically applied to the specified row. Entries are applied
/// in order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry and at most 100000. Must not be null, or contain null
/// elements.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The response from mutating the row.
/// </returns>
public virtual Task <MutateRowResponse> MutateRowAsync(
TableName tableName,
BigtableByteString rowKey,
IEnumerable <Mutation> mutations,
CallSettings callSettings = null) =>
MutateRowAsync(
CreateMutateRowRequest(tableName, rowKey, mutations),
callSettings);
/// <summary>
/// Mutates a row atomically based on the output of a predicate Reader filter.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="CheckAndMutateRow(CheckAndMutateRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the conditional mutation should be
/// applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the conditional mutation should be applied.
/// Must not be empty.
/// </param>
/// <param name="predicateFilter">
/// The filter to be applied to the contents of the specified row. Depending
/// on whether or not any results are yielded, either <paramref name="trueMutations"/> or
/// <paramref name="falseMutations"/> will be executed. If null, checks that the row contains
/// any values at all.
/// </param>
/// <param name="trueMutations">
/// Changes to be atomically applied to the specified row if <paramref name="predicateFilter"/>
/// yields at least one cell when applied to <paramref name="rowKey"/>. Entries are applied in
/// order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry if <paramref name="falseMutations"/> is null or empty, and
/// at most 100000. Can be null or empty, but must not contain null elements.
/// </param>
/// <param name="falseMutations">
/// Changes to be atomically applied to the specified row if <paramref name="predicateFilter"/>
/// does not yield any cells when applied to <paramref name="rowKey"/>. Entries are applied in
/// order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry if <paramref name="trueMutations"/> is null or empty, and
/// at most 100000. Can be null or empty, but must not contain null elements.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The response from trying to mutate the row.
/// </returns>
public virtual CheckAndMutateRowResponse CheckAndMutateRow(
TableName tableName,
BigtableByteString rowKey,
RowFilter predicateFilter,
IEnumerable <Mutation> trueMutations,
IEnumerable <Mutation> falseMutations,
CallSettings callSettings = null) =>
CheckAndMutateRow(
CreateCheckAndMutateRowRequest(tableName, rowKey, predicateFilter, trueMutations, falseMutations),
callSettings);
/// <summary>
/// Creates a <see cref="MutateRowsRequest.Types.Entry"/> to use with MutateRows requests.
/// Each Entry is an atomic, ordered set of mutations for a particular row.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="rowKey">
/// The key of the row to which the <paramref name="mutations"/> should be applied. Must not be empty.
/// </param>
/// <param name="mutations">
/// Changes to be atomically applied to the specified row. Mutations are
/// applied in order, meaning that earlier mutations can be masked by
/// later ones. You must specify at least one mutation. Must not be null, or contain null
/// elements.
/// </param>
/// <returns>The MutateRows entry describing mutations for a single row.</returns>
/// <seealso cref="BigtableClient.MutateRows(MutateRowsRequest, Api.Gax.Grpc.CallSettings)"/>
/// <seealso cref="BigtableClient.MutateRows(TableName, MutateRowsRequest.Types.Entry[])"/>
/// <seealso cref="BigtableClient.MutateRows(TableName, System.Collections.Generic.IEnumerable{MutateRowsRequest.Types.Entry}, Api.Gax.Grpc.CallSettings)"/>
public static MutateRowsRequest.Types.Entry CreateEntry(BigtableByteString rowKey, params Mutation[] mutations)
{
GaxPreconditions.CheckArgument(rowKey.Length != 0, nameof(rowKey), "The row key must not empty");
var entry = new MutateRowsRequest.Types.Entry
{
RowKey = (ByteString)rowKey,
Mutations = { Utilities.ValidateCollection(mutations, nameof(mutations)) }
};
GaxPreconditions.CheckArgument(
entry.Mutations.Count != 0, nameof(mutations), "There must be at least one entry.");
return(entry);
}
/// <summary>
/// Creates a <see cref="Mutation"/> which deletes cells from the specified column, optionally
/// restricting the deletions to a given version range.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="columnQualifier"/> can be specified using a string as well and
/// its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="familyName">
/// The name of the family from which cells should be deleted.
/// Must match `[-_.a-zA-Z0-9]+`
/// </param>
/// <param name="columnQualifier">
/// The qualifier of the column from which cells should be deleted.
/// Can be any byte string, including the empty string.
/// </param>
/// <param name="versionRange">
/// [Optional] The range of versions within which cells should be deleted.
/// If unspecified, all versions will be deleted.
/// </param>
/// <returns>The created Mutation instance.</returns>
public static Mutation DeleteFromColumn(
string familyName,
BigtableByteString columnQualifier,
BigtableVersionRange versionRange = null) =>
new Mutation
{
DeleteFromColumn = new Mutation.Types.DeleteFromColumn
{
FamilyName = ValidateFamilyName(familyName),
ColumnQualifier = columnQualifier.Value,
TimeRange = versionRange.ToTimestampRange()
}
};
/// <summary>
/// Creates a <see cref="Mutation"/> which sets the value of the specified cell.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="columnQualifier"/> or <paramref name="value"/> can be specified
/// using a string as well and its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="familyName">
/// The name of the family into which new data should be written.
/// Must match `[-_.a-zA-Z0-9]+`
/// </param>
/// <param name="columnQualifier">
/// The qualifier of the column into which new data should be written.
/// Can be any byte string, including the empty string.
/// </param>
/// <param name="value">
/// The value to be written into the specified cell.
/// </param>
/// <param name="version">
/// [Optional] The version of the cell into which new data should be written.
/// If unspecified, the version will be initialized from the current UTC time.
/// </param>
/// <returns>The created Mutation instance.</returns>
public static Mutation SetCell(
string familyName,
BigtableByteString columnQualifier,
BigtableByteString value,
BigtableVersion?version = null) =>
new Mutation
{
SetCell = new Mutation.Types.SetCell
{
FamilyName = Utilities.ValidateFamilyName(familyName),
ColumnQualifier = columnQualifier.Value,
Value = value.Value,
TimestampMicros = (version ?? new BigtableVersion(DateTime.UtcNow)).Micros
}
};
/// <summary>
/// Creates a <see cref="Mutation"/> which sets the value of the specified cell.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="columnQualifier"/> or <paramref name="value"/> can be specified
/// using a string as well and its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="familyName">
/// The name of the family into which new data should be written.
/// Must match `[-_.a-zA-Z0-9]+`
/// </param>
/// <param name="columnQualifier">
/// The qualifier of the column into which new data should be written.
/// Can be any byte string, including the empty string.
/// </param>
/// <param name="value">
/// The value to be written into the specified cell.
/// </param>
/// <param name="version">
/// [Optional] The version of the cell into which new data should be written.
/// If unspecified, the version will be initialized from the current UTC time.
/// </param>
/// <returns>The created Mutation instance.</returns>
public static Mutation SetCell(
string familyName,
BigtableByteString columnQualifier,
BigtableByteString value,
BigtableVersion?version = null) =>
new Mutation
{
SetCell = new Mutation.Types.SetCell
{
FamilyName = ValidateFamilyName(familyName),
ColumnQualifier = columnQualifier.Value,
Value = value.Value,
TimestampMicros = version.ToTimestampMicros()
}
};
private static ReadModifyWriteRowRequest CreateReadModifyWriteRowRequest(
TableName tableName,
BigtableByteString rowKey,
IEnumerable <ReadModifyWriteRule> rules)
{
GaxPreconditions.CheckNotNull(tableName, nameof(tableName));
GaxPreconditions.CheckArgument(rowKey.Length != 0, nameof(rowKey), "The row key must not empty");
var request = new ReadModifyWriteRowRequest
{
TableNameAsTableName = tableName,
RowKey = rowKey.Value,
Rules = { Utilities.ValidateCollection(rules, nameof(rules)) }
};
GaxPreconditions.CheckArgument(
request.Rules.Count != 0, nameof(rules), "There must be at least one entry.");
return(request);
}
/// <summary>
/// Asynchronously returns the contents of the requested row, optionally applying the specified Reader filter.
/// </summary>
/// <remarks>
/// <para>
/// This method simply delegates to <see cref="ReadRows(TableName, RowSet, RowFilter, long?, CallSettings)"/>
/// and takes the single row result or null if no rows are returned.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table from which to read. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to read. Must not be empty.
/// </param>
/// <param name="filter">
/// The filter to apply to the contents of the specified row. If null,
/// reads the entirety of the row.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The row from the server or null if it does not exist.
/// </returns>
public virtual async Task <Row> ReadRowAsync(
TableName tableName,
BigtableByteString rowKey,
RowFilter filter = null,
CallSettings callSettings = null)
{
GaxPreconditions.CheckNotNull(tableName, nameof(tableName));
GaxPreconditions.CheckArgument(rowKey.Length != 0, nameof(rowKey), "The row key must not empty");
var response = ReadRows(
tableName,
new RowSet {
RowKeys = { rowKey.Value }
},
filter,
callSettings: callSettings);
return(await response.AsAsyncEnumerable().SingleOrDefault().ConfigureAwait(false));
}
/// <summary>
/// Asynchronously returns the contents of the requested row, optionally applying the specified Reader filter.
/// </summary>
/// <remarks>
/// <para>
/// This method simply delegates to <see cref="ReadRows(TableName, RowSet, RowFilter, long?, CallSettings)"/>
/// and takes the single row result or null if no rows are returned.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table from which to read. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to read. Must not be empty.
/// </param>
/// <param name="filter">
/// The filter to apply to the contents of the specified row. If null,
/// reads the entirety of the row.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The row from the server or null if it does not exist.
/// </returns>
public virtual async Task <Row> ReadRowAsync(
TableName tableName,
BigtableByteString rowKey,
RowFilter filter = null,
CallSettings callSettings = null)
{
GaxPreconditions.CheckNotNull(tableName, nameof(tableName));
GaxPreconditions.CheckArgument(rowKey.Length != 0, nameof(rowKey), "The row key must not empty");
var response = ReadRows(
tableName,
new RowSet {
RowKeys = { rowKey.Value }
},
filter,
callSettings: callSettings);
// Equivalent to using SingleOrDefaultAsync, but avoids a System.Linq.Async dependency.
var enumerator = response.GetAsyncEnumerator(default);
public override RowMergeState HandleChunk(RowAsyncEnumerator owner, CellChunk chunk)
{
owner.Assert(chunk.RowKey != null && !chunk.RowKey.IsEmpty, "NewRow must have a rowKey");
owner.Assert(chunk.FamilyName != null, "NewRow must have a family");
owner.Assert(chunk.Qualifier != null, "NewRow must have a qualifier");
owner.Assert(
owner._currentCell.Row == null || BigtableByteString.Compare(owner._currentCell.Row.Key, chunk.RowKey) < 0,
"NewRow key must be greater than the previous row's");
// WARNING: owner._currentCell is a struct value. Do not extract as a local (which will make a copy).
owner._currentCell.Row = new Row {
Key = chunk.RowKey
};
owner._currentCell.Family = null;
owner._currentCell.Column = null;
owner._currentCell.Timestamp = 0;
owner._currentCell.Labels = null;
// auto transition
return(NewCell.Instance.HandleChunk(owner, chunk));
}
// TODO: Add additional ValueRange... methods to take start/end values?
/// <summary>
/// Creates a new <see cref="RowFilter"/> instance which matches only cells
/// with values that satisfy the given regular expression.
/// </summary>
/// <remarks>
/// <para>
/// Note that, since cell values can contain arbitrary bytes, the `\C` escape
/// sequence must be used if a true wildcard is desired. The `.` character
/// will not match the new line character `\n`, which may be present in a
/// binary value.
/// </para>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="regex"/> can be specified using a string as well and its UTF-8
/// representations will be used.
/// </para>
/// </remarks>
/// <param name="regex">
/// The RE2 regex used to match cell values.
/// </param>
/// <returns>The created row filter.</returns>
public static RowFilter ValueRegex(BigtableByteString regex) =>
new RowFilter
{
ValueRegexFilter = regex.Value
};
/// <summary>
/// Creates a new <see cref="RowFilter"/> instance which matches only cells from
/// columns whose qualifiers satisfy the given RE2 regex.
/// </summary>
/// <remarks>
/// <para>
/// Note that, since column qualifiers can contain arbitrary bytes, the `\C`
/// escape sequence must be used if a true wildcard is desired. The `.`
/// character will not match the new line character `\n`, which may be
/// present in a binary qualifier.
/// </para>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>,
/// so <paramref name="regex"/> can be specified using a string as well and its UTF-8
/// representations will be used.
/// </para>
/// </remarks>
/// <param name="regex">
/// The RE2 regex used to match column qualifiers.
/// </param>
/// <returns>The created row filter.</returns>
public static RowFilter ColumnQualifierRegex(BigtableByteString regex) =>
new RowFilter
{
ColumnQualifierRegexFilter = regex.Value
};
/// <summary>
/// Returns the contents of the requested row, optionally applying the specified Reader filter.
/// </summary>
/// <remarks>
/// <para>
/// This method simply delegates to <see cref="ReadRowAsync(TableName, BigtableByteString, RowFilter, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table from which to read. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to read. Must not be empty.
/// </param>
/// <param name="filter">
/// The filter to apply to the contents of the specified row. If null,
/// reads the entirety of the row.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The row from the server or null if it does not exist.
/// </returns>
public virtual Row ReadRow(
TableName tableName,
BigtableByteString rowKey,
RowFilter filter = null,
CallSettings callSettings = null) =>
Task.Run(() => ReadRowAsync(tableName, rowKey, filter, callSettings)).ResultWithUnwrappedExceptions();
/// <summary>
/// Creates a <see cref="RowSet"/> instance from a single row key.
/// </summary>
/// <param name="rowKey">
/// The key of row included in the set.
/// </param>
/// <returns>The created set.</returns>
public static RowSet FromRowKey(BigtableByteString rowKey) =>
new RowSet
{
RowKeys = { rowKey.Value }
};
/// <summary>
/// Asynchronously modifies a row atomically on the server. The method reads the latest existing version
/// and value from the specified columns and writes a new entry based on
/// pre-defined read/modify/write rules. The new value for the version is the
/// greater of the previous value's version or the current server version. The method
/// returns the new contents of all modified cells.
/// </summary>
/// <remarks>
/// <para>
/// Note that the server version is based on the current timestamp since the Unix epoch, so for
/// columns which are updated using ReadModifyWriteRow, other reads and writes of those columns
/// should use <see cref="BigtableVersion"/> values constructed from DateTime values, as opposed
/// to using a custom versioning scheme with 64-bit values.
/// </para>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="ReadModifyWriteRowAsync(ReadModifyWriteRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the read/modify/write rules should be
/// applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the read/modify/write rules should be applied.
/// Must not be empty.
/// </param>
/// <param name="rules">
/// Rules specifying how the specified row's contents are to be transformed
/// into writes. Entries are applied in order, meaning that earlier rules will
/// affect the results of later ones. Must not be null, or contain null
/// elements.
/// </param>
/// <returns>
/// The response from modifying the row.
/// </returns>
public virtual Task <ReadModifyWriteRowResponse> ReadModifyWriteRowAsync(
TableName tableName,
BigtableByteString rowKey,
params ReadModifyWriteRule[] rules) =>
ReadModifyWriteRowAsync(
CreateReadModifyWriteRowRequest(tableName, rowKey, rules));
/// <summary>
/// Creates a new <see cref="RowFilter"/> instance which matches only cells
/// from columns whose qualifiers match the exact byte string specified.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="value"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="value">
/// The exact value used to match column qualifiers.
/// </param>
/// <returns>The created row filter.</returns>
public static RowFilter ColumnQualifierExact(BigtableByteString value) =>
new RowFilter
{
ColumnQualifierRegexFilter = Utilities.RegexEscape(value.Value)
};
/// <summary>
/// Asynchronously mutates a row atomically. Cells already present in the row are left
/// unchanged unless explicitly changed by <paramref name="mutations"/>.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="rowKey"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// <para>
/// This method simply delegates to <see cref="MutateRowAsync(MutateRowRequest, CallSettings)"/>.
/// </para>
/// </remarks>
/// <param name="tableName">
/// The unique name of the table to which the mutation should be applied. Must not be null.
/// </param>
/// <param name="rowKey">
/// The key of the row to which the mutation should be applied. Must not be empty.
/// </param>
/// <param name="mutations">
/// Changes to be atomically applied to the specified row. Entries are applied
/// in order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry and at most 100000. Must not be null, or contain null
/// elements.
/// </param>
/// <returns>
/// The response from mutating the row.
/// </returns>
public virtual Task <MutateRowResponse> MutateRowAsync(
TableName tableName,
BigtableByteString rowKey,
params Mutation[] mutations) =>
MutateRowAsync(
CreateMutateRowRequest(tableName, rowKey, mutations));
/// <summary>
/// Creates a new <see cref="RowFilter"/> instance which matches only cells
/// with values that match the exact byte string specified.
/// </summary>
/// <remarks>
/// <para>
/// Note that string is implicitly convertible to <see cref="BigtableByteString"/>, so <paramref name="value"/> can
/// be specified using a string as well and its UTF-8 representations will be used.
/// </para>
/// </remarks>
/// <param name="value">
/// The exact value used to match cell values.
/// </param>
/// <returns>The created row filter.</returns>
public static RowFilter ValueExact(BigtableByteString value) =>
new RowFilter
{
ValueRegexFilter = Utilities.RegexEscape(value.Value)
};