Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-23 00:16:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactor: move more methods onto the sql struct

Browse Source
This commit is contained in:
dignifiedquire
2019-07-15 00:33:02 +02:00
parent 668c647fdd
commit cdfc8c6fa7
24 changed files with 562 additions and 584 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
examples/repl/cmdline.rs
View File

@@ -125,15 +125,12 @@ unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int
/* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
if !spec.is_null() {
real_spec = dc_strdup(spec);
sql::set_config(
context,
&context.sql,
"import_spec",
Some(as_str(real_spec)),
);
context
.sql
.set_config(context, "import_spec", Some(as_str(real_spec)));
current_block = 7149356873433890176;
} else {
let rs = sql::get_config(context, &context.sql, "import_spec", None);
let rs = context.sql.get_config(context, "import_spec", None);
if rs.is_none() {
error!(context, 0, "Import: No file or folder given.");
current_block = 8522321847195001863;

17
src/config.rs
View File

@@ -8,7 +8,6 @@ use crate::context::Context;
use crate::dc_job::*;
use crate::dc_stock::*;
use crate::dc_tools::*;
use crate::sql;
use crate::x::*;
/// The available configuration keys.
@@ -83,7 +82,7 @@ pub fn get(context: &Context, key: impl AsRef<str>) -> String {
Ok(config_key) => {
let value = match config_key {
Config::Selfavatar => {
let rel_path = sql::get_config(context, &context.sql, key, None);
let rel_path = context.sql.get_config(context, key, None);
rel_path.map(|p| {
let v = unsafe { dc_get_abs_path(context, to_cstring(p).as_ptr()) };
let r = to_string(v);
@@ -91,7 +90,7 @@ pub fn get(context: &Context, key: impl AsRef<str>) -> String {
r
})
}
_ => sql::get_config(context, &context.sql, key, None),
_ => context.sql.get_config(context, key, None),
};
if value.is_some() {
@@ -151,20 +150,20 @@ pub fn set(context: &Context, key: impl AsRef<str>, value: Option<&str>) -> libc
Ok(Config::Selfavatar) if value.is_some() => {
let mut rel_path = unsafe { dc_strdup(to_cstring(value.unwrap()).as_ptr()) };
if 0 != unsafe { dc_make_rel_and_copy(context, &mut rel_path) } {
ret = sql::set_config(context, &context.sql, key, Some(as_str(rel_path)));
ret = context.sql.set_config(context, key, Some(as_str(rel_path)));
}
unsafe { free(rel_path as *mut libc::c_void) };
}
Ok(Config::InboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value);
ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_imap_idle(context) };
}
Ok(Config::SentboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value);
ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_sentbox_idle(context) };
}
Ok(Config::MvboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value);
ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_mvbox_idle(context) };
}
Ok(Config::Selfstatus) => {
@@ -175,11 +174,11 @@ pub fn set(context: &Context, key: impl AsRef<str>, value: Option<&str>) -> libc
value
};
ret = sql::set_config(context, &context.sql, key, val);
ret = context.sql.set_config(context, key, val);
unsafe { free(def as *mut libc::c_void) };
}
Ok(_) => {
ret = sql::set_config(context, &context.sql, key, value);
ret = context.sql.set_config(context, key, value);
}
Err(_) => {}
}

60
src/context.rs
View File

@@ -15,7 +15,7 @@ use crate::dc_tools::*;
use crate::imap::*;
use crate::key::*;
use crate::smtp::*;
use crate::sql::{self, Sql};
use crate::sql::Sql;
use crate::types::*;
use crate::x::*;
@@ -260,7 +260,7 @@ unsafe fn cb_set_config(context: &Context, key: *const libc::c_char, value: *con
} else {
Some(as_str(value))
};
sql::set_config(context, &context.sql, as_str(key), v);
context.sql.set_config(context, as_str(key), v);
}
/* *
@@ -280,7 +280,7 @@ unsafe fn cb_get_config(
} else {
Some(as_str(def))
};
let res = sql::get_config(context, &context.sql, as_str(key), d);
let res = context.sql.get_config(context, as_str(key), d);
if let Some(res) = res {
strdup(to_cstring(res).as_ptr())
} else {
@@ -376,27 +376,25 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
let unset = "0";
let l = dc_loginparam_read(context, &context.sql, "");
let l2 = dc_loginparam_read(context, &context.sql, "configured_");
let displayname = sql::get_config(context, &context.sql, "displayname", None);
let displayname = context.sql.get_config(context, "displayname", None);
let chats = dc_get_chat_cnt(context) as usize;
let real_msgs = dc_get_real_msg_cnt(context) as usize;
let deaddrop_msgs = dc_get_deaddrop_msg_cnt(context) as usize;
let contacts = dc_get_real_contact_cnt(context) as usize;
let is_configured = sql::get_config_int(context, &context.sql, "configured", 0);
let dbversion = sql::get_config_int(context, &context.sql, "dbversion", 0);
let e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1);
let mdns_enabled = sql::get_config_int(context, &context.sql, "mdns_enabled", 1);
let is_configured = context.sql.get_config_int(context, "configured", 0);
let dbversion = context.sql.get_config_int(context, "dbversion", 0);
let e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
let mdns_enabled = context.sql.get_config_int(context, "mdns_enabled", 1);
let prv_key_cnt: Option<isize> = sql::query_row(
let prv_key_cnt: Option<isize> = context.sql.query_row_col(
context,
&context.sql,
"SELECT COUNT(*) FROM keypairs;",
rusqlite::NO_PARAMS,
0,
);
let pub_key_cnt: Option<isize> = sql::query_row(
let pub_key_cnt: Option<isize> = context.sql.query_row_col(
context,
&context.sql,
"SELECT COUNT(*) FROM acpeerstates;",
rusqlite::NO_PARAMS,
0,
@@ -411,23 +409,19 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
let l_readable_str = dc_loginparam_get_readable(&l);
let l2_readable_str = dc_loginparam_get_readable(&l2);
let inbox_watch = sql::get_config_int(context, &context.sql, "inbox_watch", 1);
let sentbox_watch = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
let mvbox_watch = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
let mvbox_move = sql::get_config_int(context, &context.sql, "mvbox_move", 1);
let folders_configured = sql::get_config_int(context, &context.sql, "folders_configured", 0);
let configured_sentbox_folder = sql::get_config(
context,
&context.sql,
"configured_sentbox_folder",
Some("<unset>"),
);
let configured_mvbox_folder = sql::get_config(
context,
&context.sql,
"configured_mvbox_folder",
Some("<unset>"),
);
let inbox_watch = context.sql.get_config_int(context, "inbox_watch", 1);
let sentbox_watch = context.sql.get_config_int(context, "sentbox_watch", 1);
let mvbox_watch = context.sql.get_config_int(context, "mvbox_watch", 1);
let mvbox_move = context.sql.get_config_int(context, "mvbox_move", 1);
let folders_configured = context.sql.get_config_int(context, "folders_configured", 0);
let configured_sentbox_folder =
context
.sql
.get_config(context, "configured_sentbox_folder", Some("<unset>"));
let configured_mvbox_folder =
context
.sql
.get_config(context, "configured_mvbox_folder", Some("<unset>"));
let res = format!(
"deltachat_core_version=v{}\n\
@@ -589,7 +583,9 @@ pub fn dc_is_inbox(_context: &Context, folder_name: impl AsRef<str>) -> bool {
}
pub fn dc_is_sentbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
let sentbox_name = sql::get_config(context, &context.sql, "configured_sentbox_folder", None);
let sentbox_name = context
.sql
.get_config(context, "configured_sentbox_folder", None);
if let Some(name) = sentbox_name {
name == folder_name.as_ref()
} else {
@@ -598,7 +594,9 @@ pub fn dc_is_sentbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
}
pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
let mvbox_name = sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
let mvbox_name = context
.sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(name) = mvbox_name {
name == folder_name.as_ref()

129
src/dc_chat.rs
View File

@@ -484,7 +484,7 @@ unsafe fn prepare_msg_raw(
"Cannot send message; self not in group.",
);
} else {
let from = sql::get_config(context, &context.sql, "configured_addr", None);
let from = context.sql.get_config(context, "configured_addr", None);
if from.is_none() {
error!(context, 0, "Cannot send message, not configured.",);
} else {
@@ -499,9 +499,8 @@ unsafe fn prepare_msg_raw(
);
if (*chat).type_0 == 100 {
if let Some(id) = sql::query_row(
if let Some(id) = context.sql.query_row_col(
context,
&context.sql,
"SELECT contact_id FROM chats_contacts WHERE chat_id=?;",
params![(*chat).id as i32],
0,
@@ -534,7 +533,7 @@ unsafe fn prepare_msg_raw(
so that E2EE is no longer available at a later point (reset, changed settings),
we do not send the message out at all */
do_guarantee_e2ee = 0;
e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1);
e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
if 0 != e2ee_enabled && dc_param_get_int((*msg).param, 'u' as i32, 0) == 0 {
let mut can_encrypt: libc::c_int = 1;
let mut all_mutual: libc::c_int = 1;
@@ -799,9 +798,8 @@ unsafe fn last_msg_in_chat_encrypted(
chat_id: uint32_t,
) -> libc::c_int {
let mut last_is_encrypted: libc::c_int = 0i32;
let packed: Option<String> = sql::query_row(
let packed: Option<String> = sql.query_row_col(
context,
sql,
"SELECT param \
FROM msgs WHERE timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=?) \
ORDER BY id DESC;",
@@ -1012,14 +1010,15 @@ unsafe fn set_draft_raw(context: &Context, chat_id: uint32_t, msg: *mut dc_msg_t
}
fn get_draft_msg_id(context: &Context, chat_id: u32) -> u32 {
let draft_msg_id: i32 = sql::query_row(
context,
&context.sql,
"SELECT id FROM msgs WHERE chat_id=? AND state=?;",
params![chat_id as i32, 19],
0,
)
.unwrap_or_default();
let draft_msg_id: i32 = context
.sql
.query_row_col(
context,
"SELECT id FROM msgs WHERE chat_id=? AND state=?;",
params![chat_id as i32, 19],
0,
)
.unwrap_or_default();
draft_msg_id as u32
}
@@ -1076,7 +1075,7 @@ pub unsafe fn dc_get_chat_msgs(
};
let success = if chat_id == 1 {
let show_emails = sql::get_config_int(context, &context.sql, "show_emails", 0);
let show_emails = context.sql.get_config_int(context, "show_emails", 0);
context.sql.query_map(
"SELECT m.id, m.timestamp FROM msgs m \
LEFT JOIN chats ON m.chat_id=chats.id \
@@ -1125,28 +1124,30 @@ pub unsafe fn dc_get_chat_msgs(
}
pub fn dc_get_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM msgs WHERE chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM msgs WHERE chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
}
pub fn dc_get_fresh_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM msgs \
WHERE state=10 \
AND hidden=0 \
AND chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM msgs \
WHERE state=10 \
AND hidden=0 \
AND chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
}
pub fn dc_marknoticed_chat(context: &Context, chat_id: u32) -> bool {
@@ -1518,7 +1519,9 @@ pub unsafe fn dc_add_contact_to_chat_ex(
dc_param_set((*chat).param, 'U' as i32, 0 as *const libc::c_char);
dc_chat_update_param(chat);
}
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""))
let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
if as_str((*contact).addr) != &self_addr {
// ourself is added using DC_CONTACT_ID_SELF, do not add it explicitly.
@@ -2039,16 +2042,18 @@ pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char {
if (*chat).type_0 == 100 && 0 != dc_param_exists((*chat).param, 'K' as i32) {
ret = dc_stock_str((*chat).context, 50)
} else if (*chat).type_0 == 100 {
let ret_raw: String = sql::query_row(
(*chat).context,
&(*chat).context.sql,
"SELECT c.addr FROM chats_contacts cc \
LEFT JOIN contacts c ON c.id=cc.contact_id \
WHERE cc.chat_id=?;",
params![(*chat).id as i32],
0,
)
.unwrap_or_else(|| "Err".into());
let ret_raw: String = (*chat)
.context
.sql
.query_row_col(
(*chat).context,
"SELECT c.addr FROM chats_contacts cc \
LEFT JOIN contacts c ON c.id=cc.contact_id \
WHERE cc.chat_id=?;",
params![(*chat).id as i32],
0,
)
.unwrap_or_else(|| "Err".into());
ret = dc_strdup(to_cstring(ret_raw).as_ptr());
} else if (*chat).type_0 == 120 || (*chat).type_0 == 130 {
if (*chat).id == 1 {
@@ -2066,14 +2071,15 @@ pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char {
}
pub fn dc_get_chat_contact_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;",
params![chat_id as i32],
0,
)
.unwrap_or_default()
}
pub unsafe fn dc_chat_get_profile_image(chat: *const Chat) -> *mut libc::c_char {
@@ -2164,14 +2170,15 @@ pub unsafe fn dc_chat_is_sending_locations(chat: *const Chat) -> libc::c_int {
pub fn dc_get_chat_cnt(context: &Context) -> usize {
if context.sql.is_open() {
/* no database, no chats - this is no error (needed eg. for information) */
sql::query_row::<_, isize>(
context,
&context.sql,
"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;",
params![],
0,
)
.unwrap_or_default() as usize
context
.sql
.query_row_col::<_, isize>(
context,
"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;",
params![],
0,
)
.unwrap_or_default() as usize
} else {
0
}

43
src/dc_chatlist.rs
View File

@@ -6,7 +6,6 @@ use crate::dc_lot::*;
use crate::dc_msg::*;
use crate::dc_stock::*;
use crate::dc_tools::*;
use crate::sql;
use crate::types::*;
use crate::x::*;
@@ -256,30 +255,32 @@ unsafe fn dc_chatlist_load_from_db(
// Context functions to work with chatlist
pub fn dc_get_archived_cnt(context: &Context) -> libc::c_int {
sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;",
params![],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;",
params![],
0,
)
.unwrap_or_default()
}
fn get_last_deaddrop_fresh_msg(context: &Context) -> u32 {
// we have an index over the state-column, this should be sufficient as there are typically only few fresh messages
sql::query_row(
context,
&context.sql,
"SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
WHERE m.state=10 \
AND m.hidden=0 \
AND c.blocked=2 \
ORDER BY m.timestamp DESC, m.id DESC;",
params![],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
WHERE m.state=10 \
AND m.hidden=0 \
AND c.blocked=2 \
ORDER BY m.timestamp DESC, m.id DESC;",
params![],
0,
)
.unwrap_or_default()
}
pub unsafe fn dc_chatlist_get_cnt(chatlist: *const dc_chatlist_t) -> size_t {

61
src/dc_configure.rs
View File

@@ -9,7 +9,6 @@ use crate::dc_saxparser::*;
use crate::dc_tools::*;
use crate::imap::*;
use crate::oauth2::*;
use crate::sql;
use crate::types::*;
use crate::x::*;
@@ -75,7 +74,7 @@ pub unsafe fn dc_has_ongoing(context: &Context) -> libc::c_int {
}
}
pub fn dc_is_configured(context: &Context) -> libc::c_int {
if sql::get_config_int(context, &context.sql, "configured", 0) > 0 {
if context.sql.get_config_int(context, "configured", 0) > 0 {
1
} else {
0
@@ -168,12 +167,9 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
.and_then(|e| e.parse().ok())
{
param.addr = oauth2_addr;
sql::set_config(
context,
&context.sql,
"addr",
Some(param.addr.as_str()),
);
context
.sql
.set_config(context, "addr", Some(param.addr.as_str()));
}
if s.shall_stop_ongoing {
current_block = 2927484062889439186;
@@ -900,25 +896,21 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
as uintptr_t,
0 as uintptr_t,
);
flags
=
if 0
!=
sql::get_config_int(
context, &context.sql,
"mvbox_watch",
1
)
||
0
!=
sql::get_config_int(
context,
&context.sql,
"mvbox_move",
1
)
{
flags = if 0
!= context
.sql
.get_config_int(
context,
"mvbox_watch",
1,
)
|| 0 != context
.sql
.get_config_int(
context,
"mvbox_move",
1,
) {
0x1
} else {
0
@@ -959,12 +951,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
&context.sql,
"configured_",
);
sql::set_config_int(
context,
&context.sql,
"configured",
1,
);
context
.sql
.set_config_int(
context,
"configured",
1,
);
if !s.shall_stop_ongoing
{
context.call_cb(
@@ -1489,7 +1482,7 @@ pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_
if imap.is_connected() {
ret_connected = 1
} else if sql::get_config_int(context, &context.sql, "configured", 0) == 0 {
} else if context.sql.get_config_int(context, "configured", 0) == 0 {
warn!(context, 0, "Not configured, cannot connect.",);
} else {
let param = dc_loginparam_read(context, &context.sql, "configured_");

100
src/dc_contact.rs
View File

@@ -70,15 +70,16 @@ pub unsafe fn dc_lookup_contact_id_by_addr(
let addr_normalized_c = dc_addr_normalize(addr);
let addr_normalized = as_str(addr_normalized_c);
let addr_self =
sql::get_config(context, &context.sql, "configured_addr", None).unwrap_or_default();
let addr_self = context
.sql
.get_config(context, "configured_addr", None)
.unwrap_or_default();
let contact_id = if addr_normalized == addr_self {
1
} else {
sql::query_row(
context.sql.query_row_col(
context,
&context.sql,
"SELECT id FROM contacts WHERE addr=?1 COLLATE NOCASE AND id>?2 AND origin>=?3 AND blocked=0;",
params![addr_normalized, 9, 0x100],
0
@@ -274,7 +275,10 @@ pub unsafe fn dc_contact_load_from_db(
(*contact).name = dc_stock_str((*contact).context, 2);
(*contact).addr = dc_strdup(
to_cstring(
sql::get_config((*contact).context, sql, "configured_addr", Some(""))
(*contact)
.context
.sql
.get_config((*contact).context, "configured_addr", Some(""))
.unwrap_or_default(),
)
.as_ptr(),
@@ -331,8 +335,10 @@ pub fn dc_add_or_lookup_contact(
let addr_c = unsafe { dc_addr_normalize(addr__) };
let addr = as_str(addr_c);
let addr_self =
sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap_or_default();
let addr_self = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
if addr == addr_self {
return 1;
@@ -519,8 +525,10 @@ pub fn dc_get_contacts(
listflags: u32,
query: *const libc::c_char,
) -> *mut dc_array_t {
let self_addr =
sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap_or_default();
let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
let mut add_self = false;
let ret = unsafe { dc_array_new(100) };
@@ -558,8 +566,10 @@ pub fn dc_get_contacts(
)
.unwrap(); // TODO: Better error handling
let self_name =
sql::get_config(context, &context.sql, "displayname", Some("")).unwrap_or_default();
let self_name = context
.sql
.get_config(context, "displayname", Some(""))
.unwrap_or_default();
let self_name2 = unsafe { dc_stock_str(context, 2) };
@@ -595,14 +605,15 @@ pub fn dc_get_contacts(
}
pub fn dc_get_blocked_cnt(context: &Context) -> libc::c_int {
sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
params![9],
0,
)
.unwrap_or_default()
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
params![9],
0,
)
.unwrap_or_default()
}
pub fn dc_get_blocked_contacts(context: &Context) -> *mut dc_array_t {
@@ -757,24 +768,26 @@ pub fn dc_delete_contact(context: &Context, contact_id: u32) -> bool {
return false;
}
let count_contacts: i32 = sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;",
params![contact_id as i32],
0,
)
.unwrap_or_default();
let count_msgs: i32 = if count_contacts > 0 {
sql::query_row(
let count_contacts: i32 = context
.sql
.query_row_col(
context,
&context.sql,
"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;",
params![contact_id as i32, contact_id as i32],
"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;",
params![contact_id as i32],
0,
)
.unwrap_or_default()
.unwrap_or_default();
let count_msgs: i32 = if count_contacts > 0 {
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;",
params![contact_id as i32, contact_id as i32],
0,
)
.unwrap_or_default()
} else {
0
};
@@ -974,7 +987,7 @@ pub fn dc_addr_equals_self(context: &Context, addr: *const libc::c_char) -> libc
if !addr.is_null() {
let normalized_addr = unsafe { dc_addr_normalize(addr) };
if let Some(self_addr) = sql::get_config(context, &context.sql, "configured_addr", None) {
if let Some(self_addr) = context.sql.get_config(context, "configured_addr", None) {
ret = (as_str(normalized_addr) == self_addr) as libc::c_int;
}
unsafe { free(normalized_addr as *mut libc::c_void) };
@@ -1014,14 +1027,15 @@ pub fn dc_get_real_contact_cnt(context: &Context) -> usize {
return 0;
}
sql::query_row::<_, isize>(
context,
&context.sql,
"SELECT COUNT(*) FROM contacts WHERE id>?;",
params![9],
0,
)
.unwrap_or_default() as usize
context
.sql
.query_row_col::<_, isize>(
context,
"SELECT COUNT(*) FROM contacts WHERE id>?;",
params![9],
0,
)
.unwrap_or_default() as usize
}
pub unsafe fn dc_get_contact_origin(

9
src/dc_e2ee.rs
View File

@@ -24,7 +24,6 @@ use crate::key::*;
use crate::keyring::*;
use crate::peerstate::*;
use crate::pgp::*;
use crate::sql;
use crate::types::*;
use crate::x::*;
@@ -81,13 +80,13 @@ pub unsafe fn dc_e2ee_encrypt(
|| plain.is_null())
{
/* libEtPan's pgp_encrypt_mime() takes the parent as the new root. We just expect the root as being given to this function. */
let prefer_encrypt = if 0 != sql::get_config_int(context, &context.sql, "e2ee_enabled", 1) {
let prefer_encrypt = if 0 != context.sql.get_config_int(context, "e2ee_enabled", 1) {
EncryptPreference::Mutual
} else {
EncryptPreference::NoPreference
};
let addr = sql::get_config(context, &context.sql, "configured_addr", None);
let addr = context.sql.get_config(context, "configured_addr", None);
if let Some(addr) = addr {
if let Some(public_key) =
@@ -597,7 +596,7 @@ pub unsafe fn dc_e2ee_decrypt(
}
}
/* load private key for decryption */
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
let self_addr = context.sql.get_config(context, "configured_addr", None);
if let Some(self_addr) = self_addr {
if private_keyring.load_self_private_for_decrypting(context, self_addr, &context.sql) {
if peerstate.as_ref().map(|p| p.last_seen).unwrap_or_else(|| 0) == 0 {
@@ -1066,7 +1065,7 @@ pub unsafe fn dc_ensure_secret_key_exists(context: &Context) -> libc::c_int {
(this is to gain some extra-random-seed by the message content and the timespan between program start and message sending) */
let mut success: libc::c_int = 0i32;
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
let self_addr = context.sql.get_config(context, "configured_addr", None);
if self_addr.is_none() {
warn!(
context,

36
src/dc_imex.rs
View File

@@ -69,8 +69,7 @@ pub unsafe fn dc_imex_has_backup(
if name.starts_with("delta-chat") && name.ends_with(".bak") {
let sql = Sql::new();
if sql.open(context, &path, 0x1) {
let curr_backup_time =
sql::get_config_int(context, &sql, "backup_time", 0) as u64;
let curr_backup_time = sql.get_config_int(context, "backup_time", 0) as u64;
if curr_backup_time > newest_backup_time {
newest_backup_path = Some(path);
newest_backup_time = curr_backup_time;
@@ -223,10 +222,12 @@ pub unsafe extern "C" fn dc_render_setup_file(
passphrase_begin[2usize] = 0i32 as libc::c_char;
/* create the payload */
if !(0 == dc_ensure_secret_key_exists(context)) {
let self_addr =
sql::get_config(context, &context.sql, "configured_addr", None).unwrap_or_default();
let self_addr = context
.sql
.get_config(context, "configured_addr", None)
.unwrap_or_default();
let curr_private_key = Key::from_self_private(context, self_addr, &context.sql);
let e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1);
let e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
let headers = if 0 != e2ee_enabled {
Some(("Autocrypt-Prefer-Encrypt", "mutual"))
@@ -409,7 +410,7 @@ fn set_self_key(
error!(context, 0, "File does not contain a private key.",);
}
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
let self_addr = context.sql.get_config(context, "configured_addr", None);
if self_addr.is_none() {
error!(context, 0, "Missing self addr");
@@ -430,8 +431,8 @@ fn set_self_key(
match preferencrypt.map(|s| s.as_str()) {
Some("") => 0,
Some("nopreference") => sql::set_config_int(context, &context.sql, "e2ee_enabled", 0),
Some("mutual") => sql::set_config_int(context, &context.sql, "e2ee_enabled", 1),
Some("nopreference") => context.sql.set_config_int(context, "e2ee_enabled", 0),
Some("mutual") => context.sql.set_config_int(context, "e2ee_enabled", 1),
_ => 1,
}
}
@@ -781,14 +782,10 @@ unsafe fn import_backup(context: &Context, backup_to_import: *const libc::c_char
return 0;
}
let total_files_cnt = sql::query_row::<_, isize>(
context,
&context.sql,
"SELECT COUNT(*) FROM backup_blobs;",
params![],
0,
)
.unwrap_or_default() as usize;
let total_files_cnt = context
.sql
.query_row_col::<_, isize>(context, "SELECT COUNT(*) FROM backup_blobs;", params![], 0)
.unwrap_or_default() as usize;
info!(
context,
0, "***IMPORT-in-progress: total_files_cnt={:?}", total_files_cnt,
@@ -1040,12 +1037,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
match current_block {
11487273724841241105 => {}
_ => {
if 0 != sql::set_config_int(
context,
&sql,
"backup_time",
now as i32,
) {
if 0 != sql.set_config_int(context, "backup_time", now as i32) {
context.call_cb(
Event::IMEX_FILE_WRITTEN,
dest_pathNfilename as uintptr_t,

72
src/dc_job.rs
View File

@@ -355,14 +355,15 @@ unsafe fn dc_job_do_DC_JOB_SEND(context: &Context, job: &mut dc_job_t) {
dc_delete_file(context, filename);
if 0 != job.foreign_id {
dc_update_msg_state(context, job.foreign_id, 26i32);
let chat_id: i32 = sql::query_row(
context,
&context.sql,
"SELECT chat_id FROM msgs WHERE id=?",
params![job.foreign_id as i32],
0,
)
.unwrap_or_default();
let chat_id: i32 = context
.sql
.query_row_col(
context,
"SELECT chat_id FROM msgs WHERE id=?",
params![job.foreign_id as i32],
0,
)
.unwrap_or_default();
context.call_cb(
Event::MSG_DELIVERED,
chat_id as uintptr_t,
@@ -414,11 +415,12 @@ unsafe fn dc_job_do_DC_JOB_MOVE_MSG(context: &Context, job: &mut dc_job_t) {
match current_block {
2473556513754201174 => {
if dc_msg_load_from_db(msg, context, job.foreign_id) {
if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
inbox.configure_folders(context, 0x1i32);
}
let dest_folder =
sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
let dest_folder = context
.sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(dest_folder) = dest_folder {
let server_folder = as_str((*msg).server_folder);
@@ -510,11 +512,12 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context: &Context, job: &mut dc_
dc_job_try_again_later(job, 3i32, 0 as *const libc::c_char);
}
if 0 != dc_param_get_int(job.param, 'M' as i32, 0i32) {
if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
inbox.configure_folders(context, 0x1i32);
}
let dest_folder =
sql::get_config(context, &context.sql, "configured_mvbox_folder", None);
let dest_folder = context
.sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(dest_folder) = dest_folder {
if 1 == inbox.mv(context, folder, uid, dest_folder, &mut dest_uid)
as libc::c_uint
@@ -559,12 +562,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_
}
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != sql::get_config_int(
context,
&context.sql,
"mdns_enabled",
1,
)
&& 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
{
let folder =
CStr::from_ptr((*msg).server_folder).to_str().unwrap();
@@ -615,12 +613,7 @@ unsafe fn dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context: &Context, job: &mut dc_
}
_ => {
if 0 != dc_param_get_int((*msg).param, 'r' as i32, 0i32)
&& 0 != sql::get_config_int(
context,
&context.sql,
"mdns_enabled",
1,
)
&& 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
{
let folder =
CStr::from_ptr((*msg).server_folder).to_str().unwrap();
@@ -909,7 +902,7 @@ pub unsafe fn dc_perform_imap_fetch(context: &Context) {
if 0 == connect_to_inbox(context, &inbox) {
return;
}
if sql::get_config_int(context, &context.sql, "inbox_watch", 1) == 0 {
if context.sql.get_config_int(context, "inbox_watch", 1) == 0 {
info!(context, 0, "INBOX-watch disabled.",);
return;
}
@@ -945,7 +938,7 @@ pub fn dc_perform_imap_idle(context: &Context) {
}
pub unsafe fn dc_perform_mvbox_fetch(context: &Context) {
let use_network = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
let use_network = context.sql.get_config_int(context, "mvbox_watch", 1);
dc_jobthread_fetch(
context,
&mut context.mvbox_thread.clone().write().unwrap(),
@@ -954,7 +947,7 @@ pub unsafe fn dc_perform_mvbox_fetch(context: &Context) {
}
pub unsafe fn dc_perform_mvbox_idle(context: &Context) {
let use_network = sql::get_config_int(context, &context.sql, "mvbox_watch", 1);
let use_network = context.sql.get_config_int(context, "mvbox_watch", 1);
dc_jobthread_idle(
context,
@@ -968,7 +961,7 @@ pub unsafe fn dc_interrupt_mvbox_idle(context: &Context) {
}
pub unsafe fn dc_perform_sentbox_fetch(context: &Context) {
let use_network = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
let use_network = context.sql.get_config_int(context, "sentbox_watch", 1);
dc_jobthread_fetch(
context,
&mut context.sentbox_thread.clone().write().unwrap(),
@@ -977,7 +970,7 @@ pub unsafe fn dc_perform_sentbox_fetch(context: &Context) {
}
pub unsafe fn dc_perform_sentbox_idle(context: &Context) {
let use_network = sql::get_config_int(context, &context.sql, "sentbox_watch", 1);
let use_network = context.sql.get_config_int(context, "sentbox_watch", 1);
dc_jobthread_idle(
context,
&context.sentbox_thread.clone().read().unwrap(),
@@ -1049,14 +1042,15 @@ pub unsafe fn dc_perform_smtp_idle(context: &Context) {
}
unsafe fn get_next_wakeup_time(context: &Context, thread: libc::c_int) -> Duration {
let t: i64 = sql::query_row(
context,
&context.sql,
"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;",
params![thread],
0,
)
.unwrap_or_default();
let t: i64 = context
.sql
.query_row_col(
context,
"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;",
params![thread],
0,
)
.unwrap_or_default();
let mut wakeup_time = Duration::new(10 * 60, 0);
let now = time();

7
src/dc_jobthread.rs
View File

@@ -3,7 +3,6 @@ use std::sync::{Arc, Condvar, Mutex};
use crate::context::Context;
use crate::dc_configure::*;
use crate::imap::Imap;
use crate::sql;
use crate::x::*;
#[repr(C)]
@@ -137,12 +136,14 @@ unsafe fn connect_to_imap(context: &Context, jobthread: &dc_jobthread_t) -> libc
let mut ret_connected = dc_connect_to_configured_imap(context, &jobthread.imap);
if !(0 == ret_connected) {
if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 {
if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
jobthread.imap.configure_folders(context, 0x1);
}
if let Some(mvbox_name) =
sql::get_config(context, &context.sql, jobthread.folder_config_name, None)
context
.sql
.get_config(context, jobthread.folder_config_name, None)
{
jobthread.imap.set_watch_folder(mvbox_name);
} else {

2
src/dc_location.rs
View File

@@ -261,7 +261,7 @@ pub fn dc_get_location_kml(
let mut location_count: libc::c_int = 0;
let mut ret = String::new();
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""));
let self_addr = context.sql.get_config(context, "configured_addr", Some(""));
if self_addr.is_none() {
return std::ptr::null_mut();

43
src/dc_loginparam.rs
View File

@@ -1,7 +1,7 @@
use std::borrow::Cow;
use crate::context::Context;
use crate::sql::{self, Sql};
use crate::sql::Sql;
#[derive(Default, Debug)]
pub struct dc_loginparam_t {
@@ -35,37 +35,38 @@ pub fn dc_loginparam_read(
let prefix = prefix.as_ref();
let key = format!("{}addr", prefix);
let addr = sql::get_config(context, sql, key, None)
let addr = sql
.get_config(context, key, None)
.unwrap_or_default()
.trim()
.to_string();
let key = format!("{}mail_server", prefix);
let mail_server = sql::get_config(context, sql, key, None).unwrap_or_default();
let mail_server = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}mail_port", prefix);
let mail_port = sql::get_config_int(context, sql, key, 0);
let mail_port = sql.get_config_int(context, key, 0);
let key = format!("{}mail_user", prefix);
let mail_user = sql::get_config(context, sql, key, None).unwrap_or_default();
let mail_user = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}mail_pw", prefix);
let mail_pw = sql::get_config(context, sql, key, None).unwrap_or_default();
let mail_pw = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_server", prefix);
let send_server = sql::get_config(context, sql, key, None).unwrap_or_default();
let send_server = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_port", prefix);
let send_port = sql::get_config_int(context, sql, key, 0);
let send_port = sql.get_config_int(context, key, 0);
let key = format!("{}send_user", prefix);
let send_user = sql::get_config(context, sql, key, None).unwrap_or_default();
let send_user = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_pw", prefix);
let send_pw = sql::get_config(context, sql, key, None).unwrap_or_default();
let send_pw = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}server_flags", prefix);
let server_flags = sql::get_config_int(context, sql, key, 0);
let server_flags = sql.get_config_int(context, key, 0);
dc_loginparam_t {
addr: addr.to_string(),
@@ -90,34 +91,34 @@ pub fn dc_loginparam_write(
let prefix = prefix.as_ref();
let key = format!("{}addr", prefix);
sql::set_config(context, sql, key, Some(&loginparam.addr));
sql.set_config(context, key, Some(&loginparam.addr));
let key = format!("{}mail_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_server));
sql.set_config(context, key, Some(&loginparam.mail_server));
let key = format!("{}mail_port", prefix);
sql::set_config_int(context, sql, key, loginparam.mail_port);
sql.set_config_int(context, key, loginparam.mail_port);
let key = format!("{}mail_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_user));
sql.set_config(context, key, Some(&loginparam.mail_user));
let key = format!("{}mail_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_pw));
sql.set_config(context, key, Some(&loginparam.mail_pw));
let key = format!("{}send_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_server));
sql.set_config(context, key, Some(&loginparam.send_server));
let key = format!("{}send_port", prefix);
sql::set_config_int(context, sql, key, loginparam.send_port);
sql.set_config_int(context, key, loginparam.send_port);
let key = format!("{}send_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_user));
sql.set_config(context, key, Some(&loginparam.send_user));
let key = format!("{}send_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_pw));
sql.set_config(context, key, Some(&loginparam.send_pw));
let key = format!("{}server_flags", prefix);
sql::set_config_int(context, sql, key, loginparam.server_flags);
sql.set_config_int(context, key, loginparam.server_flags);
}
fn unset_empty(s: &String) -> Cow<String> {

52
src/dc_mimefactory.rs
View File

@@ -19,7 +19,6 @@ use crate::dc_param::*;
use crate::dc_stock::*;
use crate::dc_strencode::*;
use crate::dc_tools::*;
use crate::sql;
use crate::types::*;
use crate::x::*;
@@ -196,7 +195,9 @@ pub unsafe fn dc_mimefactory_load_msg(
0 as *const libc::c_char,
);
let email_to_remove = to_string(email_to_remove_c);
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""))
let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
if !email_to_remove.is_empty() && email_to_remove != self_addr {
@@ -218,7 +219,7 @@ pub unsafe fn dc_mimefactory_load_msg(
}
if command != 6
&& command != 7
&& 0 != sql::get_config_int(context, &context.sql, "mdns_enabled", 1)
&& 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
{
(*factory).req_mdn = 1
}
@@ -261,39 +262,31 @@ pub unsafe fn dc_mimefactory_load_msg(
}
unsafe fn load_from(mut factory: *mut dc_mimefactory_t) {
let context = (*factory).context;
(*factory).from_addr = strdup(
to_cstring(
sql::get_config(
(*factory).context,
&(*factory).context.sql,
"configured_addr",
None,
)
.unwrap_or_default(),
context
.sql
.get_config(context, "configured_addr", None)
.unwrap_or_default(),
)
.as_ptr(),
);
(*factory).from_displayname = strdup(
to_cstring(
sql::get_config(
(*factory).context,
&(*factory).context.sql,
"displayname",
None,
)
.unwrap_or_default(),
context
.sql
.get_config(context, "displayname", None)
.unwrap_or_default(),
)
.as_ptr(),
);
(*factory).selfstatus = strdup(
to_cstring(
sql::get_config(
(*factory).context,
&(*factory).context.sql,
"selfstatus",
None,
)
.unwrap_or_default(),
context
.sql
.get_config(context, "selfstatus", None)
.unwrap_or_default(),
)
.as_ptr(),
);
@@ -316,12 +309,11 @@ pub unsafe fn dc_mimefactory_load_mdn(
(*factory).recipients_names = clist_new();
(*factory).recipients_addr = clist_new();
(*factory).msg = dc_msg_new_untyped((*factory).context);
if 0 != sql::get_config_int(
(*factory).context,
&(*factory).context.sql,
"mdns_enabled",
1,
) {
if 0 != (*factory)
.context
.sql
.get_config_int((*factory).context, "mdns_enabled", 1)
{
// MDNs not enabled - check this is late, in the job. the use may have changed its choice while offline ...
contact = dc_contact_new((*factory).context);
if !(!dc_msg_load_from_db((*factory).msg, (*factory).context, msg_id)

3
src/dc_move.rs
View File

@@ -2,10 +2,9 @@ use crate::constants::*;
use crate::context::*;
use crate::dc_job::*;
use crate::dc_msg::*;
use crate::sql;
pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
if sql::get_config_int(context, &context.sql, "mvbox_move", 1) == 0 {
if context.sql.get_config_int(context, "mvbox_move", 1) == 0 {
return;
}

26
src/dc_msg.rs
View File

@@ -52,9 +52,8 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
dc_msg_load_from_db(msg, context, msg_id);
dc_contact_load_from_db(contact_from, &context.sql, (*msg).from_id);
let rawtxt: Option<String> = sql::query_row(
let rawtxt: Option<String> = context.sql.query_row_col(
context,
&context.sql,
"SELECT txt_raw FROM msgs WHERE id=?;",
params![msg_id as i32],
0,
@@ -487,9 +486,8 @@ pub fn dc_msg_load_from_db<'a>(msg: *mut dc_msg_t<'a>, context: &'a Context, id:
}
pub unsafe fn dc_get_mime_headers(context: &Context, msg_id: uint32_t) -> *mut libc::c_char {
let headers: Option<String> = sql::query_row(
let headers: Option<String> = context.sql.query_row_col(
context,
&context.sql,
"SELECT mime_headers FROM msgs WHERE id=?;",
params![msg_id as i32],
0,
@@ -1132,9 +1130,8 @@ pub unsafe fn dc_msg_exists(context: &Context, msg_id: uint32_t) -> libc::c_int
return 0;
}
let chat_id: Option<i32> = sql::query_row(
let chat_id: Option<i32> = context.sql.query_row_col(
context,
&context.sql,
"SELECT chat_id FROM msgs WHERE id=?;",
params![msg_id as i32],
0,
@@ -1255,14 +1252,15 @@ pub unsafe fn dc_mdn_from_ext(
read_by_all = 1;
} else {
/* send event about new state */
let ist_cnt: i32 = sql::query_row(
context,
&context.sql,
"SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;",
params![*ret_msg_id as i32],
0,
)
.unwrap_or_default();
let ist_cnt: i32 = context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;",
params![*ret_msg_id as i32],
0,
)
.unwrap_or_default();
/*
Groupsize: Min. MDNs

30
src/dc_receive_imf.rs
View File

@@ -217,7 +217,7 @@ pub unsafe fn dc_receive_imf(
let mut allow_creation: libc::c_int = 1;
if msgrmsg == 0 {
let show_emails: libc::c_int =
sql::get_config_int(context, &context.sql, "show_emails", 0);
context.sql.get_config_int(context, "show_emails", 0);
if show_emails == 0 {
chat_id = 3 as uint32_t;
allow_creation = 0
@@ -404,7 +404,7 @@ pub unsafe fn dc_receive_imf(
// if the mime-headers should be saved, find out its size
// (the mime-header ends with an empty line)
let save_mime_headers =
sql::get_config_int(context, &context.sql, "save_mime_headers", 0);
context.sql.get_config_int(context, "save_mime_headers", 0);
field = dc_mimeparser_lookup_field(&mime_parser, "In-Reply-To");
if !field.is_null()
&& (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int
@@ -581,8 +581,7 @@ pub unsafe fn dc_receive_imf(
16282941964262048061 => {}
_ => {
if carray_count(mime_parser.reports) > 0 as libc::c_uint {
let mdns_enabled =
sql::get_config_int(context, &context.sql, "mdns_enabled", 1);
let mdns_enabled = context.sql.get_config_int(context, "mdns_enabled", 1);
icnt = carray_count(mime_parser.reports) as size_t;
i = 0 as size_t;
while i < icnt {
@@ -740,12 +739,7 @@ pub unsafe fn dc_receive_imf(
);
dc_param_set_int(param, 'z' as i32, server_uid as i32);
if 0 != mime_parser.is_send_by_messenger
&& 0 != sql::get_config_int(
context,
&context.sql,
"mvbox_move",
1,
)
&& 0 != context.sql.get_config_int(context, "mvbox_move", 1)
{
dc_param_set_int(param, 'M' as i32, 1);
}
@@ -860,9 +854,8 @@ unsafe fn calc_timestamps(
}
*sort_timestamp = message_timestamp;
if 0 != is_fresh_msg {
let last_msg_time: Option<i64> = sql::query_row(
let last_msg_time: Option<i64> = context.sql.query_row_col(
context,
&context.sql,
"SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?",
params![chat_id as i32, from_id as i32, *sort_timestamp],
0,
@@ -1107,7 +1100,9 @@ unsafe fn create_or_lookup_group(
}
/* check if the group does not exist but should be created */
group_explicitly_left = dc_is_group_explicitly_left(context, grpid);
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some(""))
let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
if chat_id == 0 as libc::c_uint
&& 0 == dc_mimeparser_is_mailinglist_message(mime_parser)
@@ -1473,7 +1468,9 @@ unsafe fn create_adhoc_grp_id(context: &Context, member_ids: *mut dc_array_t) ->
- encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f])
*/
let member_ids_str = dc_array_get_string(member_ids, b",\x00" as *const u8 as *const _);
let member_cs = sql::get_config(context, &context.sql, "configured_addr", Some("no-self"))
let member_cs = context
.sql
.get_config(context, "configured_addr", Some("no-self"))
.unwrap()
.to_lowercase();
@@ -1979,7 +1976,10 @@ unsafe fn add_or_lookup_contact_by_addr(
return;
}
*check_self = 0;
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap();
let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap();
if dc_addr_cmp(self_addr, as_str(addr_spec)) {
*check_self = 1;

27
src/dc_securejoin.rs
View File

@@ -20,7 +20,6 @@ use crate::dc_token::*;
use crate::dc_tools::*;
use crate::key::*;
use crate::peerstate::*;
use crate::sql;
use crate::types::*;
use crate::x::*;
@@ -52,7 +51,7 @@ pub unsafe fn dc_get_securejoin_qr(
auth = dc_create_id();
dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
}
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None);
let self_addr = context.sql.get_config(context, "configured_addr", None);
let cleanup = |fingerprint, chat, group_name, group_name_urlencoded| {
free(fingerprint as *mut libc::c_void);
@@ -75,7 +74,10 @@ pub unsafe fn dc_get_securejoin_qr(
}
let self_addr = self_addr.unwrap();
let self_name = sql::get_config(context, &context.sql, "displayname", Some("")).unwrap();
let self_name = context
.sql
.get_config(context, "displayname", Some(""))
.unwrap();
fingerprint = get_self_fingerprint(context);
if fingerprint.is_null() {
@@ -124,7 +126,7 @@ pub unsafe fn dc_get_securejoin_qr(
}
fn get_self_fingerprint(context: &Context) -> *mut libc::c_char {
if let Some(self_addr) = sql::get_config(context, &context.sql, "configured_addr", None) {
if let Some(self_addr) = context.sql.get_config(context, "configured_addr", None) {
if let Some(key) = Key::from_self_public(context, self_addr, &context.sql) {
return key.fingerprint_c();
}
@@ -919,14 +921,15 @@ pub unsafe fn dc_handle_degrade_event(context: &Context, peerstate: &Peerstate)
// with things they cannot fix, so the user is just kicked from the verified group
// (and he will know this and can fix this)
if Some(DegradeEvent::FingerprintChanged) == peerstate.degrade_event {
let contact_id: i32 = sql::query_row(
context,
&context.sql,
"SELECT id FROM contacts WHERE addr=?;",
params![&peerstate.addr],
0,
)
.unwrap_or_default();
let contact_id: i32 = context
.sql
.query_row_col(
context,
"SELECT id FROM contacts WHERE addr=?;",
params![&peerstate.addr],
0,
)
.unwrap_or_default();
if contact_id > 0 {
dc_create_or_lookup_nchat_by_contact_id(
context,

3
src/dc_token.rs
View File

@@ -33,9 +33,8 @@ pub fn dc_token_lookup(
namespc: dc_tokennamespc_t,
foreign_id: u32,
) -> *mut libc::c_char {
if let Some(token) = sql::query_row::<_, String>(
if let Some(token) = context.sql.query_row_col::<_, String>(
context,
&context.sql,
"SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
params![namespc as i32, foreign_id as i32],
0,

15
src/imap.rs
View File

@@ -8,7 +8,6 @@ use crate::context::Context;
use crate::dc_loginparam::*;
use crate::dc_tools::as_str;
use crate::oauth2::dc_get_oauth2_access_token;
use crate::sql;
use crate::types::*;
pub const DC_IMAP_SEEN: usize = 0x0001;
@@ -1598,19 +1597,15 @@ impl Imap {
}
}
sql::set_config_int(context, &context.sql, "folders_configured", 3);
context.sql.set_config_int(context, "folders_configured", 3);
if let Some(ref mvbox_folder) = mvbox_folder {
sql::set_config(
context,
&context.sql,
"configured_mvbox_folder",
Some(mvbox_folder),
);
context
.sql
.set_config(context, "configured_mvbox_folder", Some(mvbox_folder));
}
if let Some(ref sentbox_folder) = sentbox_folder {
sql::set_config(
context.sql.set_config(
context,
&context.sql,
"configured_sentbox_folder",
Some(sentbox_folder.name()),
);

6
src/key.rs
View File

@@ -149,9 +149,8 @@ impl Key {
) -> Option<Self> {
let addr = self_addr.as_ref();
sql::query_row(
sql.query_row_col(
context,
sql,
"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;",
&[addr],
0,
@@ -164,9 +163,8 @@ impl Key {
self_addr: impl AsRef<str>,
sql: &Sql,
) -> Option<Self> {
sql::query_row(
sql.query_row_col(
context,
sql,
"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;",
&[self_addr.as_ref()],
0,

5
src/keyring.rs
View File

@@ -3,7 +3,7 @@ use std::borrow::Cow;
use crate::constants::*;
use crate::context::Context;
use crate::key::*;
use crate::sql::{self, Sql};
use crate::sql::Sql;
#[derive(Default, Clone, Debug)]
pub struct Keyring<'a> {
@@ -33,9 +33,8 @@ impl<'a> Keyring<'a> {
self_addr: impl AsRef<str>,
sql: &Sql,
) -> bool {
sql::query_row(
sql.query_row_col(
context,
sql,
"SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;",
&[self_addr.as_ref()],
0,

64
src/oauth2.rs
View File

@@ -5,7 +5,6 @@ use serde::Deserialize;
use crate::context::Context;
use crate::dc_tools::*;
use crate::sql;
const OAUTH2_GMAIL: Oauth2 = Oauth2 {
client_id: "959970109878-4mvtgf6feshskf7695nfln6002mom908.apps.googleusercontent.com",
@@ -49,9 +48,8 @@ pub fn dc_get_oauth2_url(
redirect_uri: impl AsRef<str>,
) -> Option<String> {
if let Some(oauth2) = Oauth2::from_address(addr) {
sql::set_config(
context.sql.set_config(
context,
&context.sql,
"oauth2_pending_redirect_uri",
Some(redirect_uri.as_ref()),
);
@@ -78,17 +76,20 @@ pub fn dc_get_oauth2_access_token(
// read generated token
if 0 == flags & 0x1 && !is_expired(context) {
let access_token = sql::get_config(context, &context.sql, "oauth2_access_token", None);
let access_token = context.sql.get_config(context, "oauth2_access_token", None);
if access_token.is_some() {
// success
return access_token;
}
}
let refresh_token = sql::get_config(context, &context.sql, "oauth2_refresh_token", None);
let refresh_token_for =
sql::get_config(context, &context.sql, "oauth2_refresh_token_for", None)
.unwrap_or_else(|| "unset".into());
let refresh_token = context
.sql
.get_config(context, "oauth2_refresh_token", None);
let refresh_token_for = context
.sql
.get_config(context, "oauth2_refresh_token_for", None)
.unwrap_or_else(|| "unset".into());
let (redirect_uri, token_url, update_redirect_uri_on_success) =
if refresh_token.is_none() || refresh_token_for != code.as_ref() {
@@ -97,7 +98,9 @@ pub fn dc_get_oauth2_access_token(
0, "Generate OAuth2 refresh_token and access_token...",
);
(
sql::get_config(context, &context.sql, "oauth2_pending_redirect_uri", None)
context
.sql
.get_config(context, "oauth2_pending_redirect_uri", None)
.unwrap_or_else(|| "unset".into()),
oauth2.init_token,
true,
@@ -108,7 +111,9 @@ pub fn dc_get_oauth2_access_token(
0, "Regenerate OAuth2 access_token by refresh_token...",
);
(
sql::get_config(context, &context.sql, "oauth2_redirect_uri", None)
context
.sql
.get_config(context, "oauth2_redirect_uri", None)
.unwrap_or_else(|| "unset".into()),
oauth2.refresh_token,
false,
@@ -152,38 +157,33 @@ pub fn dc_get_oauth2_access_token(
println!("response: {:?}", &parsed);
let response = parsed.unwrap();
if let Some(ref token) = response.refresh_token {
sql::set_config(context, &context.sql, "oauth2_refresh_token", Some(token));
sql::set_config(
context,
&context.sql,
"oauth2_refresh_token_for",
Some(code.as_ref()),
);
context
.sql
.set_config(context, "oauth2_refresh_token", Some(token));
context
.sql
.set_config(context, "oauth2_refresh_token_for", Some(code.as_ref()));
}
// after that, save the access token.
// if it's unset, we may get it in the next round as we have the refresh_token now.
if let Some(ref token) = response.access_token {
sql::set_config(context, &context.sql, "oauth2_access_token", Some(token));
context
.sql
.set_config(context, "oauth2_access_token", Some(token));
let expires_in = response
.expires_in
// refresh a bet before
.map(|t| time() + t as i64 - 5)
.unwrap_or_else(|| 0);
sql::set_config_int64(
context,
&context.sql,
"oauth2_timestamp_expires",
expires_in,
);
context
.sql
.set_config_int64(context, "oauth2_timestamp_expires", expires_in);
if update_redirect_uri_on_success {
sql::set_config(
context,
&context.sql,
"oauth2_redirect_uri",
Some(redirect_uri.as_ref()),
);
context
.sql
.set_config(context, "oauth2_redirect_uri", Some(redirect_uri.as_ref()));
}
} else {
warn!(context, 0, "Failed to find OAuth2 access token");
@@ -297,7 +297,9 @@ impl Oauth2 {
fn is_expired(context: &Context) -> bool {
let expire_timestamp =
sql::get_config_int64(context, &context.sql, "oauth2_timestamp_expires", Some(0));
context
.sql
.get_config_int64(context, "oauth2_timestamp_expires", Some(0));
if expire_timestamp <= 0 {
return false;

325
src/sql.rs
View File

@@ -146,6 +146,138 @@ impl Sql {
self.with_conn(|conn| Ok(table_exists(conn, name)))
.unwrap_or_default()
}
pub fn query_row_col<P, T>(
&self,
context: &Context,
query: &str,
params: P,
column: usize,
) -> Option<T>
where
P: IntoIterator,
P::Item: rusqlite::ToSql,
T: rusqlite::types::FromSql,
{
match self.query_row(query, params, |row| row.get::<_, T>(column)) {
Ok(res) => Some(res),
Err(Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => None,
Err(Error::Sql(rusqlite::Error::InvalidColumnType(
_,
_,
rusqlite::types::Type::Null,
))) => None,
Err(err) => {
error!(context, 0, "sql: Failed query_row: {}", err);
None
}
}
}
/// Set private configuration options.
pub fn set_config(
&self,
context: &Context,
key: impl AsRef<str>,
value: Option<&str>,
) -> libc::c_int {
if !self.is_open() {
error!(context, 0, "set_config(): Database not ready.");
return 0;
}
let key = key.as_ref();
let good;
if let Some(ref value) = value {
let exists = self
.exists("SELECT value FROM config WHERE keyname=?;", params![key])
.unwrap_or_default();
if exists {
good = execute(
context,
self,
"UPDATE config SET value=? WHERE keyname=?;",
params![value, key],
);
} else {
good = execute(
context,
self,
"INSERT INTO config (keyname, value) VALUES (?, ?);",
params![key, value],
);
}
} else {
good = execute(
context,
self,
"DELETE FROM config WHERE keyname=?;",
params![key],
);
}
if !good {
error!(context, 0, "set_config(): Cannot change value.",);
return 0;
}
1
}
/// Get configuration options from the database.
pub fn get_config(
&self,
context: &Context,
key: impl AsRef<str>,
def: Option<&str>,
) -> Option<String> {
if !self.is_open() || key.as_ref().is_empty() {
return None;
}
self.query_row_col(
context,
"SELECT value FROM config WHERE keyname=?;",
params![key.as_ref()],
0,
)
.or_else(|| def.map(|s| s.to_string()))
}
pub fn set_config_int(
&self,
context: &Context,
key: impl AsRef<str>,
value: i32,
) -> libc::c_int {
self.set_config(context, key, Some(&format!("{}", value)))
}
pub fn get_config_int(&self, context: &Context, key: impl AsRef<str>, def: i32) -> i32 {
self.get_config(context, key, None)
.and_then(|s| s.parse().ok())
.unwrap_or_else(|| def)
}
pub fn set_config_int64(
&self,
context: &Context,
key: impl AsRef<str>,
value: i64,
) -> libc::c_int {
self.set_config(context, key, Some(&format!("{}", value)))
}
pub fn get_config_int64(
&self,
context: &Context,
key: impl AsRef<str>,
def: Option<i64>,
) -> i64 {
let ret = self.get_config(context, key, None);
ret.map(|r| r.parse().unwrap_or_default())
.unwrap_or_else(|| def.unwrap_or_default())
}
}
fn table_exists(conn: &Connection, name: impl AsRef<str>) -> bool {
@@ -328,11 +460,11 @@ fn open(
// cannot create the tables - maybe we cannot write?
return Err(Error::SqlFailedToOpen);
} else {
set_config_int(context, sql, "dbversion", 0);
sql.set_config_int(context, "dbversion", 0);
}
} else {
exists_before_update = 1;
dbversion_before_update = get_config_int(context, sql, "dbversion", 0);
dbversion_before_update = sql.get_config_int(context, "dbversion", 0);
}
// (1) update low-level database structure.
@@ -353,7 +485,7 @@ fn open(
params![],
)?;
dbversion = 1;
set_config_int(context, sql, "dbversion", 1);
sql.set_config_int(context, "dbversion", 1);
}
if dbversion < 2 {
sql.execute(
@@ -361,7 +493,7 @@ fn open(
params![],
)?;
dbversion = 2;
set_config_int(context, sql, "dbversion", 2);
sql.set_config_int(context, "dbversion", 2);
}
if dbversion < 7 {
sql.execute(
@@ -375,7 +507,7 @@ fn open(
params![],
)?;
dbversion = 7;
set_config_int(context, sql, "dbversion", 7);
sql.set_config_int(context, "dbversion", 7);
}
if dbversion < 10 {
sql.execute(
@@ -393,7 +525,7 @@ fn open(
params![],
)?;
dbversion = 10;
set_config_int(context, sql, "dbversion", 10);
sql.set_config_int(context, "dbversion", 10);
}
if dbversion < 12 {
sql.execute(
@@ -405,7 +537,7 @@ fn open(
params![],
)?;
dbversion = 12;
set_config_int(context, sql, "dbversion", 12);
sql.set_config_int(context, "dbversion", 12);
}
if dbversion < 17 {
sql.execute(
@@ -419,7 +551,7 @@ fn open(
)?;
sql.execute("CREATE INDEX msgs_index5 ON msgs (starred);", params![])?;
dbversion = 17;
set_config_int(context, sql, "dbversion", 17);
sql.set_config_int(context, "dbversion", 17);
}
if dbversion < 18 {
sql.execute(
@@ -428,7 +560,7 @@ fn open(
)?;
sql.execute("ALTER TABLE acpeerstates ADD COLUMN gossip_key;", params![])?;
dbversion = 18;
set_config_int(context, sql, "dbversion", 18);
sql.set_config_int(context, "dbversion", 18);
}
if dbversion < 27 {
sql.execute("DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;", params![])?;
@@ -445,7 +577,7 @@ fn open(
params![],
)?;
dbversion = 27;
set_config_int(context, sql, "dbversion", 27);
sql.set_config_int(context, "dbversion", 27);
}
if dbversion < 34 {
sql.execute(
@@ -474,7 +606,7 @@ fn open(
)?;
recalc_fingerprints = 1;
dbversion = 34;
set_config_int(context, sql, "dbversion", 34);
sql.set_config_int(context, "dbversion", 34);
}
if dbversion < 39 {
sql.execute(
@@ -504,7 +636,7 @@ fn open(
)?;
}
dbversion = 39;
set_config_int(context, sql, "dbversion", 39);
sql.set_config_int(context, "dbversion", 39);
}
if dbversion < 40 {
sql.execute(
@@ -512,22 +644,22 @@ fn open(
params![],
)?;
dbversion = 40;
set_config_int(context, sql, "dbversion", 40);
sql.set_config_int(context, "dbversion", 40);
}
if dbversion < 41 {
update_file_paths = 1;
dbversion = 41;
set_config_int(context, sql, "dbversion", 41);
sql.set_config_int(context, "dbversion", 41);
}
if dbversion < 42 {
sql.execute("UPDATE msgs SET txt='' WHERE type!=10", params![])?;
dbversion = 42;
set_config_int(context, sql, "dbversion", 42);
sql.set_config_int(context, "dbversion", 42);
}
if dbversion < 44 {
sql.execute("ALTER TABLE msgs ADD COLUMN mime_headers TEXT;", params![])?;
dbversion = 44;
set_config_int(context, sql, "dbversion", 44);
sql.set_config_int(context, "dbversion", 44);
}
if dbversion < 46 {
sql.execute(
@@ -539,7 +671,7 @@ fn open(
params![],
)?;
dbversion = 46;
set_config_int(context, sql, "dbversion", 46);
sql.set_config_int(context, "dbversion", 46);
}
if dbversion < 47 {
info!(context, 0, "[migration] v47");
@@ -548,7 +680,7 @@ fn open(
params![],
)?;
dbversion = 47;
set_config_int(context, sql, "dbversion", 47);
sql.set_config_int(context, "dbversion", 47);
}
if dbversion < 48 {
info!(context, 0, "[migration] v48");
@@ -562,7 +694,7 @@ fn open(
assert_eq!(DC_MOVE_STATE_MOVING as libc::c_int, 3);
dbversion = 48;
set_config_int(context, sql, "dbversion", 48);
sql.set_config_int(context, "dbversion", 48);
}
if dbversion < 49 {
info!(context, 0, "[migration] v49");
@@ -571,15 +703,15 @@ fn open(
params![],
)?;
dbversion = 49;
set_config_int(context, sql, "dbversion", 49);
sql.set_config_int(context, "dbversion", 49);
}
if dbversion < 50 {
info!(context, 0, "[migration] v50");
if 0 != exists_before_update {
set_config_int(context, sql, "show_emails", 2);
sql.set_config_int(context, "show_emails", 2);
}
dbversion = 50;
set_config_int(context, sql, "dbversion", 50);
sql.set_config_int(context, "dbversion", 50);
}
if dbversion < 53 {
info!(context, 0, "[migration] v53");
@@ -612,7 +744,7 @@ fn open(
params![],
)?;
dbversion = 53;
set_config_int(context, sql, "dbversion", 53);
sql.set_config_int(context, "dbversion", 53);
}
if dbversion < 54 {
info!(context, 0, "[migration] v54");
@@ -622,7 +754,7 @@ fn open(
)?;
sql.execute("CREATE INDEX msgs_index6 ON msgs (location_id);", params![])?;
dbversion = 54;
set_config_int(context, sql, "dbversion", 54);
sql.set_config_int(context, "dbversion", 54);
}
if dbversion < 55 {
sql.execute(
@@ -630,7 +762,7 @@ fn open(
params![],
)?;
set_config_int(context, sql, "dbversion", 55);
sql.set_config_int(context, "dbversion", 55);
}
if 0 != recalc_fingerprints {
@@ -657,13 +789,9 @@ fn open(
info!(context, 0, "[open] update file paths");
let repl_from = get_config(
context,
sql,
"backup_for",
Some(as_str(context.get_blobdir())),
)
.unwrap();
let repl_from = sql
.get_config(context, "backup_for", Some(as_str(context.get_blobdir())))
.unwrap();
let repl_from = dc_ensure_no_slash_safe(&repl_from);
sql.execute(
@@ -682,7 +810,7 @@ fn open(
NO_PARAMS,
)?;
set_config(context, sql, "backup_for", None);
sql.set_config(context, "backup_for", None);
}
}
@@ -691,76 +819,6 @@ fn open(
Ok(())
}
// handle configurations, private
pub fn set_config(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: Option<&str>,
) -> libc::c_int {
if !sql.is_open() {
error!(context, 0, "set_config(): Database not ready.");
return 0;
}
let key = key.as_ref();
let good;
if let Some(ref value) = value {
let exists = sql
.exists("SELECT value FROM config WHERE keyname=?;", params![key])
.unwrap_or_default();
if exists {
good = execute(
context,
sql,
"UPDATE config SET value=? WHERE keyname=?;",
params![value, key],
);
} else {
good = execute(
context,
sql,
"INSERT INTO config (keyname, value) VALUES (?, ?);",
params![key, value],
);
}
} else {
good = execute(
context,
sql,
"DELETE FROM config WHERE keyname=?;",
params![key],
);
}
if !good {
error!(context, 0, "set_config(): Cannot change value.",);
return 0;
}
1
}
pub fn get_config(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
def: Option<&str>,
) -> Option<String> {
if !sql.is_open() || key.as_ref().is_empty() {
return None;
}
query_row(
context,
sql,
"SELECT value FROM config WHERE keyname=?;",
params![key.as_ref()],
0,
)
.or_else(|| def.map(|s| s.to_string()))
}
pub fn execute<P>(context: &Context, sql: &Sql, querystr: impl AsRef<str>, params: P) -> bool
where
P: IntoIterator,
@@ -781,67 +839,6 @@ where
}
}
// TODO Remove the Option<> from the return type.
pub fn query_row<P, T>(
context: &Context,
sql: &Sql,
query: &str,
params: P,
column: usize,
) -> Option<T>
where
P: IntoIterator,
P::Item: rusqlite::ToSql,
T: rusqlite::types::FromSql,
{
match sql.query_row(query, params, |row| row.get::<_, T>(column)) {
Ok(res) => Some(res),
Err(Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => None,
Err(Error::Sql(rusqlite::Error::InvalidColumnType(_, _, rusqlite::types::Type::Null))) => {
None
}
Err(err) => {
error!(context, 0, "sql: Failed query_row: {}", err);
None
}
}
}
pub fn set_config_int(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: i32,
) -> libc::c_int {
set_config(context, sql, key, Some(&format!("{}", value)))
}
pub fn get_config_int(context: &Context, sql: &Sql, key: impl AsRef<str>, def: i32) -> i32 {
get_config(context, sql, key, None)
.and_then(|s| s.parse().ok())
.unwrap_or_else(|| def)
}
pub fn set_config_int64(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: i64,
) -> libc::c_int {
set_config(context, sql, key, Some(&format!("{}", value)))
}
pub fn get_config_int64(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
def: Option<i64>,
) -> i64 {
let ret = get_config(context, sql, key, None);
ret.map(|r| r.parse().unwrap_or_default())
.unwrap_or_else(|| def.unwrap_or_default())
}
pub fn try_execute(context: &Context, sql: &Sql, querystr: impl AsRef<str>) -> libc::c_int {
// same as execute() but does not pass error to ui
match sql.execute(querystr.as_ref(), params![]) {