ya-gcp 0.8.2

APIs for using Google Cloud Platform services
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Types and builders for requesting bigtable mutations.

pub use super::api::bigtable::v2::{
    self, mutate_rows_request::Entry, mutation::*, MutateRowRequest, MutateRowsRequest,
};

use super::Bytes;

impl SetCell {
    /// Create a new `SetCell` mutation for setting the value of a single cell.
    pub fn new(family_name: String, column_qualifier: Bytes, value: Bytes) -> SetCell {
        SetCell {
            family_name,
            column_qualifier,
            value,
            ..Default::default()
        }
    }

    /// Set the timestamp value of this `SetCell` mutation.
    ///
    /// The special value `-1` means that the
    /// [server provides the timestamp](https://cloud.google.com/bigtable/docs/reference/data/rpc/google.bigtable.v2#google.bigtable.v2.Mutation.SetCell).
    pub fn with_timestamp(mut self, timestamp_micros: i64) -> Self {
        self.timestamp_micros = timestamp_micros;
        self
    }
}

impl Entry {
    /// Create a new `Entry` for modifying the given row.
    pub fn new(row_key: Bytes) -> Self {
        Entry {
            row_key,
            ..Default::default()
        }
    }

    /// Add a mutation to this Entry.
    pub fn with_mutation(mut self, mutation: impl Into<Mutation>) -> Self {
        self.mutations.push(super::v2::Mutation {
            mutation: Some(mutation.into()),
        });
        self
    }

    /// Add a list of mutations to this Entry.
    pub fn with_mutations(
        mut self,
        mutations: impl IntoIterator<Item = impl Into<Mutation>>,
    ) -> Self {
        self.mutations
            .extend(mutations.into_iter().map(|mutation| super::v2::Mutation {
                mutation: Some(mutation.into()),
            }));
        self
    }
}

impl From<SetCell> for Mutation {
    fn from(sc: SetCell) -> Mutation {
        Mutation::SetCell(sc)
    }
}

impl From<DeleteFromColumn> for Mutation {
    fn from(dfc: DeleteFromColumn) -> Mutation {
        Mutation::DeleteFromColumn(dfc)
    }
}

impl From<DeleteFromFamily> for Mutation {
    fn from(dff: DeleteFromFamily) -> Mutation {
        Mutation::DeleteFromFamily(dff)
    }
}

impl From<DeleteFromRow> for Mutation {
    fn from(dfr: DeleteFromRow) -> Mutation {
        Mutation::DeleteFromRow(dfr)
    }
}

/// The error returned from a row mutation request.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum MutateRowsError {
    /// A gRPC error.
    #[error("gRPC error: {0}")]
    Tonic(#[from] tonic::Status),

    /// An error mutating one or more specific rows.
    #[error("row mutation error")]
    RowErrors(Vec<v2::mutate_rows_response::Entry>),
}

impl From<Vec<v2::mutate_rows_response::Entry>> for MutateRowsError {
    fn from(entries: Vec<v2::mutate_rows_response::Entry>) -> Self {
        MutateRowsError::RowErrors(entries)
    }
}

impl MutateRowRequest {
    /// Create a new request for modifying a specific row.
    pub fn new(table_name: String, row_key: Bytes) -> MutateRowRequest {
        MutateRowRequest {
            table_name,
            row_key,
            ..Default::default()
        }
    }

    /// Add a mutation to this request.
    pub fn with_mutation(mut self, mutation: impl Into<Mutation>) -> Self {
        self.mutations.push(v2::Mutation {
            mutation: Some(mutation.into()),
        });
        self
    }

    /// Add a list of mutations to this request.
    pub fn with_mutations(
        mut self,
        mutations: impl IntoIterator<Item = impl Into<Mutation>>,
    ) -> Self {
        self.mutations
            .extend(mutations.into_iter().map(|mutation| v2::Mutation {
                mutation: Some(mutation.into()),
            }));
        self
    }
}

impl MutateRowsRequest {
    /// Create a new request for modifying multiple rows.
    ///
    /// See [Google's docs](https://cloud.google.com/bigtable/docs/writing-data#batch) for advice
    /// about when to batch writes.
    pub fn new(table_name: String) -> MutateRowsRequest {
        MutateRowsRequest {
            table_name,
            ..Default::default()
        }
    }

    /// Add an entry to this request.
    pub fn with_entry(mut self, entry: Entry) -> Self {
        self.entries.push(entry);
        self
    }

    /// Add a list of entries to this request.
    pub fn with_entries(mut self, entries: impl Iterator<Item = Entry>) -> Self {
        self.entries.extend(entries);
        self
    }
}