factstr-postgres 0.5.2

PostgreSQL store for FACTSTR with append, query, streams, and durable streams.
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

use factstr::{EventFilter, EventQuery};
use sqlx::{Postgres, QueryBuilder};

pub(crate) fn push_query_conditions(
    query_builder: &mut QueryBuilder<'_, Postgres>,
    event_query: &EventQuery,
    include_min_sequence_number: bool,
) {
    let mut wrote_condition = false;

    if let Some(filters) = &event_query.filters {
        if !filters.is_empty() {
            query_builder.push(" WHERE (");

            for (index, event_filter) in filters.iter().enumerate() {
                if index > 0 {
                    query_builder.push(" OR ");
                }

                query_builder.push("(");
                push_filter_condition(query_builder, event_filter);
                query_builder.push(")");
            }

            query_builder.push(")");
            wrote_condition = true;
        }
    }

    if include_min_sequence_number {
        if let Some(min_sequence_number) = event_query.min_sequence_number {
            if wrote_condition {
                query_builder.push(" AND ");
            } else {
                query_builder.push(" WHERE ");
            }

            // The current Rust contract treats min_sequence_number as an
            // exclusive read cursor for returned rows.
            query_builder
                .push("sequence_number > ")
                .push_bind(min_sequence_number as i64);
        }
    }
}

fn push_filter_condition(
    query_builder: &mut QueryBuilder<'_, Postgres>,
    event_filter: &EventFilter,
) {
    let mut wrote_condition = false;

    if let Some(event_types) = &event_filter.event_types {
        if event_types.is_empty() {
            // `Some(Vec::new())` is an explicit empty match set, not omission.
            query_builder.push("FALSE");
            return;
        } else {
            query_builder
                .push("(")
                .push("event_type = ANY(")
                .push_bind(event_types.clone())
                .push(")");
            query_builder.push(")");
            wrote_condition = true;
        }
    }

    if let Some(payload_predicates) = &event_filter.payload_predicates {
        if wrote_condition {
            query_builder.push(" AND ");
        }

        if payload_predicates.is_empty() {
            query_builder.push("FALSE");
            return;
        }

        query_builder.push("(");
        for (index, payload_predicate) in payload_predicates.iter().enumerate() {
            if index > 0 {
                query_builder.push(" OR ");
            }

            query_builder
                .push("payload @> ")
                .push_bind(payload_predicate.clone());
        }
        query_builder.push(")");
    } else if !wrote_condition {
        query_builder.push("TRUE");
    }
}