openpql-runner 0.1.4

A high-performance Rust implementation of Poker Query Language (PQL), enabling SQL-like queries for poker analysis and calculations. This project is a spiritual successor to the original Java implementation developed by Odds Oracle.
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

use super::*;

macro_rules! union {
    ($single:ident) => {
        PQLType::$single.bits()
    };
    ($first:ident, $($rest:ident),+) => {
        PQLType::$first.bits() | union!($($rest),+)
    };
}

bitflags! {
  #[derive(Clone, Copy, Debug, PartialEq, Eq, Display)]
  pub struct PQLType: u32 {
    const BOARDRANGE = 1;
    const BOOLEAN = 1 << 1;
    const CARD = 1 << 2;
    const CARDCOUNT = 1 << 3;
    const DOUBLE = 1 << 4;
    const EQUITY = union!(DOUBLE);
    const FLOPHANDCATEGORY = 1 << 6;
    const FRACTION = 1 << 7;
    const HANDRANKING = 1 << 8;
    const HANDTYPE = 1 << 9;
    const HIRATING = 1 << 10;
    const INTEGER = union!(LONG);
    const LONG = 1 << 12;
    const LORATING = 1 << 13;
    const NUMERIC = union!(CARDCOUNT, LONG, DOUBLE, FRACTION);
    const PLAYER = 1 << 15;
    const PLAYERCOUNT = union!(CARDCOUNT);
    const RANGE = 1 << 17;
    const RANK = 1 << 18;
    const RANKSET = 1 << 19;
    const STREET = 1 << 20;
    const STRING = 1 << 21;
  }
}

impl PQLType {
    pub const fn is_num(self) -> bool {
        Self::NUMERIC.contains(self)
    }

    pub const fn is_concrete(self) -> bool {
        self.bits().is_power_of_two()
    }
}

impl From<ast::SelectorKind> for PQLType {
    fn from(sel: ast::SelectorKind) -> Self {
        match sel {
            ast::SelectorKind::Avg => Self::NUMERIC,
            ast::SelectorKind::Count => Self::BOOLEAN,
            ast::SelectorKind::Max | ast::SelectorKind::Min => {
                Self::NUMERIC
                    | Self::FLOPHANDCATEGORY
                    | Self::HANDTYPE
                    | Self::HIRATING
                    | Self::RANK
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::*;

    #[test]
    fn test_type_alias() {
        assert_eq!(PQLType::PLAYERCOUNT, PQLType::CARDCOUNT);
        assert_eq!(PQLType::INTEGER, PQLType::LONG);
        assert_eq!(PQLType::EQUITY, PQLType::DOUBLE);
    }

    #[test]
    fn test_type_num() {
        for tp in [
            PQLType::PLAYERCOUNT,
            PQLType::CARDCOUNT,
            PQLType::INTEGER,
            PQLType::LONG,
            PQLType::EQUITY,
            PQLType::DOUBLE,
            PQLType::FRACTION,
        ] {
            assert!(PQLType::NUMERIC.contains(tp));
        }
    }

    #[test]
    fn test_type_for_selector() {
        use ast::SelectorKind::*;
        fn assert_match(sel: ast::SelectorKind, kind: PQLType) {
            assert!(PQLType::from(sel).contains(kind));
        }
        fn assert_match_max_min(kind: PQLType) {
            assert_match(Max, kind);
            assert_match(Min, kind);
        }

        assert_match(Avg, PQLType::CARDCOUNT);
        assert_match(Avg, PQLType::LONG);
        assert_match(Avg, PQLType::FRACTION);
        assert_match(Avg, PQLType::DOUBLE);

        assert_match(Count, PQLType::BOOLEAN);

        assert_match_max_min(PQLType::CARDCOUNT);
        assert_match_max_min(PQLType::LONG);
        assert_match_max_min(PQLType::FRACTION);
        assert_match_max_min(PQLType::DOUBLE);
        assert_match_max_min(PQLType::FLOPHANDCATEGORY);
        assert_match_max_min(PQLType::HANDTYPE);
        assert_match_max_min(PQLType::HIRATING);
        assert_match_max_min(PQLType::RANK);
    }
}