diff options
Diffstat (limited to 'src/storage_sqlite.c')
| -rw-r--r-- | src/storage_sqlite.c | 648 |
1 files changed, 324 insertions, 324 deletions
diff --git a/src/storage_sqlite.c b/src/storage_sqlite.c index ff651af..e8e75b5 100644 --- a/src/storage_sqlite.c +++ b/src/storage_sqlite.c @@ -22,504 +22,504 @@ #include <string.h> struct storage_sqlite_settings { - char* path; + char* path; }; int storage_sqlite_settings_create(struct storage_settings* settings, const char* path) { - struct storage_sqlite_settings* sqlite = malloc(sizeof(struct storage_sqlite_settings)); - if (!sqlite) { - log_errno("malloc"); - return -1; - } + struct storage_sqlite_settings* sqlite = malloc(sizeof(struct storage_sqlite_settings)); + if (!sqlite) { + log_errno("malloc"); + return -1; + } - sqlite->path = strdup(path); - if (!sqlite->path) { - log_errno("strdup"); - goto free; - } + sqlite->path = strdup(path); + if (!sqlite->path) { + log_errno("strdup"); + goto free; + } - settings->type = STORAGE_TYPE_SQLITE; - settings->sqlite = sqlite; - return 0; + settings->type = STORAGE_TYPE_SQLITE; + settings->sqlite = sqlite; + return 0; free: - free(sqlite); + free(sqlite); - return -1; + return -1; } void storage_sqlite_settings_destroy(const struct storage_settings* settings) { - free(settings->sqlite->path); - free(settings->sqlite); + free(settings->sqlite->path); + free(settings->sqlite); } struct prepared_stmt { - pthread_mutex_t mtx; - sqlite3_stmt* impl; + pthread_mutex_t mtx; + sqlite3_stmt* impl; }; static int prepared_stmt_init(struct prepared_stmt* stmt, sqlite3* db, const char* sql) { - int ret = 0; + int ret = 0; - ret = pthread_mutex_init(&stmt->mtx, NULL); - if (ret) { - pthread_errno(ret, "pthread_mutex_init"); - return ret; - } + ret = pthread_mutex_init(&stmt->mtx, NULL); + if (ret) { + pthread_errno(ret, "pthread_mutex_init"); + return ret; + } - ret = sqlite_prepare(db, sql, &stmt->impl); - if (ret < 0) - goto destroy_mtx; + ret = sqlite_prepare(db, sql, &stmt->impl); + if (ret < 0) + goto destroy_mtx; - return ret; + return ret; destroy_mtx: - pthread_errno_if(pthread_mutex_destroy(&stmt->mtx), "pthread_mutex_destroy"); + pthread_errno_if(pthread_mutex_destroy(&stmt->mtx), "pthread_mutex_destroy"); - return ret; + return ret; } static void prepared_stmt_destroy(struct prepared_stmt* stmt) { - pthread_errno_if(pthread_mutex_destroy(&stmt->mtx), "pthread_mutex_destroy"); - sqlite_finalize(stmt->impl); + pthread_errno_if(pthread_mutex_destroy(&stmt->mtx), "pthread_mutex_destroy"); + sqlite_finalize(stmt->impl); } static int prepared_stmt_lock(struct prepared_stmt* stmt) { - int ret = pthread_mutex_lock(&stmt->mtx); - if (ret) { - pthread_errno(ret, "pthread_mutex_unlock"); - return ret; - } - return ret; + int ret = pthread_mutex_lock(&stmt->mtx); + if (ret) { + pthread_errno(ret, "pthread_mutex_unlock"); + return ret; + } + return ret; } static void prepared_stmt_unlock(struct prepared_stmt* stmt) { - pthread_errno_if(pthread_mutex_unlock(&stmt->mtx), "pthread_mutex_unlock"); + pthread_errno_if(pthread_mutex_unlock(&stmt->mtx), "pthread_mutex_unlock"); } struct storage_sqlite { - sqlite3* db; + sqlite3* db; - struct prepared_stmt stmt_repo_find; - struct prepared_stmt stmt_repo_insert; - struct prepared_stmt stmt_run_insert; - struct prepared_stmt stmt_run_finished; - struct prepared_stmt stmt_get_runs; - struct prepared_stmt stmt_get_run_queue; + struct prepared_stmt stmt_repo_find; + struct prepared_stmt stmt_repo_insert; + struct prepared_stmt stmt_run_insert; + struct prepared_stmt stmt_run_finished; + struct prepared_stmt stmt_get_runs; + struct prepared_stmt stmt_get_run_queue; }; static int storage_sqlite_upgrade_to(struct storage_sqlite* storage, size_t version) { - static const char* const fmt = "%s PRAGMA user_version = %zu;"; + static const char* const fmt = "%s PRAGMA user_version = %zu;"; - const char* script = sqlite_schemas[version]; - int ret = 0; + const char* script = sqlite_schemas[version]; + int ret = 0; - ret = snprintf(NULL, 0, fmt, script, version + 1); - size_t nb = (size_t)ret + 1; - ret = 0; + ret = snprintf(NULL, 0, fmt, script, version + 1); + size_t nb = (size_t)ret + 1; + ret = 0; - char* full_script = malloc(nb); - if (!full_script) { - log_errno("malloc"); - return -1; - } - snprintf(full_script, nb, fmt, script, version + 1); + char* full_script = malloc(nb); + if (!full_script) { + log_errno("malloc"); + return -1; + } + snprintf(full_script, nb, fmt, script, version + 1); - ret = sqlite_exec_as_transaction(storage->db, full_script); - goto free; + ret = sqlite_exec_as_transaction(storage->db, full_script); + goto free; free: - free(full_script); + free(full_script); - return ret; + return ret; } static int storage_sqlite_upgrade_from_to(struct storage_sqlite* storage, size_t from, size_t to) { - int ret = 0; + int ret = 0; - for (size_t i = from; i < to; ++i) { - log("Upgrading SQLite database from version %zu to version %zu\n", i, i + 1); - ret = storage_sqlite_upgrade_to(storage, i); - if (ret < 0) { - log_err("Failed to upgrade to version %zu\n", i + 1); - return ret; - } - } + for (size_t i = from; i < to; ++i) { + log("Upgrading SQLite database from version %zu to version %zu\n", i, i + 1); + ret = storage_sqlite_upgrade_to(storage, i); + if (ret < 0) { + log_err("Failed to upgrade to version %zu\n", i + 1); + return ret; + } + } - return ret; + return ret; } static int storage_sqlite_upgrade(struct storage_sqlite* storage) { - unsigned int current_version = 0; - int ret = 0; + unsigned int current_version = 0; + int ret = 0; - ret = sqlite_get_user_version(storage->db, ¤t_version); - if (ret < 0) - return ret; - log("SQLite database version: %u\n", current_version); + ret = sqlite_get_user_version(storage->db, ¤t_version); + if (ret < 0) + return ret; + log("SQLite database version: %u\n", current_version); - size_t newest_version = sizeof(sqlite_schemas) / sizeof(sqlite_schemas[0]); - log("Newest database version: %zu\n", newest_version); + size_t newest_version = sizeof(sqlite_schemas) / sizeof(sqlite_schemas[0]); + log("Newest database version: %zu\n", newest_version); - if (current_version > newest_version) { - log_err("Unknown database version: %u\n", current_version); - return -1; - } + if (current_version > newest_version) { + log_err("Unknown database version: %u\n", current_version); + return -1; + } - if (current_version == newest_version) { - log("SQLite database already at the newest version\n"); - return 0; - } + if (current_version == newest_version) { + log("SQLite database already at the newest version\n"); + return 0; + } - return storage_sqlite_upgrade_from_to(storage, current_version, newest_version); + return storage_sqlite_upgrade_from_to(storage, current_version, newest_version); } static int storage_sqlite_setup(struct storage_sqlite* storage) { - int ret = 0; + int ret = 0; - ret = sqlite_set_foreign_keys(storage->db); - if (ret < 0) - return ret; + ret = sqlite_set_foreign_keys(storage->db); + if (ret < 0) + return ret; - ret = storage_sqlite_upgrade(storage); - if (ret < 0) - return ret; + ret = storage_sqlite_upgrade(storage); + if (ret < 0) + return ret; - return ret; + return ret; } static int storage_sqlite_prepare_statements(struct storage_sqlite* storage) { - static const char* const fmt_repo_find = "SELECT id FROM cimple_repos WHERE url = ?;"; - static const char* const fmt_repo_insert = - "INSERT INTO cimple_repos(url) VALUES (?) ON CONFLICT(url) DO NOTHING;"; - static const char* const fmt_run_insert = - "INSERT INTO cimple_runs(status, exit_code, output, repo_id, repo_rev) VALUES (?, -1, x'', ?, ?) RETURNING id;"; - static const char* const fmt_run_finished = - "UPDATE cimple_runs SET status = ?, exit_code = ?, output = ? WHERE id = ?;"; - static const char* const fmt_get_runs = - "SELECT id, status, exit_code, repo_url, repo_rev FROM cimple_runs_view ORDER BY id DESC"; - static const char* const fmt_get_run_queue = - "SELECT id, status, exit_code, repo_url, repo_rev FROM cimple_runs_view WHERE status = ? ORDER BY id;"; + static const char* const fmt_repo_find = "SELECT id FROM cimple_repos WHERE url = ?;"; + static const char* const fmt_repo_insert = + "INSERT INTO cimple_repos(url) VALUES (?) ON CONFLICT(url) DO NOTHING;"; + static const char* const fmt_run_insert = + "INSERT INTO cimple_runs(status, exit_code, output, repo_id, repo_rev) VALUES (?, -1, x'', ?, ?) RETURNING id;"; + static const char* const fmt_run_finished = + "UPDATE cimple_runs SET status = ?, exit_code = ?, output = ? WHERE id = ?;"; + static const char* const fmt_get_runs = + "SELECT id, status, exit_code, repo_url, repo_rev FROM cimple_runs_view ORDER BY id DESC"; + static const char* const fmt_get_run_queue = + "SELECT id, status, exit_code, repo_url, repo_rev FROM cimple_runs_view WHERE status = ? ORDER BY id;"; - int ret = 0; + int ret = 0; - ret = prepared_stmt_init(&storage->stmt_repo_find, storage->db, fmt_repo_find); - if (ret < 0) - return ret; - ret = prepared_stmt_init(&storage->stmt_repo_insert, storage->db, fmt_repo_insert); - if (ret < 0) - goto finalize_repo_find; - ret = prepared_stmt_init(&storage->stmt_run_insert, storage->db, fmt_run_insert); - if (ret < 0) - goto finalize_repo_insert; - ret = prepared_stmt_init(&storage->stmt_run_finished, storage->db, fmt_run_finished); - if (ret < 0) - goto finalize_run_insert; - ret = prepared_stmt_init(&storage->stmt_get_runs, storage->db, fmt_get_runs); - if (ret < 0) - goto finalize_run_finished; - ret = prepared_stmt_init(&storage->stmt_get_run_queue, storage->db, fmt_get_run_queue); - if (ret < 0) - goto finalize_get_runs; + ret = prepared_stmt_init(&storage->stmt_repo_find, storage->db, fmt_repo_find); + if (ret < 0) + return ret; + ret = prepared_stmt_init(&storage->stmt_repo_insert, storage->db, fmt_repo_insert); + if (ret < 0) + goto finalize_repo_find; + ret = prepared_stmt_init(&storage->stmt_run_insert, storage->db, fmt_run_insert); + if (ret < 0) + goto finalize_repo_insert; + ret = prepared_stmt_init(&storage->stmt_run_finished, storage->db, fmt_run_finished); + if (ret < 0) + goto finalize_run_insert; + ret = prepared_stmt_init(&storage->stmt_get_runs, storage->db, fmt_get_runs); + if (ret < 0) + goto finalize_run_finished; + ret = prepared_stmt_init(&storage->stmt_get_run_queue, storage->db, fmt_get_run_queue); + if (ret < 0) + goto finalize_get_runs; - return ret; + return ret; finalize_get_runs: - prepared_stmt_destroy(&storage->stmt_get_runs); + prepared_stmt_destroy(&storage->stmt_get_runs); finalize_run_finished: - prepared_stmt_destroy(&storage->stmt_run_finished); + prepared_stmt_destroy(&storage->stmt_run_finished); finalize_run_insert: - prepared_stmt_destroy(&storage->stmt_run_insert); + prepared_stmt_destroy(&storage->stmt_run_insert); finalize_repo_insert: - prepared_stmt_destroy(&storage->stmt_repo_insert); + prepared_stmt_destroy(&storage->stmt_repo_insert); finalize_repo_find: - prepared_stmt_destroy(&storage->stmt_repo_find); + prepared_stmt_destroy(&storage->stmt_repo_find); - return ret; + return ret; } static void storage_sqlite_finalize_statements(struct storage_sqlite* storage) { - prepared_stmt_destroy(&storage->stmt_get_run_queue); - prepared_stmt_destroy(&storage->stmt_get_runs); - prepared_stmt_destroy(&storage->stmt_run_finished); - prepared_stmt_destroy(&storage->stmt_run_insert); - prepared_stmt_destroy(&storage->stmt_repo_insert); - prepared_stmt_destroy(&storage->stmt_repo_find); + prepared_stmt_destroy(&storage->stmt_get_run_queue); + prepared_stmt_destroy(&storage->stmt_get_runs); + prepared_stmt_destroy(&storage->stmt_run_finished); + prepared_stmt_destroy(&storage->stmt_run_insert); + prepared_stmt_destroy(&storage->stmt_repo_insert); + prepared_stmt_destroy(&storage->stmt_repo_find); } int storage_sqlite_create(struct storage* storage, const struct storage_settings* settings) { - int ret = 0; + int ret = 0; - log("Using SQLite database at %s\n", settings->sqlite->path); + log("Using SQLite database at %s\n", settings->sqlite->path); - struct storage_sqlite* sqlite = malloc(sizeof(struct storage_sqlite)); - if (!sqlite) { - log_errno("malloc"); - return -1; - } + struct storage_sqlite* sqlite = malloc(sizeof(struct storage_sqlite)); + if (!sqlite) { + log_errno("malloc"); + return -1; + } - ret = sqlite_init(); - if (ret < 0) - goto free; - ret = sqlite_open_rw(settings->sqlite->path, &sqlite->db); - if (ret < 0) - goto destroy; - ret = storage_sqlite_setup(sqlite); - if (ret < 0) - goto close; - ret = storage_sqlite_prepare_statements(sqlite); - if (ret < 0) - goto close; + ret = sqlite_init(); + if (ret < 0) + goto free; + ret = sqlite_open_rw(settings->sqlite->path, &sqlite->db); + if (ret < 0) + goto destroy; + ret = storage_sqlite_setup(sqlite); + if (ret < 0) + goto close; + ret = storage_sqlite_prepare_statements(sqlite); + if (ret < 0) + goto close; - storage->sqlite = sqlite; - return ret; + storage->sqlite = sqlite; + return ret; close: - sqlite_close(storage->sqlite->db); + sqlite_close(storage->sqlite->db); destroy: - sqlite_destroy(); + sqlite_destroy(); free: - free(sqlite); + free(sqlite); - return ret; + return ret; } void storage_sqlite_destroy(struct storage* storage) { - storage_sqlite_finalize_statements(storage->sqlite); - sqlite_close(storage->sqlite->db); - sqlite_destroy(); - free(storage->sqlite); + storage_sqlite_finalize_statements(storage->sqlite); + sqlite_close(storage->sqlite->db); + sqlite_destroy(); + free(storage->sqlite); } static int storage_sqlite_find_repo(struct storage_sqlite* storage, const char* url) { - struct prepared_stmt* stmt = &storage->stmt_repo_find; - int ret = 0; + struct prepared_stmt* stmt = &storage->stmt_repo_find; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = sqlite_bind_text(stmt->impl, 1, url); - if (ret < 0) - goto reset; - ret = sqlite_step(stmt->impl); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = sqlite_bind_text(stmt->impl, 1, url); + if (ret < 0) + goto reset; + ret = sqlite_step(stmt->impl); + if (ret < 0) + goto reset; - if (!ret) - goto reset; + if (!ret) + goto reset; - ret = sqlite_column_int(stmt->impl, 0); - goto reset; + ret = sqlite_column_int(stmt->impl, 0); + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - return ret; + return ret; } static int storage_sqlite_insert_repo(struct storage_sqlite* storage, const char* url) { - struct prepared_stmt* stmt = &storage->stmt_repo_insert; - int ret = 0; + struct prepared_stmt* stmt = &storage->stmt_repo_insert; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = sqlite_bind_text(stmt->impl, 1, url); - if (ret < 0) - goto reset; - ret = sqlite_step(stmt->impl); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = sqlite_bind_text(stmt->impl, 1, url); + if (ret < 0) + goto reset; + ret = sqlite_step(stmt->impl); + if (ret < 0) + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - if (ret < 0) - return ret; + if (ret < 0) + return ret; - return storage_sqlite_find_repo(storage, url); + return storage_sqlite_find_repo(storage, url); } static int storage_sqlite_insert_run(struct storage_sqlite* storage, int repo_id, const char* rev) { - struct prepared_stmt* stmt = &storage->stmt_run_insert; - int ret = 0; + struct prepared_stmt* stmt = &storage->stmt_run_insert; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_CREATED); - if (ret < 0) - goto reset; - ret = sqlite_bind_int(stmt->impl, 2, repo_id); - if (ret < 0) - goto reset; - ret = sqlite_bind_text(stmt->impl, 3, rev); - if (ret < 0) - goto reset; - ret = sqlite_step(stmt->impl); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_CREATED); + if (ret < 0) + goto reset; + ret = sqlite_bind_int(stmt->impl, 2, repo_id); + if (ret < 0) + goto reset; + ret = sqlite_bind_text(stmt->impl, 3, rev); + if (ret < 0) + goto reset; + ret = sqlite_step(stmt->impl); + if (ret < 0) + goto reset; - if (!ret) { - ret = -1; - log_err("Failed to insert a run\n"); - goto reset; - } + if (!ret) { + ret = -1; + log_err("Failed to insert a run\n"); + goto reset; + } - ret = sqlite_column_int(stmt->impl, 0); - goto reset; + ret = sqlite_column_int(stmt->impl, 0); + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - return ret; + return ret; } int storage_sqlite_run_create(struct storage* storage, const char* repo_url, const char* rev) { - int ret = 0; + int ret = 0; - ret = storage_sqlite_insert_repo(storage->sqlite, repo_url); - if (ret < 0) - return ret; + ret = storage_sqlite_insert_repo(storage->sqlite, repo_url); + if (ret < 0) + return ret; - ret = storage_sqlite_insert_run(storage->sqlite, ret, rev); - if (ret < 0) - return ret; + ret = storage_sqlite_insert_run(storage->sqlite, ret, rev); + if (ret < 0) + return ret; - return ret; + return ret; } int storage_sqlite_run_finished(struct storage* storage, int run_id, const struct process_output* output) { - struct prepared_stmt* stmt = &storage->sqlite->stmt_run_finished; - int ret = 0; + struct prepared_stmt* stmt = &storage->sqlite->stmt_run_finished; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_FINISHED); - if (ret < 0) - goto reset; - ret = sqlite_bind_int(stmt->impl, 2, output->ec); - if (ret < 0) - goto reset; - ret = sqlite_bind_blob(stmt->impl, 3, output->data, output->data_size); - if (ret < 0) - goto reset; - ret = sqlite_bind_int(stmt->impl, 4, run_id); - if (ret < 0) - goto reset; - ret = sqlite_step(stmt->impl); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_FINISHED); + if (ret < 0) + goto reset; + ret = sqlite_bind_int(stmt->impl, 2, output->ec); + if (ret < 0) + goto reset; + ret = sqlite_bind_blob(stmt->impl, 3, output->data, output->data_size); + if (ret < 0) + goto reset; + ret = sqlite_bind_int(stmt->impl, 4, run_id); + if (ret < 0) + goto reset; + ret = sqlite_step(stmt->impl); + if (ret < 0) + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - return ret; + return ret; } static int storage_sqlite_row_to_run(struct sqlite3_stmt* stmt, struct run** run) { - int ret = 0; + int ret = 0; - int id = sqlite_column_int(stmt, 0); - int status = sqlite_column_int(stmt, 1); - int exit_code = sqlite_column_int(stmt, 2); + int id = sqlite_column_int(stmt, 0); + int status = sqlite_column_int(stmt, 1); + int exit_code = sqlite_column_int(stmt, 2); - char* url = NULL; - ret = sqlite_column_text(stmt, 3, &url); - if (ret < 0) - return ret; + char* url = NULL; + ret = sqlite_column_text(stmt, 3, &url); + if (ret < 0) + return ret; - char* rev = NULL; - ret = sqlite_column_text(stmt, 4, &rev); - if (ret < 0) - goto free_url; + char* rev = NULL; + ret = sqlite_column_text(stmt, 4, &rev); + if (ret < 0) + goto free_url; - ret = run_new(run, id, url, rev, status, exit_code); - if (ret < 0) - goto free_rev; + ret = run_new(run, id, url, rev, status, exit_code); + if (ret < 0) + goto free_rev; - log("Adding run %d for repository %s to the queue\n", id, url); + log("Adding run %d for repository %s to the queue\n", id, url); free_rev: - free(rev); + free(rev); free_url: - free(url); + free(url); - return ret; + return ret; } static int storage_sqlite_rows_to_runs(struct sqlite3_stmt* stmt, struct run_queue* queue) { - int ret = 0; + int ret = 0; - run_queue_create(queue); + run_queue_create(queue); - while (1) { - ret = sqlite_step(stmt); - if (!ret) - break; - if (ret < 0) - goto run_queue_destroy; + while (1) { + ret = sqlite_step(stmt); + if (!ret) + break; + if (ret < 0) + goto run_queue_destroy; - struct run* run = NULL; + struct run* run = NULL; - ret = storage_sqlite_row_to_run(stmt, &run); - if (ret < 0) - goto run_queue_destroy; + ret = storage_sqlite_row_to_run(stmt, &run); + if (ret < 0) + goto run_queue_destroy; - run_queue_add_last(queue, run); - } + run_queue_add_last(queue, run); + } - return ret; + return ret; run_queue_destroy: - run_queue_destroy(queue); + run_queue_destroy(queue); - return ret; + return ret; } int storage_sqlite_get_runs(struct storage* storage, struct run_queue* queue) { - struct prepared_stmt* stmt = &storage->sqlite->stmt_get_runs; - int ret = 0; + struct prepared_stmt* stmt = &storage->sqlite->stmt_get_runs; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = storage_sqlite_rows_to_runs(stmt->impl, queue); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = storage_sqlite_rows_to_runs(stmt->impl, queue); + if (ret < 0) + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - return ret; + return ret; } int storage_sqlite_get_run_queue(struct storage* storage, struct run_queue* queue) { - struct prepared_stmt* stmt = &storage->sqlite->stmt_get_run_queue; - int ret = 0; + struct prepared_stmt* stmt = &storage->sqlite->stmt_get_run_queue; + int ret = 0; - ret = prepared_stmt_lock(stmt); - if (ret < 0) - return ret; - ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_CREATED); - if (ret < 0) - goto reset; - ret = storage_sqlite_rows_to_runs(stmt->impl, queue); - if (ret < 0) - goto reset; + ret = prepared_stmt_lock(stmt); + if (ret < 0) + return ret; + ret = sqlite_bind_int(stmt->impl, 1, RUN_STATUS_CREATED); + if (ret < 0) + goto reset; + ret = storage_sqlite_rows_to_runs(stmt->impl, queue); + if (ret < 0) + goto reset; reset: - sqlite_reset(stmt->impl); - prepared_stmt_unlock(stmt); + sqlite_reset(stmt->impl); + prepared_stmt_unlock(stmt); - return ret; + return ret; } |