]> pd.if.org Git - zpackage/blob - lib/dbquery.c
add create package
[zpackage] / 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 }