private void DeleteTable(OTSClient client, String tableName)
{
DeleteTableRequest req = new DeleteTableRequest(tableName);
client.DeleteTable(req);
Console.WriteLine("DeleteTable success");
}
public void TestDisableErrorLog()
{
var clientConfig = new OTSClientConfig(
TestEndPoint,
TestAccessKeyID,
TestAccessKeySecret,
TestInstanceName)
{
OTSErrorLogHandler = null
};
var otsClient = new OTSClient(clientConfig);
var request = new DeleteTableRequest("blahblah");
try {
otsClient.DeleteTable(request);
Assert.Fail();
} catch (OTSServerException exception) {
AssertOTSServerException(new OTSServerException(
"/DeleteTable",
HttpStatusCode.NotFound,
"OTSObjectNotExist",
"Requested table does not exist."), exception);
}
}
public static void DeleteTable()
{
OTSClient otsClient = Config.GetClient();
Console.WriteLine("Start delete table...");
DeleteTableRequest request = new DeleteTableRequest(TableName);
otsClient.DeleteTable(request);
Console.WriteLine("Table is deleted.");
}
public static void TableOperations()
{
// 创建表
OTSClient otsClient = Config.GetClient();
{
Console.WriteLine("Start create table...");
PrimaryKeySchema primaryKeySchema = new PrimaryKeySchema
{
{ "pk0", ColumnValueType.Integer },
{ "pk1", ColumnValueType.String }
};
TableMeta tableMeta = new TableMeta(TableName, primaryKeySchema);
CapacityUnit reservedThroughput = new CapacityUnit(0, 0);
CreateTableRequest request = new CreateTableRequest(tableMeta, reservedThroughput);
otsClient.CreateTable(request);
Console.WriteLine("Table is created: " + TableName);
}
// 更新表
{
Thread.Sleep(60 * 1000); // 每次更新表需要至少间隔1分钟
Console.WriteLine("Start update table...");
CapacityUnit reservedThroughput = new CapacityUnit(0, 0); // 将预留CU调整为0，0
UpdateTableRequest request = new UpdateTableRequest(TableName, reservedThroughput);
UpdateTableResponse response = otsClient.UpdateTable(request);
Console.WriteLine("LastIncreaseTime: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("LastDecreaseTime: " + response.ReservedThroughputDetails.LastDecreaseTime);
Console.WriteLine("NumberOfDecreaseToday: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("ReadCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Read);
Console.WriteLine("WriteCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Write);
}
// 描述表
{
Console.WriteLine("Start describe table...");
DescribeTableRequest request = new DescribeTableRequest(TableName);
DescribeTableResponse response = otsClient.DescribeTable(request);
Console.WriteLine("LastIncreaseTime: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("LastDecreaseTime: " + response.ReservedThroughputDetails.LastDecreaseTime);
Console.WriteLine("NumberOfDecreaseToday: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("ReadCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Read);
Console.WriteLine("WriteCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Write);
}
// 删除表
{
Console.WriteLine("Start delete table...");
DeleteTableRequest request = new DeleteTableRequest(TableName);
otsClient.DeleteTable(request);
Console.WriteLine("Table is deleted.");
}
}
private void CreateTable(String tableName)
{
foreach (var tableItem in OTSClient.ListTable(new ListTableRequest()).TableNames)
{
OTSClient.DeleteTable(new DeleteTableRequest(tableItem));
}
var primaryKeySchema = new PrimaryKeySchema();
primaryKeySchema.Add("PK0", ColumnValueType.Integer);
var tableMeta = new TableMeta(tableName, primaryKeySchema);
var reservedThroughput = new CapacityUnit(0, 0);
var request = new CreateTableRequest(tableMeta, reservedThroughput);
var response = OTSClient.CreateTable(request);
WaitForTableReady();
}
public void CreateTableAndDelete()
{
string tableName = "SampleTableName";
var primaryKeys = new PrimaryKeySchema
{
{ "PK0", ColumnValueType.String },
{ "PK1", ColumnValueType.Integer }
};
var tableOption = new TableOptions
{
MaxVersions = 1,
TimeToLive = -1
};
var tableMeta = new TableMeta(tableName, primaryKeys);
var reservedThroughput = new CapacityUnit(0, 0);
var request1 = new CreateTableRequest(tableMeta, reservedThroughput)
{
TableOptions = tableOption
};
var response1 = OTSClient.CreateTable(request1);
var request2 = new ListTableRequest();
var response2 = OTSClient.ListTable(request2);
Assert.IsTrue(response2.TableNames.Contains(tableName));
Thread.Sleep(1000);
var request3 = new DescribeTableRequest(tableName);
var response3 = OTSClient.DescribeTable(request3);
Assert.AreEqual(tableName, response3.TableMeta.TableName);
Assert.AreEqual(primaryKeys, response3.TableMeta.PrimaryKeySchema);
Assert.AreEqual(reservedThroughput.Read, response3.ReservedThroughputDetails.CapacityUnit.Read);
Assert.AreEqual(reservedThroughput.Write, response3.ReservedThroughputDetails.CapacityUnit.Write);
OTSClient.DeleteTable(new DeleteTableRequest(tableName));
var request4 = new ListTableRequest();
var response4 = OTSClient.ListTable(request4);
Assert.IsFalse(response4.TableNames.Contains(tableName));
}
private void CreateTable(OTSClient client, String tableName)
{
foreach (var tableItem in client.ListTable(new ListTableRequest()).TableNames)
{
client.DeleteTable(new DeleteTableRequest(tableItem));
}
var primaryKeySchema = new PrimaryKeySchema();
primaryKeySchema.Add(COLUMN_GID_NAME, ColumnValueType.Integer);
primaryKeySchema.Add(COLUMN_UID_NAME, ColumnValueType.Integer);
var tableMeta = new TableMeta(tableName, primaryKeySchema);
var reservedThroughput = new CapacityUnit(0, 0);
var request = new CreateTableRequest(tableMeta, reservedThroughput);
var response = OTSClient.CreateTable(request);
// 创建表只是提交请求，OTS创建表需要一段时间，这里是简单的sleep，请根据实际逻辑修改
WaitForTableReady();
}
public void UpdateTableAndThenDescribe()
{
string tableName = "update_table_and_then_describe";
var primaryKeys = new PrimaryKeySchema
{
{ "PK0", ColumnValueType.String },
{ "PK1", ColumnValueType.Integer }
};
var tableMeta = new TableMeta(tableName, primaryKeys);
var reservedThroughput = new CapacityUnit(0, 0);
var tableOption = new TableOptions
{
MaxVersions = 1,
TimeToLive = -1
};
var request1 = new CreateTableRequest(tableMeta, reservedThroughput)
{
TableOptions = tableOption
};
var response1 = OTSClient.CreateTable(request1);
WaitBeforeUpdateTable();
var request2 = new UpdateTableRequest(tableName)
{
TableOptions = tableOption
};
var response2 = OTSClient.UpdateTable(request2);
OTSClient.DeleteTable(new DeleteTableRequest(tableName));
Assert.AreEqual(0, response2.ReservedThroughputDetails.NumberOfDecreasesToday);
Assert.AreEqual(0, response2.ReservedThroughputDetails.CapacityUnit.Read);
Assert.AreEqual(0, response2.ReservedThroughputDetails.CapacityUnit.Write);
}
public void CreateTableAndDelete()
{
var primaryKeys = new PrimaryKeySchema();
primaryKeys.Add("PK0", ColumnValueType.String);
primaryKeys.Add("PK1", ColumnValueType.Integer);
var tableMeta = new TableMeta("SampleTableName", primaryKeys);
var reservedThroughput = new CapacityUnit(0, 0);
var request1 = new CreateTableRequest(tableMeta, reservedThroughput);
var response1 = OTSClient.CreateTable(request1);
var request2 = new ListTableRequest();
var response2 = OTSClient.ListTable(request2);
Assert.AreEqual(new List <string>()
{
"SampleTableName"
}, response2.TableNames);
Thread.Sleep(1000);
var request3 = new DescribeTableRequest("SampleTableName");
var response3 = OTSClient.DescribeTable(request3);
Assert.AreEqual("SampleTableName", response3.TableMeta.TableName);
Assert.AreEqual(primaryKeys, response3.TableMeta.PrimaryKeySchema);
Assert.AreEqual(reservedThroughput.Read, response3.ReservedThroughputDetails.CapacityUnit.Read);
Assert.AreEqual(reservedThroughput.Write, response3.ReservedThroughputDetails.CapacityUnit.Write);
OTSClient.DeleteTable(new DeleteTableRequest("SampleTableName"));
var request4 = new ListTableRequest();
var response4 = OTSClient.ListTable(request4);
Assert.AreEqual(new List <string>()
{
}, response4.TableNames);
}
public void Setup()
{
Thread.Sleep(1000);
TestTableName = "SampleTestName";
var clientConfig = new OTSClientConfig(
TestEndPoint,
TestAccessKeyID,
TestAccessKeySecret,
TestInstanceName
);
Console.WriteLine("Endpoint: {0}", TestEndPoint);
Console.WriteLine("TestAccessKeyID: {0}", TestAccessKeyID);
Console.WriteLine("TestAccessKeySecret: {0}", TestAccessKeySecret);
Console.WriteLine("TestInstanceName: {0}", TestInstanceName);
clientConfig.OTSDebugLogHandler = LogToFileHandler.DefaultDebugLogHandler;
clientConfig.OTSErrorLogHandler = LogToFileHandler.DefaultErrorLogHandler;
OTSClient = new OTSClient(clientConfig);
OTSClientTestHelper.Reset();
foreach (var tableName in OTSClient.ListTable(new ListTableRequest()).TableNames)
{
OTSClient.DeleteTable(new DeleteTableRequest(tableName));
}
PrimaryKeyWith4Columns = new PrimaryKey();
PrimaryKeyWith4Columns.Add("PK0", new ColumnValue("ABC"));
PrimaryKeyWith4Columns.Add("PK1", new ColumnValue("DEF"));
PrimaryKeyWith4Columns.Add("PK2", new ColumnValue(123));
PrimaryKeyWith4Columns.Add("PK3", new ColumnValue(456));
MinPrimaryKeyWith4Columns = new PrimaryKey();
MinPrimaryKeyWith4Columns.Add("PK0", ColumnValue.INF_MIN);
MinPrimaryKeyWith4Columns.Add("PK1", new ColumnValue("DEF"));
MinPrimaryKeyWith4Columns.Add("PK2", new ColumnValue(123));
MinPrimaryKeyWith4Columns.Add("PK3", new ColumnValue(456));
MaxPrimaryKeyWith4Columns = new PrimaryKey();
MaxPrimaryKeyWith4Columns.Add("PK0", ColumnValue.INF_MAX);
MaxPrimaryKeyWith4Columns.Add("PK1", new ColumnValue("DEF"));
MaxPrimaryKeyWith4Columns.Add("PK2", new ColumnValue(123));
MaxPrimaryKeyWith4Columns.Add("PK3", new ColumnValue(456));
AttributeWith5Columns = new AttributeColumns();
AttributeWith5Columns.Add("Col0", new ColumnValue("ABC"));
AttributeWith5Columns.Add("Col1", new ColumnValue(123));
AttributeWith5Columns.Add("Col2", new ColumnValue(3.14));
AttributeWith5Columns.Add("Col3", new ColumnValue(true));
AttributeWith5Columns.Add("Col4", new ColumnValue(new byte[] { 0x20, 0x20 }));
PrimaryKeyList = new List <PrimaryKey>();
AttributeColumnsList = new List <AttributeColumns>();
for (int i = 0; i < 1000; i++)
{
PrimaryKeyList.Add(GetPredefinedPrimaryKeyWith4PK(i));
AttributeColumnsList.Add(GetPredefinedAttributeWith5PK(i));
}
}
public void TestAPIWithParameter(string apiName)
{
var tableName = TestContext.tableName;
var pkSchema = TestContext.pkSchema;
var reservedThroughput = TestContext.reservedThroughput;
var primaryKey = TestContext.primaryKey;
var attribute = TestContext.attribute;
var condition = TestContext.condition;
var startPrimaryKey = TestContext.startPrimaryKey;
var endPrimaryKey = TestContext.endPrimaryKey;
var putRowConsumed = TestContext.putRowConsumed;
var getRowConsumed = TestContext.getRowConsumed;
var updateRowConsumed = TestContext.updateRowConsumed;
var deleteRowConsumed = TestContext.deleteRowConsumed;
var getRangeConsumed = TestContext.getRangeConsumed;
var updateOfAttributeForPut = TestContext.updateOfAttributeForPut;
var updateOfAttributeForDelete = TestContext.updateOfAttributeForDelete;
var columnsToGet = TestContext.columnsToGet;
var limit = TestContext.limit;
var direction = TestContext.direction;
var tableMeta = new TableMeta(tableName, pkSchema);
switch (apiName)
{
case "CreateTable":
var request0 = new CreateTableRequest(tableMeta, reservedThroughput);
OTSClient.CreateTable(request0);
return;
case "ListTable":
var request1 = new ListTableRequest();
var response1 = OTSClient.ListTable(request1);
Assert.AreEqual(new List <string>()
{
tableName
}, response1.TableNames);
return;
case "UpdateTable":
var request2 = new UpdateTableRequest(tableName, reservedThroughput);
var response2 = OTSClient.UpdateTable(request2);
if (reservedThroughput.Read.HasValue && reservedThroughput.Write.HasValue)
{
AssertCapacityUnit(
reservedThroughput,
response2.ReservedThroughputDetails.CapacityUnit);
}
Assert.IsTrue(response2.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "DeleteTable":
var request3 = new DeleteTableRequest(tableName);
OTSClient.DeleteTable(request3);
var request31 = new ListTableRequest();
var response31 = OTSClient.ListTable(request31);
Assert.AreEqual(new List <string>()
{
}, response31.TableNames);
return;
case "DescribeTable":
var request4 = new DescribeTableRequest(tableName);
var response4 = OTSClient.DescribeTable(request4);
Assert.AreEqual(tableName, response4.TableMeta.TableName);
AssertPrimaryKeySchema(pkSchema, response4.TableMeta.PrimaryKeySchema);
AssertCapacityUnit(reservedThroughput, response4.ReservedThroughputDetails.CapacityUnit);
Assert.IsTrue(response4.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "PutRow":
var request5 = new PutRowRequest(tableName, condition, primaryKey, attribute);
var response5 = OTSClient.PutRow(request5);
AssertCapacityUnit(putRowConsumed, response5.ConsumedCapacityUnit);
return;
case "GetRow":
var request6 = new GetRowRequest(tableName, primaryKey, columnsToGet);
var response6 = OTSClient.GetRow(request6);
AssertPrimaryKey(primaryKey, response6.PrimaryKey, columnsToGet);
AssertAttribute(attribute, response6.Attribute, columnsToGet);
AssertCapacityUnit(getRowConsumed, response6.ConsumedCapacityUnit);
return;
case "DeleteRow":
var request7 = new DeleteRowRequest(tableName, condition, primaryKey);
var response7 = OTSClient.DeleteRow(request7);
AssertCapacityUnit(deleteRowConsumed, response7.ConsumedCapacityUnit);
var request71 = new GetRowRequest(tableName, primaryKey);
var response71 = OTSClient.GetRow(request71);
AssertPrimaryKey(new PrimaryKey(), response71.PrimaryKey);
AssertAttribute(new AttributeColumns(), response71.Attribute);
return;
case "UpdateRow_Put":
var request8 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForPut);
var response8 = OTSClient.UpdateRow(request8);
AssertCapacityUnit(updateRowConsumed, response8.ConsumedCapacityUnit);
var request81 = new GetRowRequest(tableName, primaryKey);
var response81 = OTSClient.GetRow(request81);
AssertPrimaryKey(primaryKey, response81.PrimaryKey);
AssertAttribute(attribute, response81.Attribute);
AssertCapacityUnit(getRowConsumed, response81.ConsumedCapacityUnit);
return;
case "UpdateRow_Delete":
var request9 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForDelete);
var response9 = OTSClient.UpdateRow(request9);
AssertCapacityUnit(deleteRowConsumed, response9.ConsumedCapacityUnit);
var request91 = new GetRowRequest(tableName, primaryKey);
var response91 = OTSClient.GetRow(request91);
// Don't assert primary key
AssertAttribute(new AttributeColumns(), response91.Attribute);
return;
case "BatchGetRow":
var request11 = new BatchGetRowRequest();
request11.Add(tableName, new List <PrimaryKey>()
{
primaryKey
}, columnsToGet);
var response11 = OTSClient.BatchGetRow(request11);
Assert.AreEqual(1, response11.RowDataGroupByTable.Count);
Assert.IsTrue(response11.RowDataGroupByTable.ContainsKey(tableName));
Assert.AreEqual(1, response11.RowDataGroupByTable[tableName].Count);
if (!response11.RowDataGroupByTable[tableName][0].IsOK)
{
throw new OTSServerException(apiName, HttpStatusCode.OK,
response11.RowDataGroupByTable[tableName][0].ErrorCode,
response11.RowDataGroupByTable[tableName][0].ErrorMessage);
}
AssertPrimaryKey(primaryKey, response11.RowDataGroupByTable[tableName][0].PrimaryKey);
AssertAttribute(attribute, response11.RowDataGroupByTable[tableName][0].Attribute);
AssertCapacityUnit(getRowConsumed, response11.RowDataGroupByTable[tableName][0].Consumed);
return;
case "BatchWriteRow_Put":
var request12 = new BatchWriteRowRequest();
var rowChanges = new RowChanges();
rowChanges.AddPut(condition, primaryKey, attribute);
request12.Add(tableName, rowChanges);
var response12 = OTSClient.BatchWriteRow(request12);
Assert.AreEqual(1, response12.TableRespones.Count);
Assert.IsTrue(response12.TableRespones.ContainsKey(tableName));
Assert.AreEqual(1, response12.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].DeleteResponses.Count);
if (response12.TableRespones[tableName].PutResponses[0].IsOK)
{
AssertCapacityUnit(putRowConsumed,
response12.TableRespones[tableName].PutResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response12.TableRespones[tableName].PutResponses[0].ErrorCode,
response12.TableRespones[tableName].PutResponses[0].ErrorMessage);
}
var request121 = new GetRowRequest(tableName, primaryKey);
var response121 = OTSClient.GetRow(request121);
AssertPrimaryKey(primaryKey, response121.PrimaryKey);
AssertAttribute(attribute, response121.Attribute);
AssertCapacityUnit(getRowConsumed, response121.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Update":
var request13 = new BatchWriteRowRequest();
var rowChanges2 = new RowChanges();
rowChanges2.AddUpdate(condition, primaryKey, updateOfAttributeForPut);
request13.Add(tableName, rowChanges2);
var response13 = OTSClient.BatchWriteRow(request13);
Assert.AreEqual(1, response13.TableRespones.Count);
Assert.IsTrue(response13.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response13.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(1, response13.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response13.TableRespones[tableName].DeleteResponses.Count);
if (response13.TableRespones[tableName].UpdateResponses[0].IsOK)
{
AssertCapacityUnit(updateRowConsumed,
response13.TableRespones[tableName].UpdateResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response13.TableRespones[tableName].UpdateResponses[0].ErrorCode,
response13.TableRespones[tableName].UpdateResponses[0].ErrorMessage);
}
var request131 = new GetRowRequest(tableName, primaryKey);
var response131 = OTSClient.GetRow(request131);
AssertPrimaryKey(primaryKey, response131.PrimaryKey);
AssertAttribute(attribute, response131.Attribute);
AssertCapacityUnit(getRowConsumed, response131.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Delete":
var request14 = new BatchWriteRowRequest();
var rowChanges3 = new RowChanges();
rowChanges3.AddDelete(condition, primaryKey);
request14.Add(tableName, rowChanges3);
var response14 = OTSClient.BatchWriteRow(request14);
Assert.AreEqual(1, response14.TableRespones.Count);
Assert.IsTrue(response14.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response14.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response14.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(1, response14.TableRespones[tableName].DeleteResponses.Count);
if (response14.TableRespones[tableName].DeleteResponses[0].IsOK)
{
AssertCapacityUnit(deleteRowConsumed,
response14.TableRespones[tableName].DeleteResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response14.TableRespones[tableName].DeleteResponses[0].ErrorCode,
response14.TableRespones[tableName].DeleteResponses[0].ErrorMessage);
}
var request141 = new GetRowRequest(tableName, primaryKey);
var response141 = OTSClient.GetRow(request141);
AssertPrimaryKey(new PrimaryKey(), response141.PrimaryKey);
AssertAttribute(new AttributeColumns(), response141.Attribute);
return;
case "GetRange":
var request15 = new GetRangeRequest(tableName, direction,
startPrimaryKey, endPrimaryKey,
columnsToGet, limit);
var response15 = OTSClient.GetRange(request15);
Assert.AreEqual(1, response15.RowDataList.Count);
Assert.AreEqual(null, response15.NextPrimaryKey);
AssertCapacityUnit(getRangeConsumed, response15.ConsumedCapacityUnit);
AssertPrimaryKey(primaryKey, response15.RowDataList[0].PrimaryKey, columnsToGet);
AssertAttribute(attribute, response15.RowDataList[0].Attribute, columnsToGet);
return;
default:
throw new Exception(String.Format("invalid api name: {0}", apiName));
}
}
public static void DeleteTable(OTSClient otsClient)
{
DeleteTableRequest request = new DeleteTableRequest(TableName);
otsClient.DeleteTable(request);
}