mysql 28.0.0

Mysql client library implemented in rust
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

use std::{
    collections::VecDeque,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Condvar, Mutex,
    },
};

use crate::{Conn, Opts, PoolOpts};

#[derive(Debug)]
pub struct Protected {
    opts: Opts,
    connections: VecDeque<Conn>,
}

impl Protected {
    fn new(opts: Opts) -> crate::Result<Protected> {
        let constraints = opts.get_pool_opts().constraints();

        let mut this = Protected {
            connections: VecDeque::with_capacity(constraints.max()),
            opts,
        };

        for _ in 0..constraints.min() {
            this.new_conn()?;
        }

        Ok(this)
    }

    pub fn new_conn(&mut self) -> crate::Result<()> {
        match Conn::new(self.opts.clone()) {
            Ok(conn) => {
                self.connections.push_back(conn);
                Ok(())
            }
            Err(err) => Err(err),
        }
    }

    pub fn take_by_query(&mut self, query: &[u8]) -> Option<Conn> {
        match self
            .connections
            .iter()
            .position(|conn| conn.has_stmt(query))
        {
            Some(position) => self.connections.swap_remove_back(position),
            None => None,
        }
    }

    pub fn pop_front(&mut self) -> Option<Conn> {
        self.connections.pop_front()
    }

    pub fn push_back(&mut self, conn: Conn) {
        self.connections.push_back(conn)
    }
}

pub struct Inner {
    protected: (Mutex<Protected>, Condvar),
    pool_opts: PoolOpts,
    count: AtomicUsize,
}

impl Inner {
    pub fn increase(&self) {
        let prev = self.count.fetch_add(1, Ordering::Relaxed);
        debug_assert!(prev < self.max_constraint());
    }

    pub fn decrease(&self) {
        let prev = self.count.fetch_sub(1, Ordering::Relaxed);
        debug_assert!(prev > 0);
    }

    pub fn count(&self) -> usize {
        let value = self.count.load(Ordering::Relaxed);
        debug_assert!(value <= self.max_constraint());
        value
    }

    pub fn is_full(&self) -> bool {
        self.count() == self.max_constraint()
    }

    pub fn opts(&self) -> &PoolOpts {
        &self.pool_opts
    }

    pub fn max_constraint(&self) -> usize {
        self.pool_opts.constraints().max()
    }

    pub fn protected(&self) -> &(Mutex<Protected>, Condvar) {
        &self.protected
    }

    pub fn new(opts: Opts) -> crate::Result<Self> {
        Ok(Self {
            count: AtomicUsize::new(opts.get_pool_opts().constraints().min()),
            pool_opts: opts.get_pool_opts().clone(),
            protected: (Mutex::new(Protected::new(opts)?), Condvar::new()),
        })
    }
}