public static void GetRow()
{
Console.WriteLine("Start get row...");
// PrepareTable();
OTSClient otsClient = Config.GetClient();
// 定义行的主键，必须与创建表时的TableMeta中定义的一致
PrimaryKey primaryKey = new PrimaryKey();
primaryKey.Add("key", new ColumnValue("the key"));
Stopwatch stopwatch = Stopwatch.StartNew();
GetRowRequest request = new GetRowRequest("tableName", primaryKey); // 未指定读哪列，默认读整行
GetRowResponse response = otsClient.GetRow(request);
stopwatch.Stop();
PrimaryKey primaryKeyRead = response.PrimaryKey;
AttributeColumns attributesRead = response.Attribute;
Console.WriteLine("Primary key read: ");
foreach (KeyValuePair <string, ColumnValue> entry in primaryKeyRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Attributes read: ");
foreach (KeyValuePair <string, ColumnValue> entry in attributesRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Get row succeed.");
Console.WriteLine(stopwatch.Elapsed);
}
private void Run()
{
for (int i = 0; i < round; ++i)
{
var primaryKey = new PrimaryKey();
primaryKey.Add("PK0", new ColumnValue(pk));
var request = new GetRowRequest(tableName, primaryKey);
var response = OTSClient.GetRow(request);
var attr = response.Attribute["Col1"];
long oldIntValue = attr.IntegerValue;
ColumnValue oldValue = new ColumnValue(oldIntValue);
ColumnValue newValue = new ColumnValue(oldIntValue + 1);
RelationalCondition cc = new RelationalCondition("Col1", RelationalCondition.CompareOperator.EQUAL, oldValue);
Condition cond = new Condition(RowExistenceExpectation.IGNORE);
cond.ColumnCondition = cc;
UpdateOfAttribute updateOfAttributeForPut = new UpdateOfAttribute();
updateOfAttributeForPut.AddAttributeColumnToPut("Col1", newValue);
UpdateRowRequest updateReq = new UpdateRowRequest(tableName, cond, primaryKey, updateOfAttributeForPut);
bool success = true;
try
{
OTSClient.UpdateRow(updateReq);
}
catch (OTSServerException)
{
success = false;
}
if (success)
{
++count;
}
}
}
public ActionResult SearchLocation()
{
OTSClient _oTSClient = OTSHelper.GetOTSClientLocation(_tableStoreModel);
PrimaryKey pk = new PrimaryKey();
pk.Add("d", new ColumnValue(Convert.ToInt64(Request.Form["d"])));
pk.Add("t", new ColumnValue(TimeHelper.ConvertDateTimeToInt(Convert.ToDateTime(Request.Form["t"]))));
GetRowRequest getRowRequest = new GetRowRequest("L_100000000", pk);
GetRowResponse response = _oTSClient.GetRow(getRowRequest);
StringBuilder sbAttributeColumns = new StringBuilder();
foreach (var item in response.Attribute)
{
if (item.Key == "l")
{
byte[] lbyte = item.Value.BinaryValue;
Dictionary <string, int> dictionary = ByteIntHelper.GetLocationByByte(lbyte);
foreach (var dic in dictionary)
{
sbAttributeColumns.Append(dic.Key + ":" + dic.Value + "； ");
}
}
}
ViewData["pk"] = "设备：" + Request.Form["d"] + " 时间：" + Request.Form["t"];
ViewData["att"] = sbAttributeColumns.ToString();
return(View("Search", ViewBag));
}
public void TestGetRowWith1000ColumnsToGet()
{
CreateTestTableWith4PK(new CapacityUnit(0, 0));
var columnsToGet = new HashSet <string>();
for (int i = 0; i < 1025; i++)
{
columnsToGet.Add("Col" + i);
}
var request = new GetRowRequest(TestTableName, PrimaryKeyWith4Columns, columnsToGet);
try {
OTSClient.GetRow(request);
Assert.Fail();
} catch (OTSServerException exception) {
AssertOTSServerException(new OTSServerException(
"/GetRow",
HttpStatusCode.BadRequest,
"OTSParameterInvalid",
"The number of columns from the request exceeds the limit, limit count: 1024, column count: 1025."
), exception);
}
}
/// <summary>
/// Get a single row from the table by primary key.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public GetRowResponse GetRow(GetRowRequest request)
{
var uriStr = $"{GetEndPoint(NoSQLServices.Tables, this.Region)}/{request.TableNameOrId}/rows";
var optional = request.GetOptionalQuery();
if (!string.IsNullOrEmpty(optional))
{
uriStr = $"{uriStr}?{optional}";
}
var uri = new Uri(uriStr);
var httpRequestHeaderParam = new HttpRequestHeaderParam()
{
OpcRequestId = request.OpcRequestId
};
using (var webResponse = this.RestClient.Get(uri, httpRequestHeaderParam))
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(new GetRowResponse()
{
Row = this.JsonSerializer.Deserialize <RowDetails>(response),
OpcRequestId = webResponse.Headers.Get("opc-request-id"),
Etag = webResponse.Headers.Get("opc-request-id")
});
}
}
public static void GetRow()
{
Console.WriteLine("Start get row...");
PrepareTable();
OTSClient otsClient = Config.GetClient();
// 定义行的主键，必须与创建表时的TableMeta中定义的一致
PrimaryKey primaryKey = new PrimaryKey
{
{ Pk1, new ColumnValue(0) },
{ Pk2, new ColumnValue("abc") }
};
GetRowRequest request = new GetRowRequest(TableName, primaryKey); // 未指定读哪列，默认读整行
GetRowResponse response = otsClient.GetRow(request);
PrimaryKey primaryKeyRead = response.PrimaryKey;
AttributeColumns attributesRead = response.Attribute;
Console.WriteLine("Primary key read: ");
foreach (KeyValuePair <string, ColumnValue> entry in primaryKeyRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Attributes read: ");
foreach (KeyValuePair <string, ColumnValue> entry in attributesRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Get row succeed.");
}
public void TestString()
{
CreateTestTable();
var primaryKey = new PrimaryKey();
primaryKey.Add("PK0", new ColumnValue("ABC"));
primaryKey.Add("PK1", new ColumnValue(123));
var attribute = new AttributeColumns();
attribute.Add("Col0", new ColumnValue("abcdefghijklnm"));
var request1 = new PutRowRequest(
"SampleTableName",
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
var response1 = OTSClient.PutRow(request1);
Assert.AreEqual(0, response1.ConsumedCapacityUnit.Read);
Assert.AreEqual(1, response1.ConsumedCapacityUnit.Write);
var request2 = new GetRowRequest(
"SampleTableName",
primaryKey
);
var response2 = OTSClient.GetRow(request2);
Assert.AreEqual(1, response2.ConsumedCapacityUnit.Read);
Assert.AreEqual(0, response2.ConsumedCapacityUnit.Write);
AssertColumns(primaryKey, response2.PrimaryKey);
AssertColumns(attribute, response2.Attribute);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetRowRequest request;
try
{
request = new GetRowRequest
{
TableNameOrId = TableNameOrId,
Key = Key,
CompartmentId = CompartmentId,
Consistency = Consistency,
TimeoutInMs = TimeoutInMs,
OpcRequestId = OpcRequestId
};
response = client.GetRow(request).GetAwaiter().GetResult();
WriteOutput(response, response.Row);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public void GetRow()
{
moq::Mock <TablesService.TablesServiceClient> mockGrpcClient = new moq::Mock <TablesService.TablesServiceClient>(moq::MockBehavior.Strict);
GetRowRequest request = new GetRowRequest
{
Name = "name1c9368b0",
};
Row expectedResponse = new Row
{
RowName = RowName.FromTableRow("[TABLE]", "[ROW]"),
Values =
{
{
"key8a0b6e3c",
new wkt::Value()
},
},
};
mockGrpcClient.Setup(x => x.GetRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
TablesServiceClient client = new TablesServiceClientImpl(mockGrpcClient.Object, null);
Row response = client.GetRow(request.Name);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async stt::Task GetRowAsync()
{
moq::Mock <TablesService.TablesServiceClient> mockGrpcClient = new moq::Mock <TablesService.TablesServiceClient>(moq::MockBehavior.Strict);
GetRowRequest request = new GetRowRequest
{
Name = "name1c9368b0",
};
Row expectedResponse = new Row
{
RowName = RowName.FromTableRow("[TABLE]", "[ROW]"),
Values =
{
{
"key8a0b6e3c",
new wkt::Value()
},
},
};
mockGrpcClient.Setup(x => x.GetRowAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Row>(stt::Task.FromResult(expectedResponse), null, null, null, null));
TablesServiceClient client = new TablesServiceClientImpl(mockGrpcClient.Object, null);
Row responseCallSettings = await client.GetRowAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Row responseCancellationToken = await client.GetRowAsync(request.Name, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public void GetTimeRangeRowTest()
{
CreateTable();
PutRow();
var otsClient = OTSClient;
var primaryKey = new PrimaryKey
{
{ "PK0", new ColumnValue("ABC") },
{ "PK1", new ColumnValue(123) }
};
// update row
var updateOfAttribute = new UpdateOfAttribute();
updateOfAttribute.AddAttributeColumnToPut("Col0", new ColumnValue("Beijing"));
var updateRowRequest = new UpdateRowRequest(
TestTableName,
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
updateOfAttribute);
var updateRowResponse = otsClient.UpdateRow(updateRowRequest);
var getRowRequest = new GetRowRequest(
TestTableName,
primaryKey
);
getRowRequest.QueryCriteria.TimeRange = new TimeRange
{
StartTime = 0,
EndTime = Int64.MaxValue
};
var getRowResponse = otsClient.GetRow(getRowRequest);
Console.WriteLine("GetRow CU Consumed: Read {0} Write {1}",
getRowResponse.ConsumedCapacityUnit.Read,
getRowResponse.ConsumedCapacityUnit.Write);
var pk0 = getRowResponse.PrimaryKey["PK0"];
Console.WriteLine("PrimaryKey PK0 Value {0}", pk0.StringValue);
var pk1 = getRowResponse.PrimaryKey["PK1"];
Console.WriteLine("PrimaryKey PK1 Value {0}", pk1.IntegerValue);
var row = getRowResponse.Row;
foreach (Column column in row.GetColumn("Col0"))
{
Console.WriteLine(column);
}
Assert.AreEqual(2, row.GetColumn("Col0").Count);
DeleteTable();
}
public void TestConditionExpectNotExist()
{
CreateTestTable();
var primaryKey = new PrimaryKey();
primaryKey.Add("PK0", new ColumnValue("ABC"));
primaryKey.Add("PK1", new ColumnValue(123));
var attribute = new AttributeColumns();
attribute.Add("Col0", new ColumnValue(new byte[] { 0x20, 0x21, 0x23, 0x24 }));
{
var request1 = new PutRowRequest(
"SampleTableName",
new Condition(RowExistenceExpectation.EXPECT_NOT_EXIST),
primaryKey,
attribute
);
var response1 = OTSClient.PutRow(request1);
Assert.AreEqual(1, response1.ConsumedCapacityUnit.Read);
Assert.AreEqual(1, response1.ConsumedCapacityUnit.Write);
var request2 = new GetRowRequest(
"SampleTableName",
primaryKey
);
var response2 = OTSClient.GetRow(request2);
Assert.AreEqual(1, response2.ConsumedCapacityUnit.Read);
Assert.AreEqual(0, response2.ConsumedCapacityUnit.Write);
AssertColumns(primaryKey, response2.PrimaryKey);
AssertColumns(attribute, response2.Attribute);
}
{
var request1 = new PutRowRequest(
"SampleTableName",
new Condition(RowExistenceExpectation.EXPECT_NOT_EXIST),
primaryKey,
attribute
);
try
{
OTSClient.PutRow(request1);
Assert.Fail();
}
catch (OTSServerException e)
{
Assert.AreEqual("/PutRow", e.APIName);
Assert.AreEqual(403, (int)e.HttpStatusCode);
Assert.AreEqual("OTSConditionCheckFail", e.ErrorCode);
Assert.AreEqual("Condition check failed.", e.ErrorMessage);
Assert.NotNull(e.RequestID);
}
}
}
public static void GetRowWithFilter()
{
Console.WriteLine("Start get row with filter ...");
PrepareTable();
OTSClient otsClient = Config.GetClient();
// 定义行的主键，必须与创建表时的TableMeta中定义的一致
PrimaryKey primaryKey = new PrimaryKey
{
{ "pk0", new ColumnValue(0) },
{ "pk1", new ColumnValue("abc") }
};
var rowQueryCriteria = new SingleRowQueryCriteria(TableName)
{
RowPrimaryKey = primaryKey
};
// 只返回col0的值等于5的行或者col1不等于ff的行
var filter1 = new RelationalCondition("col0",
CompareOperator.EQUAL,
new ColumnValue(5));
var filter2 = new RelationalCondition("col1", CompareOperator.NOT_EQUAL, new ColumnValue("ff"));
var filter = new CompositeCondition(LogicOperator.OR);
filter.AddCondition(filter1);
filter.AddCondition(filter2);
rowQueryCriteria.Filter = filter.ToFilter();
rowQueryCriteria.AddColumnsToGet("col0");
rowQueryCriteria.AddColumnsToGet("col1");
GetRowRequest request = new GetRowRequest(rowQueryCriteria);
// 查询
GetRowResponse response = otsClient.GetRow(request);
PrimaryKey primaryKeyRead = response.PrimaryKey;
AttributeColumns attributesRead = response.Attribute;
Console.WriteLine("Primary key read: ");
foreach (KeyValuePair <string, ColumnValue> entry in primaryKeyRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Attributes read: ");
foreach (KeyValuePair <string, ColumnValue> entry in attributesRead)
{
Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
}
Console.WriteLine("Get row with filter succeed.");
}
public void TestColumnsToGet()
{
CreateTable();
var primaryKey = new PrimaryKey
{
{ "PK0", new ColumnValue("ABC") },
{ "PK1", new ColumnValue(123) }
};
var attribute = new AttributeColumns
{
{ "Col0", new ColumnValue(123) },
{ "Col1", new ColumnValue("ABC") },
{ "Col2", new ColumnValue(new byte[] { 0x20, 0x21, 0x23, 0x24 }) }
};
var request1 = new PutRowRequest(
TestTableName,
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
var response1 = OTSClient.PutRow(request1);
Assert.AreEqual(0, response1.ConsumedCapacityUnit.Read);
Assert.AreEqual(1, response1.ConsumedCapacityUnit.Write);
var request2 = new GetRowRequest(
TestTableName,
primaryKey,
new HashSet <string>()
{
"Col0", "Col2"
}
);
var response2 = OTSClient.GetRow(request2);
Assert.AreEqual(1, response2.ConsumedCapacityUnit.Read);
Assert.AreEqual(0, response2.ConsumedCapacityUnit.Write);
AssertColumns(primaryKey, response2.PrimaryKey);
var attributeToExpect = new AttributeColumns
{
{ "Col0", new ColumnValue(123) },
{ "Col2", new ColumnValue(new byte[] { 0x20, 0x21, 0x23, 0x24 }) }
};
AssertColumns(attributeToExpect, response2.Attribute);
DeleteTable();
}
public void GetRowTest()
{
CreateTable();
var otsClient = OTSClient;
var primaryKey = new PrimaryKey();
primaryKey.Add("PK0", new ColumnValue("ABC"));
primaryKey.Add("PK1", new ColumnValue(123));
var attribute = new AttributeColumns();
attribute.Add("IntAttr0", new ColumnValue(12345));
attribute.Add("StringAttr1", new ColumnValue("ABC"));
attribute.Add("DoubleAttr2", new ColumnValue(3.14));
attribute.Add("BooleanAttr3", new ColumnValue(true));
var putRowRequest = new PutRowRequest(
"SampleTable",
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
var putRowResponse = otsClient.PutRow(putRowRequest);
var getRowRequest = new GetRowRequest(
"SampleTable",
primaryKey
);
var getRowResponse = otsClient.GetRow(getRowRequest);
System.Console.WriteLine("GetRow CU Consumed: Read {0} Write {0}",
getRowResponse.ConsumedCapacityUnit.Read,
getRowResponse.ConsumedCapacityUnit.Write);
var pk0 = getRowResponse.PrimaryKey["PK0"];
System.Console.WriteLine("PrimaryKey PK0 Value {0}", pk0.StringValue);
var pk1 = getRowResponse.PrimaryKey["PK1"];
System.Console.WriteLine("PrimaryKey PK1 Value {0}", pk1.IntegerValue);
var attr0 = getRowResponse.Attribute["IntAttr0"];
System.Console.WriteLine("Attribute IntAttr0 Value {0}", attr0.IntegerValue);
var attr1 = getRowResponse.Attribute["StringAttr1"];
System.Console.WriteLine("Attribute StringAttr1 Value {0}", attr1.StringValue);
var attr2 = getRowResponse.Attribute["DoubleAttr2"];
System.Console.WriteLine("Attribute DoubleAttr2 Value {0}", attr2.DoubleValue);
var attr3 = getRowResponse.Attribute["BooleanAttr3"];
System.Console.WriteLine("Attribute BooleanAttr3 Value {0}", attr2.BooleanValue);
DeleteTable();
}
public long ReadRow(String tableName, Int64 pk)
{
var primaryKey = new PrimaryKey();
primaryKey.Add("PK0", new ColumnValue(pk));
var request = new GetRowRequest(tableName, primaryKey);
var response = OTSClient.GetRow(request);
var attr = response.Attribute["Col1"];
long value = attr.IntegerValue;
return(value);
}
public void TestEmptyPrimaryKey()
{
CreateTable();
var primaryKey = new PrimaryKey();
var attribute = new AttributeColumns
{
{ "Col0", new ColumnValue(true) }
};
var request1 = new PutRowRequest(
TestTableName,
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
try
{
OTSClient.PutRow(request1);
Assert.Fail();
}
catch (OTSServerException e)
{
Assert.AreEqual("/PutRow", e.APIName);
Assert.AreEqual(400, (int)e.HttpStatusCode);
Assert.AreEqual("OTSParameterInvalid", e.ErrorCode);
Assert.AreEqual("Cell data broken, empty PK.", e.ErrorMessage);
Assert.NotNull(e.RequestID);
}
var request2 = new GetRowRequest(
TestTableName,
primaryKey
);
try
{
OTSClient.GetRow(request2);
Assert.Fail();
}
catch (OTSServerException e)
{
Assert.AreEqual("/GetRow", e.APIName);
Assert.AreEqual(400, (int)e.HttpStatusCode);
Assert.AreEqual("OTSParameterInvalid", e.ErrorCode);
Assert.AreEqual("Cell data broken, empty PK.", e.ErrorMessage);
Assert.NotNull(e.RequestID);
}
DeleteTable();
}
/// <summary>Snippet for GetRow</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetRowRequestObject()
{
// Create client
TablesServiceClient tablesServiceClient = TablesServiceClient.Create();
// Initialize request argument(s)
GetRowRequest request = new GetRowRequest
{
RowName = RowName.FromTableRow("[TABLE]", "[ROW]"),
View = View.Unspecified,
};
// Make the request
Row response = tablesServiceClient.GetRow(request);
}
public void TestAsyncOperations()
{
var clientConfig = new OTSClientConfig(
TestEndPoint,
TestAccessKeyID,
TestAccessKeySecret,
TestInstanceName
);
clientConfig.OTSDebugLogHandler = null;
clientConfig.OTSErrorLogHandler = null;
OTSClient = new OTSClient(clientConfig);
OTSClientTestHelper.Reset();
CreateTestTableWith4PK(new CapacityUnit(0, 0));
var putRowTaskList = new List <Task <PutRowResponse> >();
for (int i = 0; i < 1000; i++)
{
var request = new PutRowRequest(TestTableName, new Condition(RowExistenceExpectation.IGNORE),
GetPredefinedPrimaryKeyWith4PK(i),
GetPredefinedAttributeWith5PK(i));
putRowTaskList.Add(OTSClient.PutRowAsync(request));
}
foreach (var task in putRowTaskList)
{
task.Wait();
AssertCapacityUnit(new CapacityUnit(0, 1), task.Result.ConsumedCapacityUnit);
}
var getRowTaskList = new List <Task <GetRowResponse> >();
for (int i = 0; i < 1000; i++)
{
var request = new GetRowRequest(TestTableName,
GetPredefinedPrimaryKeyWith4PK(i));
getRowTaskList.Add(OTSClient.GetRowAsync(request));
}
for (int i = 0; i < 1000; i++)
{
var task = getRowTaskList[i];
task.Wait();
var response = task.Result;
AssertCapacityUnit(new CapacityUnit(1, 0), response.ConsumedCapacityUnit);
AssertPrimaryKey(GetPredefinedPrimaryKeyWith4PK(i), response.PrimaryKey);
AssertAttribute(GetPredefinedAttributeWith5PK(i), response.Attribute);
}
}
public ActionResult SearchRoute()
{
OTSClient _oTSClient = OTSHelper.GetOTSClientRoute(_tableStoreModel);
PrimaryKey pk = new PrimaryKey();
pk.Add("d", new ColumnValue(Convert.ToInt64(Request.Form["d"])));
pk.Add("s", new ColumnValue(TimeHelper.ConvertDateTimeToInt(Convert.ToDateTime(Request.Form["s"]))));
GetRowRequest getRowRequest = new GetRowRequest("Route", pk);
GetRowResponse response = _oTSClient.GetRow(getRowRequest);
StringBuilder sbAttributeColumns = new StringBuilder();
foreach (var item in response.Attribute)
{
switch (item.Key)
{
case "e":
sbAttributeColumns.Append(item.Key + ":" + item.Value.IntegerValue + "【" + TimeHelper.ConvertStringToDateTime(item.Value.IntegerValue.ToString()).ToString("yyyy-MM-dd HH:mm:ss fff") + "】;");
break;
case "r":
byte[] lbyte = item.Value.BinaryValue;
Dictionary <string, int> dictionary = ByteIntHelper.GetRouteByByte(lbyte);
foreach (var dic in dictionary)
{
sbAttributeColumns.Append(dic.Key + ":" + dic.Value + "； ");
}
break;
case "ds":
byte[] ds = item.Value.BinaryValue;
Dictionary <string, int> dsDic = ByteIntHelper.GetDurationstatsByByte(ds);
foreach (var dic in dsDic)
{
sbAttributeColumns.Append(dic.Key + ":" + dic.Value + "； ");
}
break;
case "es":
byte[] es = item.Value.BinaryValue;
Dictionary <string, int> esDic = ByteIntHelper.GetEventStatsByByte(es);
foreach (var dic in esDic)
{
sbAttributeColumns.Append(dic.Key + ":" + dic.Value + "； ");
}
break;
}
}
ViewData["pk"] = "设备：" + Request.Form["d"] + " 开始时间：" + Request.Form["s"];
ViewData["att"] = sbAttributeColumns.ToString();
return(View("Search", ViewBag));
}
public void CheckSingleRow(string tableName, PrimaryKey primaryKey,
AttributeColumns attribute,
CapacityUnit expectCapacityUnitConsumed = null,
HashSet <string> columnsToGet = null,
bool isEmpty = false,
ColumnCondition condition = null)
{
var request = new GetRowRequest(tableName, primaryKey, columnsToGet, condition);
var response = OTSClient.GetRow(request);
PrimaryKey primaryKeyToExpect;
AttributeColumns attributeToExpect;
if (isEmpty)
{
primaryKeyToExpect = new PrimaryKey();
attributeToExpect = new AttributeColumns();
}
else if (columnsToGet == null || columnsToGet.Count == 0)
{
primaryKeyToExpect = primaryKey;
attributeToExpect = attribute;
}
else
{
primaryKeyToExpect = new PrimaryKey();
attributeToExpect = new AttributeColumns();
foreach (var columnName in columnsToGet)
{
if (primaryKey.ContainsKey(columnName))
{
primaryKeyToExpect.Add(columnName, primaryKey[columnName]);
}
if (attribute.ContainsKey(columnName))
{
attributeToExpect.Add(columnName, attribute[columnName]);
}
}
}
AssertColumns(primaryKeyToExpect, response.PrimaryKey);
AssertColumns(attributeToExpect, response.Attribute);
if (expectCapacityUnitConsumed != null)
{
AssertCapacityUnit(expectCapacityUnitConsumed, response.ConsumedCapacityUnit);
}
}
/// <summary>Snippet for GetRow</summary>
public void GetRowRequestObject()
{
// Snippet: GetRow(GetRowRequest, CallSettings)
// Create client
TablesServiceClient tablesServiceClient = TablesServiceClient.Create();
// Initialize request argument(s)
GetRowRequest request = new GetRowRequest
{
Name = "",
View = View.Unspecified,
};
// Make the request
Row response = tablesServiceClient.GetRow(request);
// End snippet
}
private void GetRow(OTSClient client, String tableName)
{
var primaryKey = new PrimaryKey();
primaryKey.Add(COLUMN_GID_NAME, new ColumnValue(1));
primaryKey.Add(COLUMN_UID_NAME, new ColumnValue(101));
var request = new GetRowRequest(tableName, primaryKey);
var response = OTSClient.GetRow(request);
String name = response.Attribute[COLUMN_NAME_NAME].StringValue;
String addr = response.Attribute[COLUMN_ADDRESS_NAME].StringValue;
long age = response.Attribute[COLUMN_AGE_NAME].IntegerValue;
Console.WriteLine("本次读取name信息:{0}", name);
Console.WriteLine("本次读取addr信息:{0}", addr);
Console.WriteLine("本次读取age信息: {0}", age);
}
public void TestEmptyPrimaryKey()
{
var primaryKey = new PrimaryKey();
var attribute = new AttributeColumns();
attribute.Add("Col0", new ColumnValue(true));
var request1 = new PutRowRequest(
"SampleTableName",
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
try
{
OTSClient.PutRow(request1);
Assert.Fail();
}
catch (OTSServerException e)
{
Assert.AreEqual("/PutRow", e.APIName);
Assert.AreEqual(400, (int)e.HttpStatusCode);
Assert.AreEqual("OTSParameterInvalid", e.ErrorCode);
Assert.AreEqual("The number of primary key columns must be in range: [1, 4].", e.ErrorMessage);
Assert.NotNull(e.RequestID);
}
var request2 = new GetRowRequest(
"SampleTableName",
primaryKey
);
try
{
OTSClient.GetRow(request2);
Assert.Fail();
}
catch (OTSServerException e)
{
Assert.AreEqual("/GetRow", e.APIName);
Assert.AreEqual(400, (int)e.HttpStatusCode);
Assert.AreEqual("OTSParameterInvalid", e.ErrorCode);
Assert.AreEqual("The number of primary key columns must be in range: [1, 4].", e.ErrorMessage);
Assert.NotNull(e.RequestID);
}
}
/// <summary>Snippet for GetRowAsync</summary>
public async Task GetRowRequestObjectAsync()
{
// Snippet: GetRowAsync(GetRowRequest, CallSettings)
// Additional: GetRowAsync(GetRowRequest, CancellationToken)
// Create client
TablesServiceClient tablesServiceClient = await TablesServiceClient.CreateAsync();
// Initialize request argument(s)
GetRowRequest request = new GetRowRequest
{
Name = "",
View = View.Unspecified,
};
// Make the request
Row response = await tablesServiceClient.GetRowAsync(request);
// End snippet
}
public void GetRowTest()
{
CreateTable();
PutRow();
var otsClient = OTSClient;
var primaryKey = new PrimaryKey
{
{ "PK0", new ColumnValue("ABC") },
{ "PK1", new ColumnValue(123) }
};
var getRowRequest = new GetRowRequest(
TestTableName,
primaryKey
);
getRowRequest.QueryCriteria.MaxVersions = 1;
var getRowResponse = otsClient.GetRow(getRowRequest);
Console.WriteLine("GetRow CU Consumed: Read {0} Write {1}",
getRowResponse.ConsumedCapacityUnit.Read,
getRowResponse.ConsumedCapacityUnit.Write);
var pk0 = getRowResponse.PrimaryKey["PK0"];
Console.WriteLine("PrimaryKey PK0 Value {0}", pk0.StringValue);
var pk1 = getRowResponse.PrimaryKey["PK1"];
Console.WriteLine("PrimaryKey PK1 Value {0}", pk1.IntegerValue);
var attr0 = getRowResponse.Attribute["Col0"];
Console.WriteLine("Attribute Col0 Value {0}", attr0.StringValue);
var attr1 = getRowResponse.Attribute["Col1"];
Console.WriteLine("Attribute Col1 Value {0}", attr1.BooleanValue);
var attr2 = getRowResponse.Attribute["Col2"];
Console.WriteLine("Attribute Col2 Value {0}", attr2.DoubleValue);
DeleteTable();
}
public void TestDouble()
{
CreateTable();
var primaryKey = new PrimaryKey
{
{ "PK0", new ColumnValue("ABC") },
{ "PK1", new ColumnValue(123) }
};
var attribute = new AttributeColumns
{
{ "Col0", new ColumnValue(123.321) }
};
var request1 = new PutRowRequest(
TestTableName,
new Condition(RowExistenceExpectation.IGNORE),
primaryKey,
attribute
);
var response1 = OTSClient.PutRow(request1);
Assert.AreEqual(0, response1.ConsumedCapacityUnit.Read);
Assert.AreEqual(1, response1.ConsumedCapacityUnit.Write);
var request2 = new GetRowRequest(
TestTableName,
primaryKey
);
var response2 = OTSClient.GetRow(request2);
Assert.AreEqual(1, response2.ConsumedCapacityUnit.Read);
Assert.AreEqual(0, response2.ConsumedCapacityUnit.Write);
AssertColumns(primaryKey, response2.PrimaryKey);
AssertColumns(attribute, response2.Attribute);
DeleteTable();
}
public ActionResult SearchEvent()
{
OTSClient _oTSClient = OTSHelper.GetOTSClientEvent(_tableStoreModel);
PrimaryKey pk = new PrimaryKey();
pk.Add("d", new ColumnValue(Convert.ToInt64(Request.Form["d"])));
pk.Add("et", new ColumnValue(TimeHelper.ConvertDateTimeToInt(Convert.ToDateTime(Request.Form["et"]))));
pk.Add("ei", new ColumnValue(ByteIntHelper.intToBytes2(Convert.ToInt64(Request.Form["ei"]), 1)));
GetRowRequest getRowRequest = new GetRowRequest("E_100000000", pk);
GetRowResponse response = _oTSClient.GetRow(getRowRequest);
StringBuilder sbAttributeColumns = new StringBuilder();
foreach (var item in response.Attribute)
{
switch (item.Key)
{
case "ep":
//事件参数字段暂不做处理
//byte[] ep = item.Value.BinaryValue;
break;
case "t":
sbAttributeColumns.Append(item.Key + ":" + item.Value.IntegerValue + "【" + TimeHelper.ConvertStringToDateTime(item.Value.IntegerValue.ToString()).ToString("yyyy-MM-dd HH:mm:ss fff") + "】；");
break;
case "l":
byte[] lbyte = item.Value.BinaryValue;
Dictionary <string, int> dictionary = ByteIntHelper.GetLocationByByte(lbyte);
foreach (var dic in dictionary)
{
sbAttributeColumns.Append(dic.Key + ":" + dic.Value + "； ");
}
break;
}
}
ViewData["pk"] = "设备：" + Request.Form["d"] + " 事件时间：" + Request.Form["et"] + " 事件ID：" + Request.Form["ei"];
ViewData["att"] = sbAttributeColumns.ToString();
return(View("Search", ViewBag));
}
public static Dictionary <string, string> GetAppKey(string keyname)
{
GetClient();
Dictionary <string, string> keyValues = new Dictionary <string, string>();
PrimaryKey primaryKey = new PrimaryKey();
primaryKey.Add("KeyName", new ColumnValue(keyname));
try
{
var request = new GetRowRequest("Appkey", primaryKey);
var response = OtsClient.GetRow(request);
var columns = response.Columns;
foreach (var q in columns)
{
keyValues[q.Name] = PrintColumnValue(q.Value);
}
return(keyValues);
}
catch (Exception ex)
{
Crashes.TrackError(ex);
return(null);
}
}
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));
}
}
