graphrecords-query 0.5.0

High-performance graph-based data records
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

use super::stats::Stats;

#[derive(Clone, Debug)]
pub struct Estimate {
    pub elements: Option<usize>,
    pub distinct: Option<usize>,
    pub selectivity: Option<f64>,
    pub per_group: Option<Box<Self>>,
}

impl Estimate {
    pub const UNKNOWN: Self = Self {
        elements: None,
        distinct: None,
        selectivity: None,
        per_group: None,
    };

    #[must_use]
    pub fn values(elements: usize, distinct: usize) -> Self {
        Self {
            elements: Some(elements),
            distinct: Some(distinct.min(elements)),
            selectivity: None,
            per_group: None,
        }
    }

    #[must_use]
    pub fn singleton() -> Self {
        Self::values(1, 1)
    }

    #[must_use]
    pub fn with_unknown_distinct(self) -> Self {
        Self {
            distinct: None,
            ..self
        }
    }

    #[must_use]
    pub fn zero_or_one(self) -> Self {
        Self {
            elements: self.elements.map(|elements| elements.min(1)),
            distinct: None,
            selectivity: None,
            per_group: None,
        }
    }

    #[must_use]
    pub fn scaled(self, selectivity: f64) -> Self {
        let elements = self
            .elements
            .map(|elements| (elements as f64 * selectivity).round() as usize);
        let distinct = match (self.distinct, elements) {
            (Some(distinct), Some(elements)) => Some(distinct.min(elements)),
            (distinct, _) => distinct,
        };

        Self {
            elements,
            distinct,
            ..self
        }
    }
}

pub trait Estimated {
    fn estimate(&self, stats: &Stats) -> Estimate;
}