Grcov report - view-example-string.rs

1

use bonsaidb::{

2

    core::{

3

        connection::Connection,

4

        document::{BorrowedDocument, Document},

5

        schema::{

6

            view::map::ViewMappedValue, Collection, CollectionName, DefaultSerialization,

7

            DefaultViewSerialization, Name, ReduceResult, SerializedCollection, View,

8

            ViewMapResult, ViewSchema,

9

},

10

        Error,

11

},

12

    local::{

13

        config::{Builder, StorageConfiguration},

14

        Database,

15

},

16

};

17

use serde::{Deserialize, Serialize};

18

19

// ANCHOR: struct

20

49

#[derive(Serialize, Deserialize, Debug)]

21

pub struct BlogPost {

22

    pub title: String,

23

    pub body: String,

24

    pub category: Option<String>,

25

26

// ANCHOR_END: struct

27

28

impl Collection for BlogPost {

29

55

    fn collection_name() -> CollectionName {

30

55

        CollectionName::new("view-example", "blog-post")

31

55

32

33

2

    fn define_views(schema: &mut bonsaidb::core::schema::Schematic) -> Result<(), Error> {

34

2

        schema.define_view(BlogPostsByCategory)

35

2

36

37

38

impl DefaultSerialization for BlogPost {}

39

40

2

#[derive(Debug, Clone)]

41

pub struct BlogPostsByCategory;

42

43

// ANCHOR: view

44

impl View for BlogPostsByCategory {

45

    type Collection = BlogPost;

46

    type Key = Option<String>;

47

    type Value = u32;

48

49

26

    fn name(&self) -> Name {

50

26

        Name::new("by-category")

51

26

52

53

54

impl ViewSchema for BlogPostsByCategory {

55

    type View = Self;

56

57

3

    fn map(&self, document: &BorrowedDocument<'_>) -> ViewMapResult<Self::View> {

58

3

        let post = document.contents::<BlogPost>()?;

59

3

        Ok(document.emit_key_and_value(post.category, 1))

60

3

61

62

4

    fn reduce(

63

4

        &self,

64

4

        mappings: &[ViewMappedValue<Self::View>],

65

4

        _rereduce: bool,

66

4

    ) -> ReduceResult<Self::View> {

67

6

        Ok(mappings.iter().map(|mapping| mapping.value).sum())

68

4

69

70

// ANCHOR_END: view

71

72

impl DefaultViewSerialization for BlogPostsByCategory {}

73

74

#[allow(unused_variables)]

75

1

#[tokio::test]

76

1

async fn example() -> Result<(), Error> {

77

1

    drop(tokio::fs::remove_dir_all("example.bonsaidb").await);

78

20

    let db = Database::open::<BlogPost>(StorageConfiguration::new("example.bonsaidb")).await?;

79

    // ANCHOR: insert_data

80

1

    BlogPost {

81

1

        title: String::from("New version of BonsaiDb released"),

82

1

        body: String::from("..."),

83

1

        category: Some(String::from("Rust")),

84

1

85

1

    .push_into(&db)

86

1

    .await?;

87

88

1

    BlogPost {

89

1

        title: String::from("New Rust version released"),

90

1

        body: String::from("..."),

91

1

        category: Some(String::from("Rust")),

92

1

93

1

    .push_into(&db)

94

1

    .await?;

95

96

1

    BlogPost {

97

1

        title: String::from("Check out this great cinnamon roll recipe"),

98

1

        body: String::from("..."),

99

1

        category: Some(String::from("Cooking")),

100

1

101

1

    .push_into(&db)

102

1

    .await?;

103

    // ANCHOR_END: insert_data

104

    // ANCHOR: query_with_docs

105

1

    let rust_posts = db

106

1

        .view::<BlogPostsByCategory>()

107

1

        .with_key(Some(String::from("Rust")))

108

3

        .query_with_docs()

109

3

        .await?;

110

3

    for mapping in &rust_posts {

111

2

        let post = mapping.document.contents::<BlogPost>()?;

112

2

        println!(

113

2

            "Retrieved post #{} \"{}\"",

114

2

            mapping.document.header.id, post.title

115

2

);

116

117

    // ANCHOR_END: query_with_docs

118

1

    assert_eq!(rust_posts.len(), 2);

119

    // ANCHOR: query_with_collection_docs

120

1

    let rust_posts = db

121

1

        .view::<BlogPostsByCategory>()

122

1

        .with_key(Some(String::from("Rust")))

123

2

        .query_with_collection_docs()

124

2

        .await?;

125

3

    for mapping in &rust_posts {

126

2

        println!(

127

2

            "Retrieved post #{} \"{}\"",

128

2

            mapping.document.header.id, mapping.document.contents.title

129

2

);

130

2

131

    // ANCHOR_END: query_with_collection_docs

132

1

    assert_eq!(rust_posts.len(), 2);

133

    // ANCHOR: reduce_one_key

134

1

    let rust_post_count = db

135

1

        .view::<BlogPostsByCategory>()

136

1

        .with_key(Some(String::from("Rust")))

137

1

        .reduce()

138

        .await?;

139

1

    assert_eq!(rust_post_count, 2);

140

    // ANCHOR_END: reduce_one_key

141

    // ANCHOR: reduce_multiple_keys

142

1

    let total_post_count = db.view::<BlogPostsByCategory>().reduce().await?;

143

1

    assert_eq!(total_post_count, 3);

144

    // ANCHOR_END: reduce_multiple_keys

145

1

    Ok(())

146

1