Tablestore:Write data

Interface

/// <summary>
/// Writes a row of data based on the specified table name, primary key, and properties. Returns the capacity unit consumed by this operation.
/// </summary>
/// <param name="request">The request to insert data.</param>
/// <returns>The capacity unit consumed by this operation.</returns>
public PutRowResponse PutRow(PutRowRequest request);

/// <summary>
/// The asynchronous version of PutRow.
/// </summary>
public Task<PutRowResponse> PutRowAsync(PutRowRequest request);                    

Parameters

Examples

// Define the primary key of the row. It must be consistent with the definition in the TableMeta of the table.
var primaryKey = new PrimaryKey();
primaryKey.Add("pk0", new ColumnValue(0));
primaryKey.Add("pk1", new ColumnValue("abc"));

// Define the attribute columns to be written to the row.
var attribute = new AttributeColumns();
attribute.Add("col0", new ColumnValue(0));
attribute.Add("col1", new ColumnValue("a"));
attribute.Add("col2", new ColumnValue(true));

try
{
    // Construct a request object to insert data. RowExistenceExpectation.IGNORE indicates that new data is inserted regardless of whether the row exists.
    var request = new PutRowRequest("SampleTable", new Condition(RowExistenceExpectation.IGNORE),
                            primaryKey, attribute);

    // Call the PutRow operation to insert the data.
    otsClient.PutRow(request);

    // If no exception is thrown, the operation is successful.
    Console.WriteLine("Put row succeeded.");
}
catch (Exception ex)
{
    // If an exception is thrown, the operation failed. Handle the exception.
    Console.WriteLine("Put row failed, exception:{0}", ex.Message);
}                    

// Define the primary key of the row. It must be consistent with the definition in the TableMeta of the table.
var primaryKey = new PrimaryKey();
primaryKey.Add("pk0", new ColumnValue(0));
primaryKey.Add("pk1", new ColumnValue("abc"));

// Define the attribute columns to be written to the row.
AttributeColumns attribute = new AttributeColumns();
attribute.Add("col0", new ColumnValue(0));
attribute.Add("col1", new ColumnValue("a"));
attribute.Add("col2", new ColumnValue(true));

// Allow inserting the row again and overwriting the original value if the value of the col0 column is greater than 24.
try
{
    var request = new PutRowRequest("SampleTable", new Condition(RowExistenceExpectation.EXPECT_EXIST),
                            primaryKey, attribute);
    request.Condition.ColumnCondition = new RelationalCondition("col0",
                                        CompareOperator.GREATER_THAN,
                                        new ColumnValue(24));
    otsClient.PutRow(request);

    Console.WriteLine("Put row succeeded.");
}
catch (Exception ex)
{
    Console.WriteLine("Put row failed. error:{0}", ex.Message);
}                   

try
{
    var putRowTaskList = new List<Task<PutRowResponse>>();
    for (int i = 0; i < 100; i++)
    {
        // Define the primary key of the row. It must be consistent with the definition in the TableMeta of the table.
        var primaryKey = new PrimaryKey();
        primaryKey.Add("pk0", new ColumnValue(i));
        primaryKey.Add("pk1", new ColumnValue("abc"));

        // Define the attribute columns to be written to the row.
        var attribute = new AttributeColumns();
        attribute.Add("col0", new ColumnValue(i));
        attribute.Add("col1", new ColumnValue("a"));
        attribute.Add("col2", new ColumnValue(true));

        var request = new PutRowRequest("SampleTable", new Condition(RowExistenceExpectation.IGNORE),
                                        primaryKey, attribute);

        putRowTaskList.Add(otsClient.PutRowAsync(request));
    }

    // Wait for each asynchronous call to return and print the consumed CU value.
    foreach (var task in putRowTaskList)
    {
        task.Wait();
        Console.WriteLine("consumed read:{0}, write:{1}", task.Result.ConsumedCapacityUnit.Read,
                            task.Result.ConsumedCapacityUnit.Write);
    }

    // If no exception is thrown, the operation is successful.
    Console.WriteLine("Put row async succeeded.");
}
catch (Exception ex)
{
    // If an exception is thrown, the operation failed. Handle the exception.
    Console.WriteLine("Put row async failed. exception:{0}", ex.Message);
}                   

Interface

