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