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

19223

#[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

150

    pub fn new() -> Self {

23

150

        Self::default()

24

150

25

26

    /// Adds an operation to the transaction.

27

148425

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

28

148425

        self.operations.push(operation);

29

148425

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

400950

    fn from(operation: Operation) -> Self {

40

400950

        Self {

41

400950

            operations: vec![operation],

42

400950

43

400950

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

204545

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

51

204545

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

52

204545

53

54

    /// Updates a document in `collection`.

55

4090

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

56

4090

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

57

4090

58

59

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

60

32900

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

61

32900

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

62

32900

63

64

65

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

66

26982

#[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

210472

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

81

210472

        Self {

82

210472

            collection,

83

210472

            command: Command::Insert {

84

210472

id,

85

210472

                contents: contents.into(),

86

210472

},

87

210472

88

210472

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

5922

    pub fn insert_serialized<C: SerializedCollection>(

95

5922

        id: Option<u64>,

96

5922

        contents: &C::Contents,

97

5922

    ) -> Result<Self, Error> {

98

5922

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

99

5922

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

100

5922

101

102

    /// Updates a document in `collection`.

103

4090

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

104

4090

        Self {

105

4090

            collection,

106

4090

            command: Command::Update {

107

4090

                header,

108

4090

                contents: contents.into(),

109

4090

},

110

4090

111

4090

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

33150

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

125

33150

        Self {

126

33150

            collection,

127

33150

            command: Command::Delete { header },

128

33150

129

33150

130

131

132

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

133

40472

#[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

38919

#[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

470728

#[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

37950

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

216

37950

            Some(docs)

217

        } else {

218

            None

219

220

37950

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

2625

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

227

2625

            Some(keys)

228

        } else {

229

            None

230

231

2625

232

233

234

/// A record of a changed document.

235

1396476

#[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

132335

#[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