public static void GetRange()
        {
            Console.WriteLine("Start get range...");

            PrepareTable();
            PrepareData();

            OTSClient otsClient = Config.GetClient();
            // 读取 (0, INF_MIN)到(100, INF_MAX)这个范围内的所有行
            PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey();

            inclusiveStartPrimaryKey.Add("pk0", new ColumnValue(0));
            inclusiveStartPrimaryKey.Add("pk1", ColumnValue.INF_MIN);

            PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey();

            exclusiveEndPrimaryKey.Add("pk0", new ColumnValue(100));
            exclusiveEndPrimaryKey.Add("pk1", ColumnValue.INF_MAX);
            GetRangeRequest request = new GetRangeRequest(TableName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);

            GetRangeResponse            response = otsClient.GetRange(request);
            IList <RowDataFromGetRange> rows     = response.RowDataList;
            PrimaryKey nextStartPrimaryKey       = response.NextPrimaryKey;

            while (nextStartPrimaryKey != null)
            {
                request             = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
                response            = otsClient.GetRange(request);
                nextStartPrimaryKey = response.NextPrimaryKey;
                foreach (RowDataFromGetRange row in response.RowDataList)
                {
                    rows.Add(row);
                }
            }

            foreach (RowDataFromGetRange row in rows)
            {
                Console.WriteLine("-----------------");
                foreach (KeyValuePair <string, ColumnValue> entry in row.PrimaryKey)
                {
                    Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
                }
                foreach (KeyValuePair <string, ColumnValue> entry in row.Attribute)
                {
                    Console.WriteLine(entry.Key + ":" + PrintColumnValue(entry.Value));
                }
                Console.WriteLine("-----------------");
            }

            Console.WriteLine("TotalRowsRead: " + rows.Count);
        }
        public static void GetRange()
        {
            Console.WriteLine("Start get range...");

            PrepareTable();
            PrepareData();

            OTSClient otsClient = Config.GetClient();
            // 读取 (0, INF_MIN)到(100, INF_MAX)这个范围内的所有行
            PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey
            {
                { "pk0", new ColumnValue(0) },
                { "pk1", ColumnValue.INF_MIN }
            };

            PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey
            {
                { "pk0", new ColumnValue(100) },
                { "pk1", ColumnValue.INF_MAX }
            };

            GetRangeRequest request = new GetRangeRequest(TableName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);

            GetRangeResponse response            = otsClient.GetRange(request);
            IList <Row>      rows                = response.RowDataList;
            PrimaryKey       nextStartPrimaryKey = response.NextPrimaryKey;

            while (nextStartPrimaryKey != null)
            {
                request             = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
                response            = otsClient.GetRange(request);
                nextStartPrimaryKey = response.NextPrimaryKey;
                foreach (var row in response.RowDataList)
                {
                    rows.Add(row);
                }
            }

            foreach (var row in rows)
            {
                PrintRow(row);
            }

            Console.WriteLine("TotalRowsRead: " + rows.Count);
        }
Example #3
0
        /// <summary>
        /// 从索引表中读取数据
        /// </summary>
        public static void GetRangeFromIndexTable()
        {
            Console.WriteLine("Start getRange from index...");
            OTSClient otsClient = Config.GetClient();
            // 指定第一主键Col1的值,进行扫描
            PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey
            {
                { Col1, new ColumnValue("Col1Value") },
                { Pk1, ColumnValue.INF_MIN },
                { Pk2, ColumnValue.INF_MIN }
            };

            PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey
            {
                { Col1, new ColumnValue("Col1Value") },
                { Pk1, ColumnValue.INF_MAX },
                { Pk2, ColumnValue.INF_MAX }
            };

            GetRangeRequest request = new GetRangeRequest(IndexName, GetRangeDirection.Forward, inclusiveStartPrimaryKey, exclusiveEndPrimaryKey);

            GetRangeResponse response            = otsClient.GetRange(request);
            IList <Row>      rows                = response.RowDataList;
            PrimaryKey       nextStartPrimaryKey = response.NextPrimaryKey;

            while (nextStartPrimaryKey != null)
            {
                request             = new GetRangeRequest(TableName, GetRangeDirection.Forward, nextStartPrimaryKey, exclusiveEndPrimaryKey);
                response            = otsClient.GetRange(request);
                nextStartPrimaryKey = response.NextPrimaryKey;
                foreach (var row in response.RowDataList)
                {
                    rows.Add(row);
                }
            }

            foreach (var row in rows)
            {
                PrintRow(row);
            }

            Console.WriteLine("TotalRowsRead: " + rows.Count);
        }
        public static void GetRangeWithFilter()
        {
            Console.WriteLine("Start get range with filter ...");
            PrepareTable();
            PrepareData();

            OTSClient otsClient = Config.GetClient();
            // 读取 (0, INF_MIN)到(100, INF_MAX)这个范围内的所有行,且col2等于false的行
            PrimaryKey inclusiveStartPrimaryKey = new PrimaryKey
            {
                { "pk0", new ColumnValue(0) },
                { "pk1", ColumnValue.INF_MIN }
            };

            PrimaryKey exclusiveEndPrimaryKey = new PrimaryKey
            {
                { "pk0", new ColumnValue(100) },
                { "pk1", ColumnValue.INF_MAX }
            };

            // 构造列过滤条件
            var condition = new RelationalCondition("col2",
                                                    CompareOperator.EQUAL,
                                                    new ColumnValue(false));

            var queryCriteria = new RangeRowQueryCriteria(TableName)
            {
                Direction = GetRangeDirection.Forward,
                InclusiveStartPrimaryKey = inclusiveStartPrimaryKey,
                ExclusiveEndPrimaryKey   = exclusiveEndPrimaryKey,
                Filter = condition.ToFilter()
            };

            GetRangeResponse response            = otsClient.GetRange(new GetRangeRequest(queryCriteria));
            IList <Row>      rows                = response.RowDataList;
            PrimaryKey       nextStartPrimaryKey = response.NextPrimaryKey;

            while (nextStartPrimaryKey != null)
            {
                queryCriteria = new RangeRowQueryCriteria(TableName)
                {
                    Direction = GetRangeDirection.Forward,
                    InclusiveStartPrimaryKey = nextStartPrimaryKey,
                    ExclusiveEndPrimaryKey   = exclusiveEndPrimaryKey,
                    Filter = condition.ToFilter()
                };

                response            = otsClient.GetRange(new GetRangeRequest(queryCriteria));
                nextStartPrimaryKey = response.NextPrimaryKey;
                foreach (var row in response.RowDataList)
                {
                    rows.Add(row);
                }
            }

            foreach (var row in rows)
            {
                PrintRow(row);
            }

            Console.WriteLine("TotalRowsRead with filter: " + rows.Count);
        }
        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));
            }
        }