Grcov report - transaction.rs

1

use arc_bytes::serde::Bytes;

2

use serde::{Deserialize, Serialize};

3

4

use crate::{

5

    document::Header,

6

    schema::{CollectionName, SerializedCollection},

7

    Error,

8

};

9

10

/// A list of operations to execute as a single unit. If any operation fails,

11

/// all changes are aborted. Reads that happen while the transaction is in

12

/// progress will return old data and not block.

13

18938

#[derive(Clone, Serialize, Deserialize, Default, Debug)]

14

#[must_use]

15

pub struct Transaction {

16

    /// The operations in this transaction.

17

    pub operations: Vec<Operation>,

18

19

20

impl Transaction {

21

    /// Returns a new, empty transaction.

22

138

    pub fn new() -> Self {

23

138

        Self::default()

24

138

25

26

    /// Adds an operation to the transaction.

27

209231

    pub fn push(&mut self, operation: Operation) {

28

209231

        self.operations.push(operation);

29

209231

30

31

    /// Appends an operation to the transaction and returns self.

32

    pub fn with(mut self, operation: Operation) -> Self {

33

        self.push(operation);

34

        self

35

36

37

38

impl From<Operation> for Transaction {

39

338422

    fn from(operation: Operation) -> Self {

40

338422

        Self {

41

338422

            operations: vec![operation],

42

338422

43

338422

44

45

46

impl Transaction {

47

    /// Inserts a new document with `contents` into `collection`.  If `id` is

48

    /// `None` a unique id will be generated. If an id is provided and a

49

    /// document already exists with that id, a conflict error will be returned.

50

185269

    pub fn insert(collection: CollectionName, id: Option<u64>, contents: impl Into<Bytes>) -> Self {

51

185269

        Self::from(Operation::insert(collection, id, contents))

52

185269

53

54

    /// Updates a document in `collection`.

55

3928

    pub fn update(collection: CollectionName, header: Header, contents: impl Into<Bytes>) -> Self {

56

3928

        Self::from(Operation::update(collection, header, contents))

57

3928

58

59

    /// Deletes a document from a `collection`.

60

30130

    pub fn delete(collection: CollectionName, header: Header) -> Self {

61

30130

        Self::from(Operation::delete(collection, header))

62

30130

63

64

65

/// A single operation performed on a `Collection`.

66

30926

#[derive(Clone, Serialize, Deserialize, Debug)]

67

#[must_use]

68

pub struct Operation {

69

    /// The id of the `Collection`.

70

    pub collection: CollectionName,

71

72

    /// The command being performed.

73

    pub command: Command,

74

75

76

impl Operation {

77

    /// Inserts a new document with `contents` into `collection`.  If `id` is

78

    /// `None` a unique id will be generated. If an id is provided and a

79

    /// document already exists with that id, a conflict error will be returned.

80

194314

    pub fn insert(collection: CollectionName, id: Option<u64>, contents: impl Into<Bytes>) -> Self {

81

194314

        Self {

82

194314

            collection,

83

194314

            command: Command::Insert {

84

194314

id,

85

194314

                contents: contents.into(),

86

194314

},

87

194314

88

194314

89

90

    /// Inserts a new document with the serialized representation of `contents`

91

    /// into `collection`.  If `id` is `None` a unique id will be generated. If

92

    /// an id is provided and a document already exists with that id, a conflict

93

    /// error will be returned.

94

9084

    pub fn insert_serialized<C: SerializedCollection>(

95

9084

        id: Option<u64>,

96

9084

        contents: &C::Contents,

97

9084

    ) -> Result<Self, Error> {

98

9084

        let contents = C::serialize(contents)?;

99

9084

        Ok(Self::insert(C::collection_name(), id, contents))

100

9084

101

102

    /// Updates a document in `collection`.

103

3928

    pub fn update(collection: CollectionName, header: Header, contents: impl Into<Bytes>) -> Self {

104

3928

        Self {

105

3928

            collection,

106

3928

            command: Command::Update {

107

3928

                header,

108

3928

                contents: contents.into(),

109

3928

},

110

3928

111

3928

112

113

    /// Updates a document with the serialized representation of `contents` in

114

    /// `collection`.

115

    pub fn update_serialized<C: SerializedCollection>(

116

        header: Header,

117

        contents: &C::Contents,

118

    ) -> Result<Self, Error> {

119

        let contents = C::serialize(contents)?;

120

        Ok(Self::update(C::collection_name(), header, contents))

121

122

123

    /// Deletes a document from a `collection`.

124

30314

    pub const fn delete(collection: CollectionName, header: Header) -> Self {

125

30314

        Self {

126

30314

            collection,

127

30314

            command: Command::Delete { header },

128

30314

129

30314

130

131

132

/// A command to execute within a `Collection`.

133

46389

#[derive(Clone, Serialize, Deserialize, Debug)]

134

pub enum Command {

135

    /// Inserts a new document containing `contents`.

136

    Insert {

137

        /// An optional id for the document. If this is `None`, a unique id will

138

        /// be generated. If this is `Some()` and a document already exists with

139

        /// that id, a conflict error will be returned.

140

        id: Option<u64>,

141

        /// The initial contents of the document.

142

        contents: Bytes,

143

},

144

145

    /// Update an existing `Document` identified by `id`. `revision` must match

146

    /// the currently stored revision on the `Document`. If it does not, the

147

    /// command fill fail with a `DocumentConflict` error.

148

    Update {

149

        /// The header of the `Document`. The revision must match the current

150

        /// document.

151

        header: Header,

152

153

        /// The new contents to store within the `Document`.

154

        contents: Bytes,

155

},

156

157

    /// Delete an existing `Document` identified by `id`. `revision` must match

158

    /// the currently stored revision on the `Document`. If it does not, the

159

    /// command fill fail with a `DocumentConflict` error.

160

    Delete {

161

        /// The current header of the `Document`.

162

        header: Header,

163

},

164

165

166

/// Information about the result of each `Operation` in a transaction.

167

44835

#[derive(Clone, Debug, Serialize, Deserialize)]

168

pub enum OperationResult {

169

    /// An operation succeeded but had no information to output.

170

    Success,

171

172

    /// A `Document` was updated.

173

    DocumentUpdated {

174

        /// The id of the `Collection` of the updated `Document`.

175

        collection: CollectionName,

176

177

        /// The header of the updated `Document`.

178

        header: Header,

179

},

180

181

    /// A `Document` was deleted.

182

    DocumentDeleted {

183

        /// The id of the `Collection` of the deleted `Document`.

184

        collection: CollectionName,

185

186

        /// The id of the deleted `Document`.

187

        id: u64,

188

},

189

190

191

/// Details about an executed transaction.

192

11444

#[derive(Clone, Debug, Serialize, Deserialize)]

193

pub struct Executed {

194

    /// The id of the transaction.

195

    pub id: u64,

196

197

    /// A list of containing ids of `Documents` changed.

198

    pub changes: Changes,

199

200

201

/// A list of changes.

202

445920

#[derive(Clone, Debug, Serialize, Deserialize)]

203

pub enum Changes {

204

    /// A list of changed documents.

205

    Documents(Vec<ChangedDocument>),

206

    /// A list of changed keys.

207

    Keys(Vec<ChangedKey>),

208

209

210

impl Changes {

211

    /// Returns the list of documents changed in this transaction, or None if

212

    /// the transaction was not a document transaction.

213

    #[must_use]

214

    pub fn documents(&self) -> Option<&[ChangedDocument]> {

215

34845

        if let Self::Documents(docs) = self {

216

34845

            Some(docs)

217

        } else {

218

            None

219

220

34845

221

222

    /// Returns the list of keys changed in this transaction, or None if the

223

    /// transaction was not a `KeyValue` transaction.

224

    #[must_use]

225

    pub fn keys(&self) -> Option<&[ChangedKey]> {

226

1932

        if let Self::Keys(keys) = self {

227

1932

            Some(keys)

228

        } else {

229

            None

230

231

1932

232

233

234

/// A record of a changed document.

235

1268130

#[derive(Debug, Clone, Serialize, Deserialize)]

236

pub struct ChangedDocument {

237

    /// The id of the `Collection` of the changed `Document`.

238

    pub collection: CollectionName,

239

240

    /// The id of the changed `Document`.

241

    pub id: u64,

242

243

    /// If the `Document` has been deleted, this will be `true`.

244

    pub deleted: bool,

245

246

247

/// A record of a changed `KeyValue` entry.

248

142945

#[derive(Clone, Debug, Serialize, Deserialize)]

249

pub struct ChangedKey {

250

    /// The namespace of the key.

251

    pub namespace: Option<String>,

252

253

    /// The key that was changed.

254

    pub key: String,

255

256

    /// True if the key was deleted.

257

    pub deleted: bool,

258