dbsp 0.287.0

Continuous streaming analytics engine
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

#[cfg(doc)]
use crate::zset_set;

/// Create an indexed Z-set with specified elements.
///
/// This macro is used in unit tests to create reference inputs and outputs.
/// It generates an indexed Z-set of type
/// [`OrdIndexedZSet`](crate::OrdIndexedZSet)s.
///
/// # Example
///
/// The following example shows how to construct an indexed Z-set with `(key,
/// value, weight)` tuples `(1, 3, -1), (1, 2, 1), (2, 2, 1)`:
///
/// ```
/// use dbsp::{indexed_zset, IndexedZSet, IndexedZSetReader};
///
/// let zset = indexed_zset! {1 => {3 => -1, 2 => 1}, 2 => {2 => 1}};
/// assert_eq!(
///     zset.iter().collect::<Vec<_>>(),
///     vec![(1, 2, 1), (1, 3, -1), (2, 2, 1)]
/// );
/// ```
#[macro_export]
macro_rules! indexed_zset {
    ($key_type:ty => $val_type:ty: $($key:expr_2021 => { $($value:expr_2021 => $weight:expr_2021),* }),* $(,)?) => {{
        let batch = ::std::vec![ $( $( $crate::utils::Tup2($crate::utils::Tup2($key, $value), $weight) ),* ),* ];

        $crate::typed_batch::OrdIndexedZSet::<$key_type, $val_type>::from_tuples((), batch)
    }};

    ($($key:expr_2021 => { $($value:expr_2021 => $weight:expr_2021),* }),* $(,)?) => {{
        let batch = ::std::vec![ $( $( $crate::utils::Tup2($crate::utils::Tup2($key, $value), $weight) ),* ),* ];

        $crate::typed_batch::OrdIndexedZSet::from_tuples((), batch)
    }};
}

/// Create a Z-set with specified elements.
///
/// This macro is used in unit tests to create reference inputs and outputs.
/// It generates a Z-set of type [`OrdZSet`](crate::OrdZSet)s.
///
/// If all the elements in the Z-set will have weight 1, consider [`zset_set!`].
///
/// # Example
///
/// The following example shows how to construct a Z-set with `(key, weight)`
/// tuples `(1, -1), (2, 1)`:
///
/// ```
/// use dbsp::{zset, IndexedZSet, IndexedZSetReader};
///
/// let zset = zset! {1 => -1, 2 => 1};
/// assert_eq!(
///     zset.iter().collect::<Vec<_>>(),
///     vec![(1, (), -1), (2, (), 1)]
/// );
/// ```
#[macro_export]
macro_rules! zset {
    ( $( $key:expr_2021 => $weight:expr_2021 ),* $(,)?) => {{
        let batch = ::std::vec![ $( $crate::utils::Tup2($crate::utils::Tup2($key, ()), $weight) ),* ];

        $crate::typed_batch::OrdZSet::from_tuples((), batch)
    }};

}

/// Create a Z-set with specified elements all with weight 1.
///
/// This macro is used in unit tests to create reference inputs and outputs.
/// It generates a Z-set of type [`OrdZSet`](crate::OrdZSet)s.
///
/// # Example
///
/// The following examples shows how to construct a Z-set with `(key, weight)`
/// tuples `(1, 1), (2, 1), (-3, 1)`:
///
/// ```
/// use dbsp::{zset_set, IndexedZSet, IndexedZSetReader};
///
/// let zset = zset_set! {1, 2, -3};
/// assert_eq!(
///     zset.iter().collect::<Vec<_>>(),
///     vec![(-3, (), 1), (1, (), 1), (2, (), 1)]
/// );
/// ```
#[macro_export]
macro_rules! zset_set {
    ( $( $key:expr_2021 ),* $(,)?) => {{
        let batch = ::std::vec![ $( $crate::utils::Tup2($crate::utils::Tup2($key, ()), 1) ),* ];

        $crate::typed_batch::OrdZSet::from_tuples((), batch)
    }};
}

#[cfg(test)]
mod test {
    use crate::typed_batch::IndexedZSetReader;

    #[test]
    fn zset_test() {
        let zset = zset! {1 => -1, 2 => 1};
        assert_eq!(
            zset.iter().collect::<Vec<_>>(),
            vec![(1, (), -1), (2, (), 1)]
        );
    }

    #[test]
    fn indexed_zset_test() {
        let zset = indexed_zset! { u64 => i64: 1 => {3 => -1, 2 => 1}, 2 => {2 => 1}};
        assert_eq!(
            zset.iter().collect::<Vec<_>>(),
            vec![(1, 2, 1), (1, 3, -1), (2, 2, 1)]
        );
    }

    #[test]
    fn zset_set_test() {
        let zset = zset_set! {1i32, 2, -3};
        assert_eq!(
            zset.iter().collect::<Vec<_>>(),
            vec![(-3i32, (), 1), (1, (), 1), (2, (), 1)]
        );
    }
}