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 void 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         sqlite3_finalize(st);
  85         return ;
  86 }
  87
  88 int zpm_findhash(struct zpm *zpm, char *find, char *dest) {
  89         int count;
  90         char *found;
  91
  92         count = zpm_db_int(zpm, "select count(*) from files where hash like '%q%%';", find);
  93         if (count != 1) {
  94                 return count;
  95         }
  96         if (dest) {
  97                 found = zpm_db_string(zpm, "select hash from files where hash like '%s%%' limit 1;", find);
  98                 if (find) {
  99                         strcpy(dest, found);
 100                         free(found);
 101                 } else {
 102                         count = 0;
 103                 }
 104         }
 105         return count;
 106
 107 }
 108
 109 char *zpm_db_string(struct zpm *zpm, char *query, ...) {
 110         sqlite3_stmt *st;
 111         va_list args;
 112         int rv;
 113         char *result = 0;
 114
 115         va_start(args, query);
 116         st = zpm_dbqueryv(zpm, query, args);
 117         va_end(args);
 118
 119         rv = sqlite3_step(st);
 120
 121         switch (rv) {
 122                 case SQLITE_ROW:
 123                 result = (char *)sqlite3_column_text(st, 0);
 124                 if (result) {
 125                         result = strdup(result);
 126                 }
 127                 break;
 128                 case SQLITE_DONE: break;
 129                 default:
 130                                   zpm->error = 1;
 131                                   zpm_seterror(zpm, "db error: %s", sqlite3_errstr(rv));
 132                                   break;
 133         }
 134
 135         sqlite3_finalize(st);
 136         return result;
 137 }
 138
 139 int zpm_db_int(struct zpm *zpm, char *query, ...) {
 140         sqlite3_stmt *st;
 141         va_list args;
 142         int rv;
 143         int result = 0;
 144
 145         va_start(args, query);
 146         st = zpm_dbqueryv(zpm, query, args);
 147         va_end(args);
 148
 149         rv = sqlite3_step(st);
 150
 151         if (rv == SQLITE_ROW) {
 152                 result = sqlite3_column_int(st, 0);
 153         }
 154         /* TODO set error if it's not SQLITE_ROW */
 155
 156         sqlite3_finalize(st);
 157         return result;
 158 }