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
  44         return st;
  45 }
  46
  47 sqlite3_stmt *zpm_dbquery(struct zpm *zpm, char *query, ...) {
  48         va_list args;
  49         sqlite3_stmt *st;
  50
  51         if (!zpm || zpm->error) {
  52                 return 0;
  53         }
  54
  55         if (!zpm->db) {
  56                 zpm->error = 1;
  57                 return 0;
  58         }
  59
  60         va_start(args, query);
  61         st = zpm_dbqueryv(zpm, query, args);
  62         va_end(args);
  63
  64         return st;
  65 }
  66
  67 void zpm_db_run(struct zpm *zpm, char *query, ...) {
  68         sqlite3_stmt *st;
  69         va_list args;
  70         int rv;
  71
  72         va_start(args, query);
  73         st = zpm_dbqueryv(zpm, query, args);
  74         va_end(args);
  75
  76         rv = sqlite3_step(st);
  77
  78         if (rv != SQLITE_DONE) {
  79                 zpm->error = 1;
  80                 zpm_seterror(zpm, "db error: %s", sqlite3_errstr(rv));
  81         }
  82
  83         sqlite3_finalize(st);
  84         return ;
  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 }