jdbc 0.1.0

Rust bindings to the Java Jdbc.
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

use std::ops::{Deref, DerefMut};

use jni::{
    objects::{AutoLocal, JMethodID, JObject, JValueGen},
    signature::ReturnType,
    AttachGuard, JNIEnv,
};

use crate::{errors::Error, util};

use super::PreparedStatement;

pub struct Connection<'local> {
    inner: AutoLocal<'local, JObject<'local>>,
    guard: AttachGuard<'local>,
    prepare_statement: JMethodID,
}

impl<'local> Connection<'local> {
    pub fn from_ref(
        mut guard: AttachGuard<'local>,
        datasource: JObject<'local>,
    ) -> Result<Self, Error> {
        let env = guard.deref_mut();
        let datasource = AutoLocal::new(datasource, &env);

        let class = AutoLocal::new(env.find_class("java/sql/Connection")?, &env);
        let prepare_statement: jni::objects::JMethodID = env.get_method_id(
            &class,
            "prepareStatement",
            "(Ljava/lang/String;)Ljava/sql/PreparedStatement;",
        )?;

        Ok(Connection {
            inner: datasource,
            guard,
            prepare_statement,
        })
    }

    pub fn prepare_statement<'parent>(
        &'parent self,
        sql: &str,
    ) -> Result<PreparedStatement<'parent>, Error> {
        let mut env = unsafe { self.env() };
        let sql: JObject<'_> = env.new_string(sql)?.into();
        let statement = unsafe {
            env.call_method_unchecked(
                &self.inner,
                self.prepare_statement,
                ReturnType::Object,
                &[JValueGen::Object(&sql).as_jni()],
            )?
        };
        env.delete_local_ref(sql)?;
        if let JValueGen::Object(statement) = statement {
            return Ok(PreparedStatement::from_ref(self, statement)?);
        }
        return Err(Error::ImpossibleError);
    }

    pub unsafe fn env(&self) -> JNIEnv {
        let env = (&self.guard).deref();
        let env = env.unsafe_clone();
        env
    }
}

impl<'local> Drop for Connection<'local> {
    fn drop(&mut self) {
        let env = self.guard.deref_mut();
        let _ = util::auto_close(env, &self.inner);
    }
}