*/
#include "config.h"
-#include "stat_internal.h"
#include "main.h"
#include "sqlite3.h"
+#include "libutil/sqlite_utils.h"
+#include "libstat/stat_internal.h"
#define SQLITE3_BACKEND_TYPE "sqlite3"
#define SQLITE3_SCHEMA_VERSION "1"
#define SQLITE3_DEFAULT "default"
-struct rspamd_sqlite3_prstmt;
-
struct rspamd_stat_sqlite3_db {
sqlite3 *sqlite;
- struct rspamd_sqlite3_prstmt *prstmt;
+ GArray *prstmt;
gboolean in_transaction;
};
RSPAMD_STAT_BACKEND_MAX
};
-static struct rspamd_sqlite3_prstmt {
- enum rspamd_stat_sqlite3_stmt_idx idx;
- const gchar *sql;
- const gchar *args;
- sqlite3_stmt *stmt;
- gint result;
- const gchar *ret;
-} prepared_stmts[RSPAMD_STAT_BACKEND_MAX] =
+static struct rspamd_sqlite3_prstmt prepared_stmts[RSPAMD_STAT_BACKEND_MAX] =
{
{
.idx = RSPAMD_STAT_BACKEND_TRANSACTION_START_IM,
};
static GQuark
-rspamd_sqlite3_quark (void)
+rspamd_sqlite3_backend_quark (void)
{
return g_quark_from_static_string ("sqlite3-stat-backend");
}
-static gboolean
-rspamd_sqlite3_init_prstmt (struct rspamd_stat_sqlite3_db *db, GError **err)
-{
- int i;
-
- for (i = 0; i < RSPAMD_STAT_BACKEND_MAX; i ++) {
- if (db->prstmt[i].stmt != NULL) {
- /* Skip already prepared statements */
- continue;
- }
- if (sqlite3_prepare_v2 (db->sqlite, db->prstmt[i].sql, -1,
- &db->prstmt[i].stmt, NULL) != SQLITE_OK) {
- g_set_error (err, rspamd_sqlite3_quark (),
- -1, "Cannot initialize prepared sql `%s`: %s",
- db->prstmt[i].sql, sqlite3_errmsg (db->sqlite));
-
- return FALSE;
- }
- }
-
- return TRUE;
-}
-
-static int
-rspamd_sqlite3_run_prstmt (struct rspamd_stat_sqlite3_db *db, int idx, ...)
-{
- gint retcode;
- va_list ap;
- sqlite3_stmt *stmt;
- gint i, rowid, nargs, j;
- const char *argtypes;
-
- if (idx < 0 || idx >= RSPAMD_STAT_BACKEND_MAX) {
-
- return -1;
- }
-
- stmt = db->prstmt[idx].stmt;
- if (stmt == NULL) {
- if ((retcode = sqlite3_prepare_v2 (db->sqlite, db->prstmt[idx].sql, -1,
- &db->prstmt[idx].stmt, NULL)) != SQLITE_OK) {
- msg_err ("Cannot initialize prepared sql `%s`: %s",
- db->prstmt[idx].sql, sqlite3_errmsg (db->sqlite));
-
- return retcode;
- }
- stmt = db->prstmt[idx].stmt;
- }
-
- msg_debug ("executing `%s`", db->prstmt[idx].sql);
- argtypes = db->prstmt[idx].args;
- sqlite3_reset (stmt);
- va_start (ap, idx);
- nargs = 1;
-
- for (i = 0, rowid = 1; argtypes[i] != '\0'; i ++) {
- switch (argtypes[i]) {
- case 'T':
-
- for (j = 0; j < nargs; j ++, rowid ++) {
- sqlite3_bind_text (stmt, rowid, va_arg (ap, const char*), -1,
- SQLITE_STATIC);
- }
-
- nargs = 1;
- break;
- case 'I':
-
- for (j = 0; j < nargs; j ++, rowid ++) {
- sqlite3_bind_int64 (stmt, rowid, va_arg (ap, gint64));
- }
-
- nargs = 1;
- break;
- case 'S':
-
- for (j = 0; j < nargs; j ++, rowid ++) {
- sqlite3_bind_int (stmt, rowid, va_arg (ap, gint));
- }
-
- nargs = 1;
- break;
- case '*':
- nargs = va_arg (ap, gint);
- break;
- }
- }
-
- va_end (ap);
- retcode = sqlite3_step (stmt);
-
- if (retcode == db->prstmt[idx].result) {
- argtypes = db->prstmt[idx].ret;
-
- for (i = 0; argtypes != NULL && argtypes[i] != '\0'; i ++) {
- switch (argtypes[i]) {
- case 'T':
- *va_arg (ap, char**) = g_strdup (sqlite3_column_text (stmt, i));
- break;
- case 'I':
- *va_arg (ap, gint64*) = sqlite3_column_int64 (stmt, i);
- break;
- case 'S':
- *va_arg (ap, int*) = sqlite3_column_int (stmt, i);
- break;
- }
- }
-
- return SQLITE_OK;
- }
- else if (retcode != SQLITE_DONE) {
- msg_debug ("failed to execute query %s: %d, %s", db->prstmt[idx].sql,
- retcode, sqlite3_errmsg (db->sqlite));
- }
-
- return retcode;
-}
-
-static void
-rspamd_sqlite3_close_prstmt (struct rspamd_stat_sqlite3_db *db)
-{
- int i;
-
- for (i = 0; i < RSPAMD_STAT_BACKEND_MAX; i++) {
- if (db->prstmt[i].stmt != NULL) {
- sqlite3_finalize (db->prstmt[i].stmt);
- db->prstmt[i].stmt = NULL;
- }
- }
-
- return;
-}
-
static gboolean
rspamd_sqlite3_wait (const gchar *lock)
{
user_version[] = "PRAGMA user_version;";
flags = SQLITE_OPEN_READWRITE;
+#ifdef SQLITE_OPEN_SHAREDCACHE
+ flags |= SQLITE_OPEN_SHAREDCACHE;
+#endif
+#ifdef SQLITE_OPEN_WAL
+ flags |= SQLITE_OPEN_WAL;
+#endif
if (create) {
flags |= SQLITE_OPEN_CREATE;
if (lock_fd == -1 && (errno == EEXIST || errno == EBUSY)) {
if (!rspamd_sqlite3_wait (lock_path)) {
- g_set_error (err, rspamd_sqlite3_quark (),
+ g_set_error (err, rspamd_sqlite3_backend_quark (),
errno, "cannot create sqlite file %s: %s",
path, strerror (errno));
}
}
else if (access (path, R_OK) == -1) {
- g_set_error (err, rspamd_sqlite3_quark (),
+ g_set_error (err, rspamd_sqlite3_backend_quark (),
errno, "cannot open sqlite file %s: %s",
path, strerror (errno));
if ((rc = sqlite3_open_v2 (path, &sqlite,
flags, NULL)) != SQLITE_OK) {
#if SQLITE_VERSION_NUMBER >= 3008000
- g_set_error (err, rspamd_sqlite3_quark (),
+ g_set_error (err, rspamd_sqlite3_backend_quark (),
rc, "cannot open sqlite db %s: %s",
path, sqlite3_errstr (rc));
#else
- g_set_error (err, rspamd_sqlite3_quark (),
+ g_set_error (err, rspamd_sqlite3_backend_quark (),
rc, "cannot open sqlite db %s: %d",
path, rc);
#endif
if (create) {
if (sqlite3_exec (sqlite, create_tables_sql, NULL, NULL, NULL) != SQLITE_OK) {
- g_set_error (err, rspamd_sqlite3_quark (),
+ g_set_error (err, rspamd_sqlite3_backend_quark (),
-1, "cannot execute create sql `%s`: %s",
create_tables_sql, sqlite3_errmsg (sqlite));
sqlite3_close (sqlite);
bk = g_slice_alloc0 (sizeof (*bk));
bk->sqlite = sqlite;
- bk->prstmt = g_slice_alloc0 (sizeof (prepared_stmts));
- memcpy (bk->prstmt, prepared_stmts, sizeof (prepared_stmts));
+ bk->prstmt = rspamd_sqlite3_init_prstmt (sqlite, prepared_stmts,
+ RSPAMD_STAT_BACKEND_MAX, err);
+
+ if (bk->prstmt == NULL) {
+ g_slice_free1 (sizeof (*bk), bk);
+ sqlite3_close (sqlite);
- if (!rspamd_sqlite3_init_prstmt (bk, err)) {
return NULL;
}
if (bk->sqlite) {
if (bk->in_transaction) {
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
}
+ rspamd_sqlite3_close_prstmt (bk->sqlite, bk->prstmt);
sqlite3_close (bk->sqlite);
- rspamd_sqlite3_close_prstmt (bk);
g_slice_free1 (sizeof (*bk), bk);
}
}
}
if (!bk->in_transaction) {
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_TRANSACTION_START_DEF);
bk->in_transaction = TRUE;
}
memcpy (&idx, tok->data, sizeof (idx));
/* TODO: language and user support */
- if (rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_GET_TOKEN,
+ if (rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_GET_TOKEN,
idx, rt->user_id, rt->lang_id, &iv) == SQLITE_OK) {
res->value = iv;
bk = rt->db;
if (bk->in_transaction) {
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
bk->in_transaction = FALSE;
}
}
if (!bk->in_transaction) {
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_TRANSACTION_START_IM);
bk->in_transaction = TRUE;
}
iv = res->value;
memcpy (&idx, tok->data, sizeof (idx));
- if (rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_SET_TOKEN,
- idx, rt->user_id, rt->lang_id, iv) == SQLITE_OK) {
+ if (rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_SET_TOKEN,
+ idx, rt->user_id, rt->lang_id, iv) == SQLITE_OK) {
return FALSE;
}
bk = rt->db;
if (bk->in_transaction) {
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_TRANSACTION_COMMIT);
bk->in_transaction = FALSE;
}
g_assert (rt != NULL);
bk = rt->db;
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
return res;
}
g_assert (rt != NULL);
bk = rt->db;
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_INC_LEARNS,
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_INC_LEARNS,
SQLITE3_DEFAULT, SQLITE3_DEFAULT);
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
return res;
}
g_assert (rt != NULL);
bk = rt->db;
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_DEC_LEARNS,
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_DEC_LEARNS,
SQLITE3_DEFAULT, SQLITE3_DEFAULT);
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
return res;
}
g_assert (rt != NULL);
bk = rt->db;
- rspamd_sqlite3_run_prstmt (bk, RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
+ rspamd_sqlite3_run_prstmt (bk->sqlite, bk->prstmt,
+ RSPAMD_STAT_BACKEND_GET_LEARNS, &res);
return res;
}
--- /dev/null
+/*
+ * Copyright (c) 2015, Vsevolod Stakhov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "libutil/logger.h"
+#include "libutil/sqlite_utils.h"
+
+
+static GQuark
+rspamd_sqlite3_quark (void)
+{
+ return g_quark_from_static_string ("rspamd-sqlite3");
+}
+
+GArray*
+rspamd_sqlite3_init_prstmt (sqlite3 *db,
+ struct rspamd_sqlite3_prstmt *init_stmt,
+ gint max_idx,
+ GError **err)
+{
+ gint i;
+ GArray *res;
+ struct rspamd_sqlite3_prstmt *nst;
+
+ res = g_array_sized_new (FALSE, TRUE, sizeof (struct rspamd_sqlite3_prstmt),
+ max_idx);
+ g_array_set_size (res, max_idx);
+
+ for (i = 0; i < max_idx; i ++) {
+ nst = &g_array_index (res, struct rspamd_sqlite3_prstmt, i);
+ memcpy (nst, &init_stmt[i], sizeof (*nst));
+
+ if (sqlite3_prepare_v2 (db, init_stmt[i].sql, -1,
+ &nst->stmt, NULL) != SQLITE_OK) {
+ g_set_error (err, rspamd_sqlite3_quark (),
+ -1, "Cannot initialize prepared sql `%s`: %s",
+ nst->sql, sqlite3_errmsg (db));
+ rspamd_sqlite3_close_prstmt (db, res);
+
+ return NULL;
+ }
+ }
+
+ return res;
+}
+
+int
+rspamd_sqlite3_run_prstmt (sqlite3 *db, GArray *stmts,
+ gint idx, ...)
+{
+ gint retcode;
+ va_list ap;
+ sqlite3_stmt *stmt;
+ gint i, rowid, nargs, j;
+ struct rspamd_sqlite3_prstmt *nst;
+ const char *argtypes;
+
+ if (idx < 0 || idx >= (gint)stmts->len) {
+
+ return -1;
+ }
+
+ nst = &g_array_index (stmts, struct rspamd_sqlite3_prstmt, idx);
+ stmt = nst->stmt;
+
+ g_assert (nst != NULL);
+
+ msg_debug ("executing `%s`", nst->sql);
+ argtypes = nst->args;
+ sqlite3_reset (stmt);
+ va_start (ap, idx);
+ nargs = 1;
+
+ for (i = 0, rowid = 1; argtypes[i] != '\0'; i ++) {
+ switch (argtypes[i]) {
+ case 'T':
+
+ for (j = 0; j < nargs; j ++, rowid ++) {
+ sqlite3_bind_text (stmt, rowid, va_arg (ap, const char*), -1,
+ SQLITE_STATIC);
+ }
+
+ nargs = 1;
+ break;
+ case 'I':
+
+ for (j = 0; j < nargs; j ++, rowid ++) {
+ sqlite3_bind_int64 (stmt, rowid, va_arg (ap, gint64));
+ }
+
+ nargs = 1;
+ break;
+ case 'S':
+
+ for (j = 0; j < nargs; j ++, rowid ++) {
+ sqlite3_bind_int (stmt, rowid, va_arg (ap, gint));
+ }
+
+ nargs = 1;
+ break;
+ case '*':
+ nargs = va_arg (ap, gint);
+ break;
+ }
+ }
+
+ va_end (ap);
+ retcode = sqlite3_step (stmt);
+
+ if (retcode == nst->result) {
+ argtypes = nst->ret;
+
+ for (i = 0; argtypes != NULL && argtypes[i] != '\0'; i ++) {
+ switch (argtypes[i]) {
+ case 'T':
+ *va_arg (ap, char**) = g_strdup (sqlite3_column_text (stmt, i));
+ break;
+ case 'I':
+ *va_arg (ap, gint64*) = sqlite3_column_int64 (stmt, i);
+ break;
+ case 'S':
+ *va_arg (ap, int*) = sqlite3_column_int (stmt, i);
+ break;
+ }
+ }
+
+ return SQLITE_OK;
+ }
+ else if (retcode != SQLITE_DONE) {
+ msg_debug ("failed to execute query %s: %d, %s", nst->sql,
+ retcode, sqlite3_errmsg (db));
+ }
+
+ return retcode;
+}
+
+void
+rspamd_sqlite3_close_prstmt (sqlite3 *db, GArray *stmts)
+{
+ guint i;
+ struct rspamd_sqlite3_prstmt *nst;
+
+ for (i = 0; i < stmts->len; i++) {
+ nst = &g_array_index (stmts, struct rspamd_sqlite3_prstmt, i);
+ if (nst->stmt != NULL) {
+ sqlite3_finalize (nst->stmt);
+ }
+ }
+
+ g_array_free (stmts, TRUE);
+
+ return;
+}
projects / thirdparty / rspamd.git / commitdiff
