diff --git a/src/commands.c b/src/commands.c
index 890c26d318cdbf69c6e1600c1426c2baa6b67030..a4a5d3f79701db45d62fb63200561db3aa5d838a 100644
--- a/src/commands.c
+++ b/src/commands.c
@@ -94,7 +94,7 @@ command_currentsong(struct lkt_state *srv, size_t c)
 
     memset(&kara, 0, sizeof(struct kara_metadata));
 
-    if (!database_queue_current_kara((sqlite3 *) srv->db, &kara, NULL))
+    if (!database_queue_current_kara(srv->db, &kara, NULL))
         LOG_ERROR_SCT("COMMAND", "%s", "Failed to get information about the current kara");
 
     out = lkt_message_new();
@@ -124,8 +124,8 @@ command_status(struct lkt_state *srv, size_t c)
 
     RETURN_UNLESS(srv, "Invalid argument", false);
     win = &srv->win;
-    RETURN_UNLESS(database_queue_state((sqlite3 *) srv->db, &queue_state), "Can't determine playback status", false);
-    database_queue_current_kara((sqlite3 *) srv->db, NULL, &songid);
+    RETURN_UNLESS(database_queue_state(srv->db, &queue_state), "Can't determine playback status", false);
+    database_queue_current_kara(srv->db, NULL, &songid);
     win->get_elapsed(win, &elapsed);
     win->get_duration(win, &duration);
 
@@ -154,7 +154,7 @@ command_status(struct lkt_state *srv, size_t c)
 }
 
 bool
