public void MutateRowAsync()
        {
            MutateRowRequest mutateRowRequest = new MutateRowRequest
            {
                TableName = TableName,
                RowKey    = ByteString.CopyFromUtf8(RowKey),
            };

            Mutation mutation = new Mutation
            {
                SetCell = new Mutation.Types.SetCell
                {
                    FamilyName      = ColumnFamily,
                    ColumnQualifier = ByteString.CopyFromUtf8(ColumnQualifier),
                    Value           = ByteString.CopyFromUtf8(TestValue),
                }
            };

            mutateRowRequest.Mutations.Add(mutation);

            AsyncUnaryCall <MutateRowResponse> call = client.MutateRowAsync(mutateRowRequest);
            var channelRefs = invoker.GetChannelRefsForTest();

            Assert.AreEqual(1, channelRefs.Count);
            Assert.AreEqual(1, channelRefs[0].ActiveStreamCount);

            MutateRowResponse response = call.ResponseAsync.Result;

            channelRefs = invoker.GetChannelRefsForTest();
            Assert.AreEqual(0, channelRefs[0].ActiveStreamCount);
        }
Beispiel #2
0
 /// <summary>Snippet for MutateRow</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void MutateRow1()
 {
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     string                 tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
     ByteString             rowKey    = ByteString.Empty;
     IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(tableName, rowKey, mutations);
 }
 /// <summary>Snippet for MutateRow</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void MutateRow1ResourceNames()
 {
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     TableName              tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
     ByteString             rowKey    = ByteString.Empty;
     IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(tableName, rowKey, mutations);
 }
 public void MutateRow()
 {
     // Snippet: MutateRow(string,ByteString,IEnumerable<Mutation>,CallSettings)
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     string                 formattedTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]").ToString();
     ByteString             rowKey             = ByteString.CopyFromUtf8("");
     IEnumerable <Mutation> mutations          = new List <Mutation>();
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(formattedTableName, rowKey, mutations);
     // End snippet
 }
        /// <summary>Snippet for MutateRowAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task MutateRow2Async()
        {
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            string                 tableName    = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
            ByteString             rowKey       = ByteString.Empty;
            IEnumerable <Mutation> mutations    = new Mutation[] { new Mutation(), };
            string                 appProfileId = "";
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(tableName, rowKey, mutations, appProfileId);
        }
 /// <summary>Snippet for MutateRow</summary>
 public void MutateRow()
 {
     // Snippet: MutateRow(TableName,ByteString,IEnumerable<Mutation>,CallSettings)
     // Create client
     BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create();
     // Initialize request argument(s)
     TableName              tableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]");
     ByteString             rowKey    = ByteString.Empty;
     IEnumerable <Mutation> mutations = new List <Mutation>();
     // Make the request
     MutateRowResponse response = bigtableServiceApiClient.MutateRow(tableName, rowKey, mutations);
     // End snippet
 }
Beispiel #7
0
        /// <summary>Snippet for MutateRowAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task MutateRow2ResourceNamesAsync()
        {
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            TableName              tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
            ByteString             rowKey    = ByteString.Empty;
            IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
            string appProfileId = "";
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(tableName, rowKey, mutations, appProfileId);
        }
Beispiel #8
0
 /// <summary>Snippet for MutateRow</summary>
 public void MutateRow2ResourceNames()
 {
     // Snippet: MutateRow(TableName, ByteString, IEnumerable<Mutation>, string, CallSettings)
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     TableName              tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
     ByteString             rowKey    = ByteString.Empty;
     IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
     string appProfileId = "";
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(tableName, rowKey, mutations, appProfileId);
     // End snippet
 }
Beispiel #9
0
 /// <summary>Snippet for MutateRow</summary>
 public void MutateRow2()
 {
     // Snippet: MutateRow(string, ByteString, IEnumerable<Mutation>, string, CallSettings)
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     string                 tableName    = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
     ByteString             rowKey       = ByteString.Empty;
     IEnumerable <Mutation> mutations    = new Mutation[] { new Mutation(), };
     string                 appProfileId = "";
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(tableName, rowKey, mutations, appProfileId);
     // End snippet
 }
