pd.if.org Git - zpackage/blob - lib/dbquery.c

   1 #define _POSIX_C_SOURCE 200809L
   2
   3 #include <stdarg.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6
   7 #include "sqlite3.h"
   8 #include "zpm.h"
   9
  10 #define SQLERROR(x) fprintf(stderr, "%s %d: %s\n", __func__, __LINE__, (x))
  11
  12 sqlite3_stmt *zpm_dbqueryv(struct zpm *zpm, char *query, va_list args) {
  13         sqlite3 *db;
  14         char *sql;
  15         sqlite3_stmt *st;
  16         int rv;
  17
  18         if (!zpm || zpm->error) {
  19                 return 0;
  20         }
  21
  22         if (!zpm->db) {
  23                 zpm->error = 1;
  24                 return 0;
  25         }
  26
  27         db = zpm->db;
  28
  29         sql = sqlite3_vmprintf(query, args);
  30
  31         if (!sql) {
  32                 zpm->error = 1;
  33                 return 0;
  34         }
  35
  36         rv = sqlite3_prepare_v2(db, sql, strlen(sql), &st, NULL);
  37         if (rv != SQLITE_OK) {
  38                 SQLERROR(sqlite3_errmsg(db));
  39                 fprintf(stderr, "sql (%d): %s\n", rv, sql);
  40                 zpm->error = rv;
  41                 return 0;
  42         }
  43         sqlite3_free(sql);
  44
  45         return st;
  46 }
  47
  48 sqlite3_stmt *zpm_dbquery(struct zpm *zpm, char *query, ...) {
  49         va_list args;
  50         sqlite3_stmt *st;
  51
  52         if (!zpm || zpm->error) {
  53                 return 0;
  54         }
  55
  56         if (!zpm->db) {
  57                 zpm->error = 1;
  58                 return 0;
  59         }
  60
  61         va_start(args, query);
  62         st = zpm_dbqueryv(zpm, query, args);
  63         va_end(args);
  64
  65         return st;
  66 }
  67
  68 int zpm_db_run(struct zpm *zpm, char *query, ...) {
  69         sqlite3_stmt *st;
  70         va_list args;
  71         int rv;
  72
  73         va_start(args, query);
  74         st = zpm_dbqueryv(zpm, query, args);
  75         va_end(args);
  76
  77         rv = sqlite3_step(st);
  78
  79         if (rv != SQLITE_DONE) {
  80                 zpm->error = 1;
  81                 zpm_seterror(zpm, "db error: %s", sqlite3_errstr(rv));
  82         }
  83
  84         return sqlite3_finalize(st);
  85 }
  86
  87 int zpm_findhash(struct zpm *zpm, char *find, char *dest) {
  88         int count;
  89         char *found;
  90
  91         count = zpm_db_int(zpm, "select count(*) from files where hash like '%q%%';", find);
  92         if (count != 1) {
  93                 return count;
  94         }
  95         if (dest) {
  96                 found = zpm_db_string(zpm, "select hash from files where hash like '%s%%' limit 1;", find);
  97                 if (find) {
  98                         strcpy(dest, found);
  99                         free(found);
 100                 } else {
 101                         count = 0;
 102                 }
 103         }
 104         return count;
 105
 106 }
 107
 108 char *zpm_db_string(struct zpm *zpm, char *query, ...) {
 109         sqlite3_stmt *st;
 110         va_list args;
 111         int rv;
 112         char *result = 0;
 113
 114         va_start(args, query);
 115         st = zpm_dbqueryv(zpm, query, args);
 116         va_end(args);
 117
 118         rv = sqlite3_step(st);
 119
 120         switch (rv) {
 121                 case SQLITE_ROW:
 122                 result = (char *)sqlite3_column_text(st, 0);
 123                 if (result) {
 124                         result = strdup(result);
 125                 }
 126                 break;
 127                 case SQLITE_DONE: break;
 128                 default:
 129                                   zpm->error = 1;
 130                                   zpm_seterror(zpm, "db error: %s", sqlite3_errstr(rv));
 131                                   break;
 132         }
 133
 134         sqlite3_finalize(st);
 135         return result;
 136 }
 137
 138 int zpm_db_int(struct zpm *zpm, char *query, ...) {
 139         sqlite3_stmt *st;
 140         va_list args;
 141         int rv;
 142         int result = 0;
 143
 144         va_start(args, query);
 145         st = zpm_dbqueryv(zpm, query, args);
 146         va_end(args);
 147
 148         rv = sqlite3_step(st);
 149
 150         if (rv == SQLITE_ROW) {
 151                 result = sqlite3_column_int(st, 0);
 152         }
 153         /* TODO set error if it's not SQLITE_ROW */
 154
 155         sqlite3_finalize(st);
 156         return result;
 157 }