-command_next(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_ptr)
+command_next(volatile sqlite3 *db, struct lkt_win *win, mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
@@ -162,14 +162,14 @@ command_next(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_pt
 }
 
 bool
-command_pause(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_ptr)
+command_pause(volatile sqlite3 *db, struct lkt_win *win, mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
     return database_queue_toggle_pause(db) && win->toggle_pause(win);
 }
 
 bool
-command_previous(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_ptr)
+command_previous(volatile sqlite3 *db, struct lkt_win *win, mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
@@ -177,7 +177,7 @@ command_previous(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mas
 }
 
 static inline bool
-__play_that_file(sqlite3 *db, struct lkt_win *win, int pos)
+__play_that_file(volatile sqlite3 *db, struct lkt_win *win, int pos)
 {
     char filepath[PATH_MAX];
     RETURN_UNLESS(pos, "Invalid argument", false);
@@ -188,8 +188,7 @@ __play_that_file(sqlite3 *db, struct lkt_win *win, int pos)
 }
 
 bool
-command_play(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
-             enum mpd_idle_flag *watch_mask_ptr)
+command_play(volatile sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char *endptr;
@@ -210,8 +209,7 @@ command_play(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
 }
 
 bool
-command_playid(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
-               enum mpd_idle_flag *watch_mask_ptr)
+command_playid(volatile sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
     char *endptr;
@@ -236,7 +234,7 @@ command_playid(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX
 
 
 bool
-command_stop(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_ptr)
+command_stop(volatile sqlite3 *db, struct lkt_win *win, mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(database_queue_stop(db), "DB error", false);
     win->close(win);
@@ -245,8 +243,7 @@ command_stop(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_pt
 }
 
 bool
-command_add(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
-            enum mpd_idle_flag *watch_mask_ptr)
+command_add(volatile sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args, "Invalid argument", false);
     *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
@@ -289,8 +286,7 @@ command_add(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
 }
 
 bool
-command_addid(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX],
-              enum mpd_idle_flag *watch_mask_ptr)
+command_addid(volatile sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     UNUSED(win);
     long id;
@@ -309,21 +305,21 @@ command_addid(sqlite3 *db, struct lkt_win *win, char *args[LKT_MESSAGE_ARGS_MAX]
 }
 
 inline bool
-command_clear(sqlite3 *db, enum mpd_idle_flag *watch_mask_ptr)
+command_clear(volatile sqlite3 *db, mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
     return database_queue_clear(db);
 }
 
 inline bool
-command_crop(sqlite3 *db, enum mpd_idle_flag *watch_mask_ptr)
+command_crop(volatile sqlite3 *db, mpd_idle_flag *watch_mask_ptr)
 {
     *watch_mask_ptr |= MPD_IDLE_PLAYLIST;
     return database_queue_crop(db);
 }
 
 bool
-command_delid(sqlite3 *db, struct lkt_win *win, char *id_str, enum mpd_idle_flag *watch_mask_ptr)
+command_delid(volatile sqlite3 *db, struct lkt_win *win, char *id_str, mpd_idle_flag *watch_mask_ptr)
 {
     UNUSED(win);
     long id;
@@ -346,7 +342,7 @@ command_delid(sqlite3 *db, struct lkt_win *win, char *id_str, enum mpd_idle_flag
 }
 
 bool
-command_move(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_move(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     long from, to;
     char *endptr;
@@ -470,12 +466,12 @@ static bool
 lkt_callback_insert_v1(struct lkt_state *srv, size_t c, int id, int id_len, const char *sql_row)
 {
     UNUSED(sql_row, id_len, c);
-    return database_queue_add_id((sqlite3 *) srv->db, id, 5);
+    return database_queue_add_id(srv->db, id, 5);
 }
 
 static bool
 __find(struct lkt_state *srv, size_t c, char *cmd_args[LKT_MESSAGE_ARGS_MAX], long continuation,
-       enum lkt_find_action action, bool(*init)(sqlite3 *, char *, char *, struct lkt_search *))
+       enum lkt_find_action action, bool(*init)(volatile sqlite3 *, char *, char *, struct lkt_search *))
 {
     char rgx[PATH_MAX], *col_name, *mpd_tag;
     int count;
@@ -547,7 +543,7 @@ __find(struct lkt_state *srv, size_t c, char *cmd_args[LKT_MESSAGE_ARGS_MAX], lo
 
     /* Make the search langand do the right action */
 
-    RETURN_UNLESS(init((sqlite3 *) srv->db, col_name, rgx, &search), "Failed to init search", false);
+    RETURN_UNLESS(init(srv->db, col_name, rgx, &search), "Failed to init search", false);
 
     for (count = 0; database_search_iter(&search); ++count)
         continue;
@@ -599,19 +595,19 @@ command_set_playback_option(struct lkt_state *srv, size_t c, enum lkt_playback_o
 
     switch (opt) {
     case lkt_playback_option_random:
-        ret = database_config_queue((sqlite3 *) srv->db, "random", val);
+        ret = database_config_queue(srv->db, "random", val);
         break;
     case lkt_playback_option_single:
-        ret = database_config_queue((sqlite3 *) srv->db, "single", val);
+        ret = database_config_queue(srv->db, "single", val);
         break;
     case lkt_playback_option_consume:
-        ret = database_config_queue((sqlite3 *) srv->db, "consume", val);
+        ret = database_config_queue(srv->db, "consume", val);
         break;
     case lkt_playback_option_repeat:
-        ret = database_config_queue((sqlite3 *) srv->db, "repeat", val);
+        ret = database_config_queue(srv->db, "repeat", val);
         break;
     case lkt_playback_option_volume:
-        ret = database_config_queue((sqlite3 *) srv->db, "volume", val);
+        ret = database_config_queue(srv->db, "volume", val);
         LOG_INFO_SCT("COMMAND", "Set volume to %ld", val);
         ret &= win->set_volume(win, val);
         srv->mpd_idle_events |= MPD_IDLE_MIXER;
@@ -628,17 +624,17 @@ command_set_playback_option(struct lkt_state *srv, size_t c, enum lkt_playback_o
 }
 
 bool
-command_set_pos(sqlite3 *db, struct lkt_win *win, enum mpd_idle_flag *watch_mask_ptr, int index)
+command_set_pos(volatile sqlite3 *db, struct lkt_win *win, mpd_idle_flag *watch_mask_ptr, int index)
 {
     char filepath[PATH_MAX];
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
-    RETURN_UNLESS(database_queue_set_current_index((sqlite3 *)db, index), "Failed to set position in queue", false);
-    RETURN_UNLESS(database_queue_get_current_file((sqlite3 *)db, filepath), "Failed to get filename", false);
+    RETURN_UNLESS(database_queue_set_current_index(db, index), "Failed to set position in queue", false);
+    RETURN_UNLESS(database_queue_get_current_file(db, filepath), "Failed to get filename", false);
     return win->load_file(win, filepath);
 }
 
 bool
-command_plt_add(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_add(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
 
@@ -671,7 +667,7 @@ end_plt_add_uri:
 }
 
 bool
-command_plt_remove(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_remove(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     char *endptr;
     long pos;
@@ -693,7 +689,7 @@ command_plt_remove(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_
 }
 
 bool
-command_plt_clear(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_clear(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     RETURN_UNLESS(database_plt_clear(db, args[0]), "Failed to clear playlist", false);
@@ -702,7 +698,7 @@ command_plt_clear(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_f
 }
 
 bool
-command_plt_rename(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_rename(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_plt_rename(db, args[0], args[1]), "Failed to rename playlist", false);
@@ -711,7 +707,7 @@ command_plt_rename(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_
 }
 
 bool
-command_plt_export(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_export(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(db, args[0], args[1]), "Failed to attach database", false);
@@ -723,7 +719,7 @@ command_plt_export(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_
 }
 
 bool
-command_plt_import(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_import(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(db, args[0], args[1]), "Failed to attach database", false);
@@ -735,7 +731,7 @@ command_plt_import(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_
 }
 
 bool
-command_plt_add_uri(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle_flag *watch_mask_ptr)
+command_plt_add_uri(volatile sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     struct lkt_uri uri;
@@ -748,7 +744,7 @@ command_plt_add_uri(sqlite3 *db, char *args[LKT_MESSAGE_ARGS_MAX], enum mpd_idle
 }
 
 bool
-command_shuffle(sqlite3 *db, enum mpd_idle_flag *watch_mask_ptr)
+command_shuffle(volatile sqlite3 *db, mpd_idle_flag *watch_mask_ptr)
 {
     RETURN_UNLESS(database_queue_shuffle(db), "Failed to shuffle", false);
     *watch_mask_ptr |= MPD_IDLE_PLAYER;
@@ -809,17 +805,17 @@ command_queue_list(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_
     /* The command is used in its relative forme, display elements from the
        current one. */
 only_one:
-    return database_queue_list((sqlite3 *) srv->db, from, from, &callback);
+    return database_queue_list(srv->db, from, from, &callback);
 
     /* The command is used with a range specifier. */
 is_a_range:
     if (to - from + 1 < lkt_remaining_msg(srv, c) - 2) {
         lkt_set_continuation(srv, c, 0);
-        return database_queue_list((sqlite3 *) srv->db, from, to, &callback);
+        return database_queue_list(srv->db, from, to, &callback);
     } else {
         to = from + lkt_remaining_msg(srv, c) - 3;
         lkt_set_continuation(srv, c, to + 1);
-        return database_queue_list((sqlite3 *) srv->db, from, to, &callback);
+        return database_queue_list(srv->db, from, to, &callback);
     }
 }
 
@@ -827,13 +823,13 @@ bool
 command_password(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(argv[0], "Invalid argument", false);
-    RETURN_UNLESS(database_user_authentificate((sqlite3 *) srv->db, argv[0]), "Failed to authentificate user", false);
+    RETURN_UNLESS(database_user_authentificate(srv->db, argv[0]), "Failed to authentificate user", false);
     lkt_client_auth(srv, c, true);
     return true;
 }
 
 bool
-command_user_add(struct lkt_state *srv, size_t c, sqlite3 *db, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_user_add(struct lkt_state *srv, size_t c, volatile sqlite3 *db, char *argv[LKT_MESSAGE_ARGS_MAX])
 {
     RETURN_UNLESS(argv[0] && argv[1], "Invalid argument", false);
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
@@ -933,7 +929,7 @@ command_sticker_get(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS
         .c = c,
         .call = sticker_send_one_value,
     };
-    RETURN_UNLESS(database_sticker_get((sqlite3 *) srv->db, argv[0], argv[2], uri, &cb), "Failed to get sticker",
+    RETURN_UNLESS(database_sticker_get(srv->db, argv[0], argv[2], uri, &cb), "Failed to get sticker",
                   false);
     return true;
 }
@@ -945,7 +941,7 @@ command_sticker_set(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS
     RETURN_UNLESS(argv[0] && argv[1] && argv[2] && argv[3] && !argv[4], "Invalid argument", false);
     int uri = atoi(argv[1]);    /* FIXME: Use strtol. */
     int value = atoi(argv[4]);  /* FIXME: Use strtol. */
-    RETURN_UNLESS(database_sticker_set((sqlite3 *) srv->db, argv[0], argv[2], uri, value), "Failed to get sticker", false);
+    RETURN_UNLESS(database_sticker_set(srv->db, argv[0], argv[2], uri, value), "Failed to get sticker", false);
     srv->mpd_idle_events |= MPD_IDLE_STICKER;
     return true;
 }
@@ -982,18 +978,18 @@ command_sticker_list(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARG
 
 just_list_all:
     callback.call = sticker_send_all;
-    return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+    return database_sticker_list(srv->db, argv[0], &callback);
 
 simple_list_command:
     callback.uri  = atoi(argv[1]);   /* FIXME: Use strtol. */
     callback.call = sticker_send_check_uri;
-    return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+    return database_sticker_list(srv->db, argv[0], &callback);
 
 list_stickers_in_uri:
     callback.uri  = atoi(argv[1]);  /* FIXME: Use strtol. */
     callback.name = argv[2];
     callback.call = sticker_send_value_check_uri_name;
-    return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+    return database_sticker_list(srv->db, argv[0], &callback);
     return false;
 
 list_stickers_check_value:
@@ -1003,13 +999,13 @@ list_stickers_check_value:
     switch (argv[3][0]) {
     case '=':
         callback.call = sticker_check_is_present_eq;
-        return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+        return database_sticker_list(srv->db, argv[0], &callback);
     case '<':
         callback.call = sticker_check_is_present_lt;
-        return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+        return database_sticker_list(srv->db, argv[0], &callback);
     case '>':
         callback.call = sticker_check_is_present_gt;
-        return database_sticker_list((sqlite3 *) srv->db, argv[0], &callback);
+        return database_sticker_list(srv->db, argv[0], &callback);
     default:
         return 0;
     }
@@ -1026,5 +1022,5 @@ command_sticker_delete(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_A
     RETURN_UNLESS(argv[0] && argv[1], "Invalid argument", false);
     int uri = atoi(argv[1]);
     srv->mpd_idle_events |= MPD_IDLE_STICKER;
-    return database_sticker_delete_specify((sqlite3 *) srv->db, argv[0], uri, argv[2]);
+    return database_sticker_delete_specify(srv->db, argv[0], uri, argv[2]);
 }