Beispiel #10
0
 /// <summary>Snippet for MutateRowAsync</summary>
 public async Task MutateRowAsync()
 {
     // Snippet: MutateRowAsync(TableName,ByteString,IEnumerable<Mutation>,CallSettings)
     // Additional: MutateRowAsync(TableName,ByteString,IEnumerable<Mutation>,CancellationToken)
     // Create client
     BigtableServiceApiClient bigtableServiceApiClient = await BigtableServiceApiClient.CreateAsync();
     // Initialize request argument(s)
     TableName tableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]");
     ByteString rowKey = ByteString.Empty;
     IEnumerable<Mutation> mutations = new List<Mutation>();
     // Make the request
     MutateRowResponse response = await bigtableServiceApiClient.MutateRowAsync(tableName, rowKey, mutations);
     // End snippet
 }
Beispiel #11
0
 /// <summary>Snippet for MutateRow</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void MutateRowRequestObject()
 {
     // Create client
     BigtableClient bigtableClient = BigtableClient.Create();
     // Initialize request argument(s)
     MutateRowRequest request = new MutateRowRequest
     {
         TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
         RowKey       = ByteString.Empty,
         Mutations    = { new Mutation(), },
         AppProfileId = "",
     };
     // Make the request
     MutateRowResponse response = bigtableClient.MutateRow(request);
 }
Beispiel #12
0
        /// <summary>Snippet for MutateRowAsync</summary>
        public async Task MutateRow1ResourceNamesAsync()
        {
            // Snippet: MutateRowAsync(TableName, ByteString, IEnumerable<Mutation>, CallSettings)
            // Additional: MutateRowAsync(TableName, ByteString, IEnumerable<Mutation>, CancellationToken)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            TableName              tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
            ByteString             rowKey    = ByteString.Empty;
            IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(tableName, rowKey, mutations);

            // End snippet
        }
Beispiel #13
0
        /// <summary>Snippet for MutateRowAsync</summary>
        public async Task MutateRow1Async()
        {
            // Snippet: MutateRowAsync(string, ByteString, IEnumerable<Mutation>, CallSettings)
            // Additional: MutateRowAsync(string, ByteString, IEnumerable<Mutation>, CancellationToken)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            string                 tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
            ByteString             rowKey    = ByteString.Empty;
            IEnumerable <Mutation> mutations = new Mutation[] { new Mutation(), };
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(tableName, rowKey, mutations);

            // End snippet
        }
 /// <summary>Snippet for MutateRow</summary>
 public void MutateRow_RequestObject()
 {
     // Snippet: MutateRow(MutateRowRequest,CallSettings)
     // Create client
     BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create();
     // Initialize request argument(s)
     MutateRowRequest request = new MutateRowRequest
     {
         TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
         RowKey    = ByteString.Empty,
         Mutations = { },
     };
     // Make the request
     MutateRowResponse response = bigtableServiceApiClient.MutateRow(request);
     // End snippet
 }
