mimir 0.3.5

Rust bindings over the Oracle Database Programming Interface for Drivers and Applications
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use mimir::enums::ODPIDeqMode::Remove;
use mimir::enums::ODPIMessageDeliveryMode::NotSet;
use mimir::enums::ODPINativeTypeNum::Bytes;
use mimir::enums::ODPIOracleTypeNum::{Clob, Varchar};
use mimir::enums::ODPIVisibility::OnCommit;
use mimir::flags;
use mimir::Result;
use mimir::{Connection, Context, ODPISubscrMessage};
use rand::{self, Rng};
use CREDS;

extern "C" fn subscr_callback(
    _context: *mut ::std::os::raw::c_void,
    _message: *mut ODPISubscrMessage,
) {
    // For testing
}

fn conn(ctxt: &Context) -> Result<()> {
    let mut common_create_params = ctxt.init_common_create_params()?;
    common_create_params.set_encoding("UTF-8")?;
    common_create_params.set_nchar_encoding("UTF-8")?;
    common_create_params.set_create_mode(flags::DPI_MODE_CREATE_EVENTS);

    let mut common_connection_params = ctxt.init_conn_create_params()?;
    common_connection_params.set_auth_mode(flags::DPI_MODE_AUTH_DEFAULT);

    let conn = Connection::create(
        ctxt,
        Some(&CREDS[0]),
        Some(&CREDS[1]),
        Some("//oic.cbsnae86d3iv.us-east-2.rds.amazonaws.com/ORCL"),
        Some(common_create_params),
        None,
    )?;

    // break_execution / ping test
    conn.break_execution()?;
    conn.ping()?;

    // set_current_schema / get_current_schema test
    conn.set_current_schema("jozias")?;
    let current_schema = conn.get_current_schema()?;
    assert_eq!(current_schema, "jozias");

    let edition = conn.get_edition()?;
    assert_eq!(edition, "");

    conn.set_external_name("ext")?;
    let external_name = conn.get_external_name()?;
    assert_eq!(external_name, "ext");

    conn.set_internal_name("ext")?;
    let internal_name = conn.get_internal_name()?;
    assert_eq!(internal_name, "ext");

    let encoding_info = conn.get_encoding_info()?;
    assert_eq!(encoding_info.encoding(), "UTF-8");
    assert_eq!(encoding_info.nchar_encoding(), "UTF-8");
    assert_eq!(encoding_info.max_bytes_per_char(), 4);
    assert_eq!(encoding_info.max_bytes_per_nchar(), 4);

    conn.set_statement_cache_size(40)?;
    let statement_cache_size = conn.get_statement_cache_size()?;
    assert_eq!(statement_cache_size, 40);

    // begin_distrib_trans / get_ltxid / prepare_distrib_trans
    let mut rng = rand::thread_rng();
    conn.begin_distrib_trans(rng.gen::<i64>(), "One", "Two")?;
    let ltxid = conn.get_ltxid()?;
    assert_eq!(ltxid, "");
    let commit_needed = conn.prepare_distrib_trans()?;
    assert!(!commit_needed);

    // get_server_version
    let version_info = conn.get_server_version()?;
    assert_eq!(version_info.version(), "12.1.0.2.0");
    assert_eq!(version_info.version_num(), 1_201_000_200);
    assert_eq!(
        version_info.release(),
        "Oracle Database 12c Standard Edition Release 12.1.0.2.0 - \
         64bit Production"
    );

    // new_deq_options
    let deq_opts = conn.new_deq_options()?;
    let mode = deq_opts.get_mode()?;
    assert_eq!(mode, Remove);

    // new_enq_options
    let enq_opts = conn.new_enq_options()?;
    let visibility = enq_opts.get_visibility()?;
    assert_eq!(visibility, OnCommit);

    // new_msg_props
    let msg_props = conn.new_msg_props()?;
    let delivery_mode = msg_props.get_delivery_mode()?;
    assert_eq!(delivery_mode, NotSet);

    // new_subscr_props
    let mut subscr_create_params = ctxt.init_subscr_create_params()?;
    subscr_create_params.set_port_number(32_276);
    subscr_create_params.set_timeout(10_000);
    subscr_create_params.set_name("subscription")?;
    subscr_create_params.set_callback(Some(subscr_callback));
    subscr_create_params.set_recipient_name("yoda")?;

    // TODO: Fix this to run on VM.
    // let subscription = conn.new_subscription(subscr_create_params)?;
    // subscription.add_ref()?;
    // subscription.release()?;

    // new_temp_lob
    let clob = conn.new_temp_lob(Clob)?;
    let chunk_size = clob.get_chunk_size()?;
    assert_eq!(chunk_size, 8132);

    // new_var
    let var = conn.new_var(Varchar, Bytes, 5, 256, false, false)?;
    let sib = var.get_size_in_bytes()?;
    assert_eq!(sib, 1024);
    let num_elements_in_array = var.get_num_elements_in_array()?;
    assert_eq!(num_elements_in_array, 5);
    let data_arr = var.get_data()?;
    assert_eq!(data_arr.len(), 5);

    // prepare_stmt
    let _statement = conn.prepare_stmt(Some("select 1 from dual"), None, false)?;

    // sets
    conn.set_action("action")?;
    conn.set_client_identifier("client_identifier")?;
    conn.set_client_info("client_info")?;
    conn.set_db_op("insert")?;
    conn.set_module("module")?;

    Ok(())
}

#[test]
fn connection() {
    check_with_ctxt!(conn)
}