/// <summary>
/// Updates the data of a specified row. If the row does not exist, a new row is created. If the row exists, the values of specified columns are added, modified, or deleted based on the request.
/// </summary>
/// <param name="request">The request object.</param>
public UpdateRowResponse UpdateRow(UpdateRowRequest request);

/// <summary>
/// The asynchronous version of UpdateRow.
/// </summary>
/// <param name="request">The request object.</param>
/// <returns></returns>
public Task<UpdateRowResponse> UpdateRowAsync(UpdateRowRequest request);            

Parameters

Example

The following example shows how to update a row of data.

// Define the primary key of the row. The primary key must be the same as the one defined in TableMeta when the table was created.
PrimaryKey primaryKey = new PrimaryKey();
primaryKey.Add("pk0", new ColumnValue(0));
primaryKey.Add("pk1", new ColumnValue("abc"));

// Define the attribute columns to write to the row.
UpdateOfAttribute attribute = new UpdateOfAttribute();
attribute.AddAttributeColumnToPut("col0", new ColumnValue(0));
attribute.AddAttributeColumnToPut("col1", new ColumnValue("b")); // Change the original value 'a' to 'b'.
attribute.AddAttributeColumnToPut("col2", new ColumnValue(true));

try
{
    // Construct a request object to update the row. RowExistenceExpectation.IGNORE indicates that the row is updated whether it exists or not.
    var request = new UpdateRowRequest("SampleTable", new Condition(RowExistenceExpectation.IGNORE),
                                primaryKey, attribute);
    // Call the UpdateRow operation to update the data.
    otsClient.UpdateRow(request);

    // If no exception is thrown, the operation is successful.
    Console.WriteLine("Update row succeeded.");
}
catch (Exception ex)
{
    // If an exception is thrown, the operation failed. Handle the exception.
    Console.WriteLine("Update row failed, exception:{0}", ex.Message);
}           

For the complete sample code, see UpdateRow@GitHub.

Notes

API

/// <summary>
/// <para>Bulk inserts, updates, or deletes multiple rows of data in one or more tables.</para>
/// <para>The BatchWriteRow operation is a collection of multiple PutRow, UpdateRow, and DeleteRow operations. Each operation is executed independently, returns its own result, and consumes capacity units separately.</para>
/// <para>Compared to many single-row write operations, the BatchWriteRow operation reduces request response times and improves the data write speed.</para>
/// </summary>
/// <param name="request">The request instance.</param>
/// <returns>The response instance.</returns>
public BatchWriteRowResponse BatchWriteRow(BatchWriteRowRequest request);

/// <summary>
/// The asynchronous version of BatchWriteRow.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task<BatchWriteRowResponse> BatchWriteRowAsync(BatchWriteRowRequest request);            

Example

The following example shows how to batch write 100 rows of data.

var TableName = "SampleTable";
// Construct a batch write request object and set the primary keys for 100 rows of data.
var request = new BatchWriteRowRequest();
var rowChanges = new RowChanges(TableName);
for (int i = 0; i < 100; i++)
{
    PrimaryKey primaryKey = new PrimaryKey();
    primaryKey.Add("pk0", new ColumnValue(i));
    primaryKey.Add("pk1", new ColumnValue("abc"));

    // Define the attribute columns to write to the row.
    UpdateOfAttribute attribute = new UpdateOfAttribute();
    attribute.AddAttributeColumnToPut("col0", new ColumnValue(0));
    attribute.AddAttributeColumnToPut("col1", new ColumnValue("a"));
    attribute.AddAttributeColumnToPut("col2", new ColumnValue(true));

    rowChanges.AddUpdate(new Condition(RowExistenceExpectation.IGNORE), primaryKey, attribute);
}

request.Add(TableName, rowChanges);

try
{
    // Call the BatchWriteRow API to write data.
    var response = otsClient.BatchWriteRow(request);
    var tableRows = response.TableRespones;
    var rows = tableRows[TableName];

    // A batch operation may partially succeed. Check the status of each row for success. For more information, see the GitHub link in the sample code.
}
catch (Exception ex)
{
    // If an exception is thrown, the execution failed. Handle the exception.
    Console.WriteLine("Batch put row failed, exception:{0}", ex.Message);
}           

For the complete sample code, see BatchWriteRow@GitHub.