Beispiel #15
0
 /// <summary>Snippet for MutateRowAsync</summary>
 public async Task MutateRowAsync_RequestObject()
 {
     // Snippet: MutateRowAsync(MutateRowRequest,CallSettings)
     // Additional: MutateRowAsync(MutateRowRequest,CancellationToken)
     // Create client
     BigtableServiceApiClient bigtableServiceApiClient = await BigtableServiceApiClient.CreateAsync();
     // Initialize request argument(s)
     MutateRowRequest request = new MutateRowRequest
     {
         TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
         RowKey = ByteString.Empty,
         Mutations = { },
     };
     // Make the request
     MutateRowResponse response = await bigtableServiceApiClient.MutateRowAsync(request);
     // End snippet
 }
        public async Task MutateRowAsync_RequestObject()
        {
            // Snippet: MutateRowAsync(MutateRowRequest,CallSettings)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            MutateRowRequest request = new MutateRowRequest
            {
                TableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]").ToString(),
                RowKey    = ByteString.CopyFromUtf8(""),
                Mutations = { },
            };
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(request);

            // End snippet
        }
        public void MutateRow2()
        {
            Mock <Bigtable.BigtableClient> mockGrpcClient = new Mock <Bigtable.BigtableClient>(MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = ByteString.CopyFromUtf8("122"),
                Mutations = { },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse();

            mockGrpcClient.Setup(x => x.MutateRow(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            BigtableServiceApiClient client   = new BigtableServiceApiClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse        response = client.MutateRow(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateRow1()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Mutations = { new Mutation(), },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse {
            };

            mockGrpcClient.Setup(x => x.MutateRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigtableClient    client   = new BigtableClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse response = client.MutateRow(request.TableName, request.RowKey, request.Mutations);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateRowRequestObject()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = new gcbcv::TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey       = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Mutations    = { new Mutation(), },
                AppProfileId = "app_profile_id57fb0442",
            };
            MutateRowResponse expectedResponse = new MutateRowResponse {
            };

            mockGrpcClient.Setup(x => x.MutateRow(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            BigtableServiceApiClient client   = new BigtableServiceApiClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse        response = client.MutateRow(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Beispiel #20
0
        /// <summary>Snippet for MutateRowAsync</summary>
        public async Task MutateRowRequestObjectAsync()
        {
            // Snippet: MutateRowAsync(MutateRowRequest, CallSettings)
            // Additional: MutateRowAsync(MutateRowRequest, CancellationToken)
            // Create client
            BigtableClient bigtableClient = await BigtableClient.CreateAsync();

            // Initialize request argument(s)
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey       = ByteString.Empty,
                Mutations    = { new Mutation(), },
                AppProfileId = "",
            };
            // Make the request
            MutateRowResponse response = await bigtableClient.MutateRowAsync(request);

            // End snippet
        }
        public async Task MutateRowAsync()
        {
            Mock <Bigtable.BigtableClient> mockGrpcClient = new Mock <Bigtable.BigtableClient>(MockBehavior.Strict);
            MutateRowRequest expectedRequest = new MutateRowRequest
            {
                TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = ByteString.CopyFromUtf8("122"),
                Mutations = { },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse();

            mockGrpcClient.Setup(x => x.MutateRowAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateRowResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            BigtableServiceApiClient client  = new BigtableServiceApiClientImpl(mockGrpcClient.Object, null);
            TableName              tableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]");
            ByteString             rowKey    = ByteString.CopyFromUtf8("122");
            IEnumerable <Mutation> mutations = new List <Mutation>();
            MutateRowResponse      response  = await client.MutateRowAsync(tableName, rowKey, mutations);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task MutateRow1Async()
        {
            moq::Mock <Bigtable.BigtableClient> mockGrpcClient = new moq::Mock <Bigtable.BigtableClient>(moq::MockBehavior.Strict);
            MutateRowRequest request = new MutateRowRequest
            {
                TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
                RowKey    = proto::ByteString.CopyFromUtf8("row_key7adfb7cb"),
                Mutations = { new Mutation(), },
            };
            MutateRowResponse expectedResponse = new MutateRowResponse {
            };

            mockGrpcClient.Setup(x => x.MutateRowAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <MutateRowResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            BigtableClient    client = new BigtableClientImpl(mockGrpcClient.Object, null);
            MutateRowResponse responseCallSettings = await client.MutateRowAsync(request.TableName, request.RowKey, request.Mutations, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            MutateRowResponse responseCancellationToken = await client.MutateRowAsync(request.TableName, request.RowKey, request.Mutations, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        /// <summary>
        /// Mutate one row in an existing table and column family. Updates multiple cells within that row using one API call.
        ///</summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
        /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>
        public string writeSimple(
            string projectId  = "YOUR-PROJECT-ID",
            string instanceId = "YOUR-INSTANCE-ID",
            string tableId    = "YOUR-TABLE-ID")
        {
            BigtableClient bigtableClient = BigtableClient.Create();

            TableName          tableName     = new TableName(projectId, instanceId, tableId);
            BigtableByteString rowkey        = new BigtableByteString("phone#4c410523#20190501");
            BigtableVersion    timestamp     = new BigtableVersion(DateTime.UtcNow);
            String             COLUMN_FAMILY = "stats_summary";

            Mutation[] mutations =
            {
                Mutations.SetCell(COLUMN_FAMILY, "connected_cell",                 1, timestamp),
                Mutations.SetCell(COLUMN_FAMILY, "connected_wifi",                 1, timestamp),
                Mutations.SetCell(COLUMN_FAMILY, "os_build",       "PQ2A.190405.003", timestamp)
            };
            MutateRowResponse mutateRowResponse = bigtableClient.MutateRow(tableName, rowkey, mutations);

            Console.WriteLine(mutateRowResponse);
            return($"Successfully wrote row {rowkey}");
        }