OpenDNSSEC-enforcer 2.1.10
db_backend_sqlite.c
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Jerry Lundström <lundstrom.jerry@gmail.com>
3 * Copyright (c) 2014 .SE (The Internet Infrastructure Foundation).
4 * Copyright (c) 2014 OpenDNSSEC AB (svb)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
22 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
24 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#include "db_backend_sqlite.h"
31#include "db_error.h"
32
33#include "log.h"
34
35#include <stdlib.h>
36#include <sqlite3.h>
37#include <stdio.h>
38#include <unistd.h>
39#include <string.h>
40#include <time.h>
41#include <pthread.h>
42#include <errno.h>
43
44static int db_backend_sqlite_transaction_rollback(void*);
45
49static int __sqlite3_initialized = 0;
50
60static pthread_mutex_t __sqlite_mutex = PTHREAD_MUTEX_INITIALIZER;
61static pthread_cond_t __sqlite_cond = PTHREAD_COND_INITIALIZER;
62
66typedef struct db_backend_sqlite {
67 sqlite3* db;
70 int time;
71 long usleep;
73
74
75
81 sqlite3_stmt* statement;
82 int fields;
85
86
87
91static int __db_backend_sqlite_busy_handler(void *data, int retry) {
92 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
93 struct timespec busy_ts;
94 int rc;
95 (void)retry;
96
97 if (!backend_sqlite) {
98 return 0;
99 }
100
101 ods_log_deeebug("db_backend_sqlite_busy_handler: Database busy, waiting...");
102
103 if (pthread_mutex_lock(&__sqlite_mutex)) {
104 ods_log_error("db_backend_sqlite_busy_handler: Mutex error");
105 return 0;
106 }
107 if (clock_gettime(CLOCK_REALTIME, &busy_ts)) {
108 pthread_mutex_unlock(&__sqlite_mutex);
109 return 0;
110 }
111
112 busy_ts.tv_nsec += backend_sqlite->usleep * 1000;
113 if (busy_ts.tv_nsec > 999999999) {
114 busy_ts.tv_sec += (busy_ts.tv_nsec / 1000000000);
115 busy_ts.tv_nsec -= (busy_ts.tv_nsec / 1000000000) * 1000000000;
116 }
117
118 rc = pthread_cond_timedwait(&__sqlite_cond, &__sqlite_mutex, &busy_ts);
119 if (rc == ETIMEDOUT) {
120 if (time(NULL) < (backend_sqlite->time + backend_sqlite->timeout)) {
121 ods_log_deeebug("db_backend_sqlite_busy_handler: Woke up, checking database...");
122 pthread_mutex_unlock(&__sqlite_mutex);
123 return 1;
124 }
125 pthread_mutex_unlock(&__sqlite_mutex);
126 return 0;
127 }
128 else if (rc) {
129 ods_log_error("db_backend_sqlite_busy_handler: pthread_cond_timedwait() error %d", rc);
130 pthread_mutex_unlock(&__sqlite_mutex);
131 return 0;
132 }
133
134 ods_log_deeebug("db_backend_sqlite_busy_handler: Woke up, checking database...");
135 pthread_mutex_unlock(&__sqlite_mutex);
136 return 1;
137}
138
142static inline int __db_backend_sqlite_prepare(db_backend_sqlite_t* backend_sqlite, sqlite3_stmt** statement, const char* sql, size_t size) {
143 int ret;
144
145 if (!backend_sqlite) {
146 return DB_ERROR_UNKNOWN;
147 }
148 if (!backend_sqlite->db) {
149 return DB_ERROR_UNKNOWN;
150 }
151 if (!statement) {
152 return DB_ERROR_UNKNOWN;
153 }
154 if (*statement) {
155 return DB_ERROR_UNKNOWN;
156 }
157 if (!sql) {
158 return DB_ERROR_UNKNOWN;
159 }
160
161 ods_log_debug("%s", sql);
162 backend_sqlite->time = time(NULL);
163 ret = sqlite3_prepare_v2(backend_sqlite->db,
164 sql,
165 size,
166 statement,
167 NULL);
168 if (ret != SQLITE_OK) {
169 ods_log_info("DB prepare SQL %s", sql);
170 ods_log_crit("DB prepare Err %d", ret);
171 if (*statement) {
172 sqlite3_finalize(*statement);
173 }
174 *statement = NULL;
175 return DB_ERROR_UNKNOWN;
176 }
177
178 return DB_OK;
179}
180
184static inline int __db_backend_sqlite_step(db_backend_sqlite_t* backend_sqlite, sqlite3_stmt* statement) {
185 /*
186 struct timespec busy_ts;
187 int rc, ret, been_busy = 0;
188 */
189 int ret;
190
191 if (!backend_sqlite) {
192 return SQLITE_INTERNAL;
193 }
194 if (!statement) {
195 return SQLITE_INTERNAL;
196 }
197
198 backend_sqlite->time = time(NULL);
199 ret = sqlite3_step(statement);
200 /*
201 if (ret == SQLITE_BUSY) {
202 ods_log_deeebug("db_backend_sqlite_step: Database busy, waiting...");
203 }
204 while (ret == SQLITE_BUSY) {
205 if (pthread_mutex_lock(&__sqlite_mutex)) {
206 ods_log_error("db_backend_sqlite_step: Mutex error");
207 return ret;
208 }
209 if (clock_gettime(CLOCK_REALTIME, &busy_ts)) {
210 pthread_mutex_unlock(&__sqlite_mutex);
211 return ret;
212 }
213
214 busy_ts.tv_sec += backend_sqlite->timeout;
215
216 rc = pthread_cond_timedwait(&__sqlite_cond, &__sqlite_mutex, &busy_ts);
217 if (rc == ETIMEDOUT) {
218 pthread_mutex_unlock(&__sqlite_mutex);
219 return ret;
220 }
221 else if (rc) {
222 ods_log_error("db_backend_sqlite_step: pthread_cond_timedwait() error %d", rc);
223 pthread_mutex_unlock(&__sqlite_mutex);
224 return ret;
225 }
226
227 ods_log_deeebug("db_backend_sqlite_step: Woke up, checking database...");
228 ret = sqlite3_step(statement);
229 pthread_mutex_unlock(&__sqlite_mutex);
230 }
231 if (been_busy) {
232 ods_log_deeebug("db_backend_sqlite_step: Got lock or failed/timed out");
233 }
234 */
235
236 return ret;
237}
238
244static inline int __db_backend_sqlite_finalize(sqlite3_stmt* statement) {
245 int ret;
246
247 ret = sqlite3_finalize(statement);
248 pthread_cond_broadcast(&__sqlite_cond);
249
250 return ret;
251}
252
253static int db_backend_sqlite_initialize(void* data) {
254 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
255
256 if (!backend_sqlite) {
257 return DB_ERROR_UNKNOWN;
258 }
259
260 if (!__sqlite3_initialized) {
261 int ret = sqlite3_initialize();
262 if (ret != SQLITE_OK) {
263 return DB_ERROR_UNKNOWN;
264 }
265 __sqlite3_initialized = 1;
266 }
267 return DB_OK;
268}
269
270static int db_backend_sqlite_shutdown(void* data) {
271 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
272
273 if (!backend_sqlite) {
274 return DB_ERROR_UNKNOWN;
275 }
276
277 if (__sqlite3_initialized) {
278 int ret = sqlite3_shutdown();
279 if (ret != SQLITE_OK) {
280 return DB_ERROR_UNKNOWN;
281 }
282 __sqlite3_initialized = 0;
283 }
284 return DB_OK;
285}
286
287static int db_backend_sqlite_connect(void* data, const db_configuration_list_t* configuration_list) {
288 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
289 const db_configuration_t* file;
290 const db_configuration_t* timeout;
291 const db_configuration_t* usleep;
292 int ret;
293
294 if (!__sqlite3_initialized) {
295 return DB_ERROR_UNKNOWN;
296 }
297 if (!backend_sqlite) {
298 return DB_ERROR_UNKNOWN;
299 }
300 if (backend_sqlite->db) {
301 return DB_ERROR_UNKNOWN;
302 }
303 if (!configuration_list) {
304 return DB_ERROR_UNKNOWN;
305 }
306
307 if (!(file = db_configuration_list_find(configuration_list, "file"))) {
308 return DB_ERROR_UNKNOWN;
309 }
310
312 if ((timeout = db_configuration_list_find(configuration_list, "timeout"))) {
313 backend_sqlite->timeout = atoi(db_configuration_value(timeout));
314 if (backend_sqlite->timeout < 1) {
316 }
317 }
318
320 if ((usleep = db_configuration_list_find(configuration_list, "usleep"))) {
321 backend_sqlite->usleep = atoi(db_configuration_value(usleep));
322 if (backend_sqlite->usleep < 1) {
324 }
325 }
326
327 ret = sqlite3_open_v2(
329 &(backend_sqlite->db),
330 SQLITE_OPEN_READWRITE
331 | SQLITE_OPEN_FULLMUTEX,
332 NULL);
333 if (ret != SQLITE_OK) {
334 return DB_ERROR_UNKNOWN;
335 }
336
337 if ((ret = sqlite3_busy_handler(backend_sqlite->db, __db_backend_sqlite_busy_handler, backend_sqlite)) != SQLITE_OK) {
338 ods_log_error("db_backend_sqlite: sqlite3_busy_handler() error %d", ret);
339 sqlite3_close(backend_sqlite->db);
340 backend_sqlite->db = NULL;
341 return DB_ERROR_UNKNOWN;
342 }
343 /*
344 * Enable This line to log complete queries to stdout.
345 * sqlite3_trace(backend_sqlite->db, printf, "SQL: %s\n");
346 * */
347
348 return DB_OK;
349}
350
351static int db_backend_sqlite_disconnect(void* data) {
352 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
353 int ret;
354
355 if (!__sqlite3_initialized) {
356 return DB_ERROR_UNKNOWN;
357 }
358 if (!backend_sqlite) {
359 return DB_ERROR_UNKNOWN;
360 }
361 if (!backend_sqlite->db) {
362 return DB_ERROR_UNKNOWN;
363 }
364
365 if (backend_sqlite->transaction) {
366 db_backend_sqlite_transaction_rollback(backend_sqlite);
367 }
368 ret = sqlite3_close(backend_sqlite->db);
369 if (ret != SQLITE_OK) {
370 return DB_ERROR_UNKNOWN;
371 }
372 backend_sqlite->db = NULL;
373 return DB_OK;
374}
375
385static int __db_backend_sqlite_build_clause(const db_object_t* object, const db_clause_list_t* clause_list, char** sqlp, int* left) {
386 const db_clause_t* clause;
387 int first, ret;
388
389 if (!clause_list) {
390 return DB_ERROR_UNKNOWN;
391 }
392 if (!sqlp) {
393 return DB_ERROR_UNKNOWN;
394 }
395 if (!*sqlp) {
396 return DB_ERROR_UNKNOWN;
397 }
398 if (!left) {
399 return DB_ERROR_UNKNOWN;
400 }
401 if (*left < 1) {
402 return DB_ERROR_UNKNOWN;
403 }
404
405 clause = db_clause_list_begin(clause_list);
406 first = 1;
407 while (clause) {
408 if (first) {
409 first = 0;
410 }
411 else {
412 switch (db_clause_operator(clause)) {
414 if ((ret = snprintf(*sqlp, *left, " AND")) >= *left) {
415 return DB_ERROR_UNKNOWN;
416 }
417 break;
418
420 if ((ret = snprintf(*sqlp, *left, " OR")) >= *left) {
421 return DB_ERROR_UNKNOWN;
422 }
423 break;
424
425 default:
426 return DB_ERROR_UNKNOWN;
427 }
428 *sqlp += ret;
429 *left -= ret;
430 }
431
432 switch (db_clause_type(clause)) {
433 case DB_CLAUSE_EQUAL:
434 if ((ret = snprintf(*sqlp, *left, " %s.%s = ?",
435 db_object_table(object),
436 db_clause_field(clause))) >= *left)
437 {
438 return DB_ERROR_UNKNOWN;
439 }
440 break;
441
443 if ((ret = snprintf(*sqlp, *left, " %s.%s != ?",
444 db_object_table(object),
445 db_clause_field(clause))) >= *left)
446 {
447 return DB_ERROR_UNKNOWN;
448 }
449 break;
450
452 if ((ret = snprintf(*sqlp, *left, " %s.%s < ?",
453 db_object_table(object),
454 db_clause_field(clause))) >= *left)
455 {
456 return DB_ERROR_UNKNOWN;
457 }
458 break;
459
461 if ((ret = snprintf(*sqlp, *left, " %s.%s <= ?",
462 db_object_table(object),
463 db_clause_field(clause))) >= *left)
464 {
465 return DB_ERROR_UNKNOWN;
466 }
467 break;
468
470 if ((ret = snprintf(*sqlp, *left, " %s.%s >= ?",
471 db_object_table(object),
472 db_clause_field(clause))) >= *left)
473 {
474 return DB_ERROR_UNKNOWN;
475 }
476 break;
477
479 if ((ret = snprintf(*sqlp, *left, " %s.%s > ?",
480 db_object_table(object),
481 db_clause_field(clause))) >= *left)
482 {
483 return DB_ERROR_UNKNOWN;
484 }
485 break;
486
488 if ((ret = snprintf(*sqlp, *left, " %s.%s IS NULL",
489 db_object_table(object),
490 db_clause_field(clause))) >= *left)
491 {
492 return DB_ERROR_UNKNOWN;
493 }
494 break;
495
497 if ((ret = snprintf(*sqlp, *left, " %s.%s IS NOT NULL",
498 db_object_table(object),
499 db_clause_field(clause))) >= *left)
500 {
501 return DB_ERROR_UNKNOWN;
502 }
503 break;
504
505 case DB_CLAUSE_NESTED:
506 if ((ret = snprintf(*sqlp, *left, " (")) >= *left) {
507 return DB_ERROR_UNKNOWN;
508 }
509 *sqlp += ret;
510 *left -= ret;
511 if (__db_backend_sqlite_build_clause(object, db_clause_list(clause), sqlp, left)) {
512 return DB_ERROR_UNKNOWN;
513 }
514 if ((ret = snprintf(*sqlp, *left, " )")) >= *left) {
515 return DB_ERROR_UNKNOWN;
516 }
517 break;
518
519 default:
520 return DB_ERROR_UNKNOWN;
521 }
522 *sqlp += ret;
523 *left -= ret;
524
525 clause = db_clause_next(clause);
526 }
527 return DB_OK;
528}
529
538static int __db_backend_sqlite_bind_clause(sqlite3_stmt* statement, const db_clause_list_t* clause_list, int* bind) {
539 const db_clause_t* clause;
540 int ret;
541 int to_int;
542 sqlite3_int64 to_int64;
543 db_type_int32_t int32;
544 db_type_uint32_t uint32;
545 db_type_int64_t int64;
546 db_type_uint64_t uint64;
547
548 if (!statement) {
549 return DB_ERROR_UNKNOWN;
550 }
551 if (!clause_list) {
552 return DB_ERROR_UNKNOWN;
553 }
554 if (!bind) {
555 return DB_ERROR_UNKNOWN;
556 }
557 if (!*bind) {
558 return DB_ERROR_UNKNOWN;
559 }
560
561 clause = db_clause_list_begin(clause_list);
562 while (clause) {
563 switch (db_clause_type(clause)) {
564 case DB_CLAUSE_EQUAL:
570 switch (db_value_type(db_clause_value(clause))) {
572 case DB_TYPE_INT32:
573 if (db_value_to_int32(db_clause_value(clause), &int32)) {
574 return DB_ERROR_UNKNOWN;
575 }
576 to_int = int32;
577 ret = sqlite3_bind_int(statement, (*bind)++, to_int);
578 if (ret != SQLITE_OK) {
579 return DB_ERROR_UNKNOWN;
580 }
581 break;
582
583 case DB_TYPE_UINT32:
584 if (db_value_to_uint32(db_clause_value(clause), &uint32)) {
585 return DB_ERROR_UNKNOWN;
586 }
587 to_int = uint32;
588 ret = sqlite3_bind_int(statement, (*bind)++, to_int);
589 if (ret != SQLITE_OK) {
590 return DB_ERROR_UNKNOWN;
591 }
592 break;
593
594 case DB_TYPE_INT64:
595 if (db_value_to_int64(db_clause_value(clause), &int64)) {
596 return DB_ERROR_UNKNOWN;
597 }
598 to_int64 = int64;
599 ret = sqlite3_bind_int64(statement, (*bind)++, to_int64);
600 if (ret != SQLITE_OK) {
601 return DB_ERROR_UNKNOWN;
602 }
603 break;
604
605 case DB_TYPE_UINT64:
606 if (db_value_to_uint64(db_clause_value(clause), &uint64)) {
607 return DB_ERROR_UNKNOWN;
608 }
609 to_int64 = uint64;
610 ret = sqlite3_bind_int64(statement, (*bind)++, to_int64);
611 if (ret != SQLITE_OK) {
612 return DB_ERROR_UNKNOWN;
613 }
614 break;
615
616 case DB_TYPE_TEXT:
617 ret = sqlite3_bind_text(statement, (*bind)++, db_value_text(db_clause_value(clause)), -1, SQLITE_TRANSIENT);
618 if (ret != SQLITE_OK) {
619 return DB_ERROR_UNKNOWN;
620 }
621 break;
622
623 case DB_TYPE_ENUM:
624 if (db_value_enum_value(db_clause_value(clause), &to_int)) {
625 return DB_ERROR_UNKNOWN;
626 }
627 ret = sqlite3_bind_int(statement, (*bind)++, to_int);
628 if (ret != SQLITE_OK) {
629 return DB_ERROR_UNKNOWN;
630 }
631 break;
632
633 default:
634 return DB_ERROR_UNKNOWN;
635 }
636 break;
637
640 break;
641
642 case DB_CLAUSE_NESTED:
643 if (__db_backend_sqlite_bind_clause(statement, db_clause_list(clause), bind)) {
644 return DB_ERROR_UNKNOWN;
645 }
646 break;
647
648 default:
649 return DB_ERROR_UNKNOWN;
650 }
651 clause = db_clause_next(clause);
652 }
653 return DB_OK;
654}
655
656static db_result_t* db_backend_sqlite_next(void* data, int finish) {
658 int ret;
659 int bind;
660 db_result_t* result = NULL;
661 db_value_set_t* value_set = NULL;
662 const db_object_field_t* object_field;
663 int from_int;
664 sqlite3_int64 from_int64;
665 db_type_int32_t int32;
666 db_type_uint32_t uint32;
667 db_type_int64_t int64;
668 db_type_uint64_t uint64;
669 const char* text;
670
671 if (!statement) {
672 return NULL;
673 }
674 if (!statement->object) {
675 return NULL;
676 }
677 if (!statement->statement) {
678 return NULL;
679 }
680
681 if (finish) {
682 __db_backend_sqlite_finalize(statement->statement);
683 free(statement);
684 return NULL;
685 }
686
687 if (__db_backend_sqlite_step(statement->backend_sqlite, statement->statement) != SQLITE_ROW) {
688 return NULL;
689 }
690
691 if (!(result = db_result_new())
692 || !(value_set = db_value_set_new(statement->fields))
693 || db_result_set_value_set(result, value_set))
694 {
695 db_result_free(result);
696 db_value_set_free(value_set);
697 return NULL;
698 }
700 bind = 0;
701 while (object_field) {
702 switch (db_object_field_type(object_field)) {
704 from_int = sqlite3_column_int(statement->statement, bind);
705 int32 = from_int;
706 ret = sqlite3_errcode(statement->backend_sqlite->db);
707 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
708 || db_value_from_int32(db_value_set_get(value_set, bind), int32)
709 || db_value_set_primary_key(db_value_set_get(value_set, bind)))
710 {
711 db_result_free(result);
712 return NULL;
713 }
714 break;
715
716 case DB_TYPE_ENUM:
717 /*
718 * Enum needs to be handled elsewhere since we don't know the
719 * enum_set_t here.
720 */
721 case DB_TYPE_INT32:
722 from_int = sqlite3_column_int(statement->statement, bind);
723 int32 = from_int;
724 ret = sqlite3_errcode(statement->backend_sqlite->db);
725 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
726 || db_value_from_int32(db_value_set_get(value_set, bind), int32))
727 {
728 db_result_free(result);
729 return NULL;
730 }
731 break;
732
733 case DB_TYPE_UINT32:
734 from_int = sqlite3_column_int(statement->statement, bind);
735 uint32 = from_int;
736 ret = sqlite3_errcode(statement->backend_sqlite->db);
737 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
738 || db_value_from_uint32(db_value_set_get(value_set, bind), uint32))
739 {
740 db_result_free(result);
741 return NULL;
742 }
743 break;
744
745 case DB_TYPE_INT64:
746 from_int64 = sqlite3_column_int64(statement->statement, bind);
747 int64 = from_int64;
748 ret = sqlite3_errcode(statement->backend_sqlite->db);
749 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
750 || db_value_from_int64(db_value_set_get(value_set, bind), int64))
751 {
752 db_result_free(result);
753 return NULL;
754 }
755 break;
756
757 case DB_TYPE_UINT64:
758 from_int64 = sqlite3_column_int64(statement->statement, bind);
759 uint64 = from_int64;
760 ret = sqlite3_errcode(statement->backend_sqlite->db);
761 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
762 || db_value_from_uint64(db_value_set_get(value_set, bind), uint64))
763 {
764 db_result_free(result);
765 return NULL;
766 }
767 break;
768
769 case DB_TYPE_TEXT:
770 text = (const char*)sqlite3_column_text(statement->statement, bind);
771 ret = sqlite3_errcode(statement->backend_sqlite->db);
772 if (!text
773 || (ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
774 || db_value_from_text(db_value_set_get(value_set, bind), text))
775 {
776 db_result_free(result);
777 return NULL;
778 }
779 break;
780
781 case DB_TYPE_ANY:
782 case DB_TYPE_REVISION:
783 switch (sqlite3_column_type(statement->statement, bind)) {
784 case SQLITE_INTEGER:
785 from_int64 = sqlite3_column_int64(statement->statement, bind);
786 int64 = from_int64;
787 ret = sqlite3_errcode(statement->backend_sqlite->db);
788 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
789 || db_value_from_int64(db_value_set_get(value_set, bind), int64))
790 {
791 db_result_free(result);
792 return NULL;
793 }
794 break;
795
796 case SQLITE_TEXT:
797 text = (const char*)sqlite3_column_text(statement->statement, bind);
798 ret = sqlite3_errcode(statement->backend_sqlite->db);
799 if (!text
800 || (ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)
801 || db_value_from_text(db_value_set_get(value_set, bind), text))
802 {
803 db_result_free(result);
804 return NULL;
805 }
806 break;
807
808 default:
809 db_result_free(result);
810 return NULL;
811 }
812 break;
813
814 default:
815 db_result_free(result);
816 return NULL;
817 }
818 object_field = db_object_field_next(object_field);
819 bind++;
820 }
821 return result;
822}
823
824static int db_backend_sqlite_create(void* data, const db_object_t* object, const db_object_field_list_t* object_field_list, const db_value_set_t* value_set) {
825 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
826 const db_object_field_t* object_field;
827 const db_object_field_t* revision_field = NULL;
828 const db_value_t* value;
829 char sql[4*1024];
830 char* sqlp;
831 int ret, left, bind, first;
832 sqlite3_stmt* statement = NULL;
833 size_t value_pos;
834 int to_int;
835 sqlite3_int64 to_int64;
836 db_type_int32_t int32;
837 db_type_uint32_t uint32;
838 db_type_int64_t int64;
839 db_type_uint64_t uint64;
840
841 if (!__sqlite3_initialized) {
842 return DB_ERROR_UNKNOWN;
843 }
844 if (!backend_sqlite) {
845 return DB_ERROR_UNKNOWN;
846 }
847 if (!object) {
848 return DB_ERROR_UNKNOWN;
849 }
850 if (!object_field_list) {
851 return DB_ERROR_UNKNOWN;
852 }
853 if (!value_set) {
854 return DB_ERROR_UNKNOWN;
855 }
856
857 /*
858 * Check if the object has a revision field and keep it for later use.
859 */
861 while (object_field) {
862 if (db_object_field_type(object_field) == DB_TYPE_REVISION) {
863 if (revision_field) {
864 /*
865 * We do not support multiple revision fields.
866 */
867 return DB_ERROR_UNKNOWN;
868 }
869
870 revision_field = object_field;
871 }
872 object_field = db_object_field_next(object_field);
873 }
874
875 left = sizeof(sql);
876 sqlp = sql;
877 memset(sql, 0, left);
878
879 if (!db_object_field_list_begin(object_field_list) && !revision_field) {
880 /*
881 * Special case when tables has no fields except maybe a primary key.
882 */
883 if ((ret = snprintf(sqlp, left, "INSERT INTO %s DEFAULT VALUES", db_object_table(object))) >= left) {
884 return DB_ERROR_UNKNOWN;
885 }
886 sqlp += ret;
887 left -= ret;
888 }
889 else {
890 if ((ret = snprintf(sqlp, left, "INSERT INTO %s (", db_object_table(object))) >= left) {
891 return DB_ERROR_UNKNOWN;
892 }
893 sqlp += ret;
894 left -= ret;
895
896 /*
897 * Add the fields from the given object_field_list.
898 */
899 object_field = db_object_field_list_begin(object_field_list);
900 first = 1;
901 while (object_field) {
902 if (first) {
903 if ((ret = snprintf(sqlp, left, " %s", db_object_field_name(object_field))) >= left) {
904 return DB_ERROR_UNKNOWN;
905 }
906 first = 0;
907 }
908 else {
909 if ((ret = snprintf(sqlp, left, ", %s", db_object_field_name(object_field))) >= left) {
910 return DB_ERROR_UNKNOWN;
911 }
912 }
913 sqlp += ret;
914 left -= ret;
915
916 object_field = db_object_field_next(object_field);
917 }
918
919 /*
920 * Add the revision field if we have one.
921 */
922 if (revision_field) {
923 if (first) {
924 if ((ret = snprintf(sqlp, left, " %s", db_object_field_name(revision_field))) >= left) {
925 return DB_ERROR_UNKNOWN;
926 }
927 first = 0;
928 }
929 else {
930 if ((ret = snprintf(sqlp, left, ", %s", db_object_field_name(revision_field))) >= left) {
931 return DB_ERROR_UNKNOWN;
932 }
933 }
934 sqlp += ret;
935 left -= ret;
936 }
937
938 if ((ret = snprintf(sqlp, left, " ) VALUES (")) >= left) {
939 return DB_ERROR_UNKNOWN;
940 }
941 sqlp += ret;
942 left -= ret;
943
944 /*
945 * Mark all the fields for binding from the object_field_list.
946 */
947 object_field = db_object_field_list_begin(object_field_list);
948 first = 1;
949 while (object_field) {
950 if (first) {
951 if ((ret = snprintf(sqlp, left, " ?")) >= left) {
952 return DB_ERROR_UNKNOWN;
953 }
954 first = 0;
955 }
956 else {
957 if ((ret = snprintf(sqlp, left, ", ?")) >= left) {
958 return DB_ERROR_UNKNOWN;
959 }
960 }
961 sqlp += ret;
962 left -= ret;
963
964 object_field = db_object_field_next(object_field);
965 }
966
967 /*
968 * Mark revision field for binding if we have one.
969 */
970 if (revision_field) {
971 if (first) {
972 if ((ret = snprintf(sqlp, left, " ?")) >= left) {
973 return DB_ERROR_UNKNOWN;
974 }
975 first = 0;
976 }
977 else {
978 if ((ret = snprintf(sqlp, left, ", ?")) >= left) {
979 return DB_ERROR_UNKNOWN;
980 }
981 }
982 sqlp += ret;
983 left -= ret;
984 }
985
986 if ((ret = snprintf(sqlp, left, " )")) >= left) {
987 return DB_ERROR_UNKNOWN;
988 }
989 sqlp += ret;
990 left -= ret;
991 }
992
993 /*
994 * Prepare the SQL, create a SQLite statement.
995 */
996 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, sizeof(sql))) {
997 return DB_ERROR_UNKNOWN;
998 }
999
1000 /*
1001 * Bind all the values from value_set.
1002 */
1003 bind = 1;
1004 for (value_pos = 0; value_pos < db_value_set_size(value_set); value_pos++) {
1005 if (!(value = db_value_set_at(value_set, value_pos))) {
1006 __db_backend_sqlite_finalize(statement);
1007 return DB_ERROR_UNKNOWN;
1008 }
1009
1010 switch (db_value_type(value)) {
1011 case DB_TYPE_INT32:
1012 if (db_value_to_int32(value, &int32)) {
1013 __db_backend_sqlite_finalize(statement);
1014 return DB_ERROR_UNKNOWN;
1015 }
1016 to_int = int32;
1017 ret = sqlite3_bind_int(statement, bind++, to_int);
1018 if (ret != SQLITE_OK) {
1019 __db_backend_sqlite_finalize(statement);
1020 return DB_ERROR_UNKNOWN;
1021 }
1022 break;
1023
1024 case DB_TYPE_UINT32:
1025 if (db_value_to_uint32(value, &uint32)) {
1026 __db_backend_sqlite_finalize(statement);
1027 return DB_ERROR_UNKNOWN;
1028 }
1029 to_int = uint32;
1030 ret = sqlite3_bind_int(statement, bind++, to_int);
1031 if (ret != SQLITE_OK) {
1032 __db_backend_sqlite_finalize(statement);
1033 return DB_ERROR_UNKNOWN;
1034 }
1035 break;
1036
1037 case DB_TYPE_INT64:
1038 if (db_value_to_int64(value, &int64)) {
1039 __db_backend_sqlite_finalize(statement);
1040 return DB_ERROR_UNKNOWN;
1041 }
1042 to_int64 = int64;
1043 ret = sqlite3_bind_int64(statement, bind++, to_int64);
1044 if (ret != SQLITE_OK) {
1045 __db_backend_sqlite_finalize(statement);
1046 return DB_ERROR_UNKNOWN;
1047 }
1048 break;
1049
1050 case DB_TYPE_UINT64:
1051 if (db_value_to_uint64(value, &uint64)) {
1052 __db_backend_sqlite_finalize(statement);
1053 return DB_ERROR_UNKNOWN;
1054 }
1055 to_int64 = uint64;
1056 ret = sqlite3_bind_int64(statement, bind++, to_int64);
1057 if (ret != SQLITE_OK) {
1058 __db_backend_sqlite_finalize(statement);
1059 return DB_ERROR_UNKNOWN;
1060 }
1061 break;
1062
1063 case DB_TYPE_TEXT:
1064 ret = sqlite3_bind_text(statement, bind++, db_value_text(value), -1, SQLITE_TRANSIENT);
1065 if (ret != SQLITE_OK) {
1066 __db_backend_sqlite_finalize(statement);
1067 return DB_ERROR_UNKNOWN;
1068 }
1069 break;
1070
1071 case DB_TYPE_ENUM:
1072 if (db_value_enum_value(value, &to_int)) {
1073 __db_backend_sqlite_finalize(statement);
1074 return DB_ERROR_UNKNOWN;
1075 }
1076 ret = sqlite3_bind_int(statement, bind++, to_int);
1077 if (ret != SQLITE_OK) {
1078 __db_backend_sqlite_finalize(statement);
1079 return DB_ERROR_UNKNOWN;
1080 }
1081 break;
1082
1083 default:
1084 __db_backend_sqlite_finalize(statement);
1085 return DB_ERROR_UNKNOWN;
1086 }
1087 }
1088
1089 /*
1090 * Bind the revision field value if we have one.
1091 */
1092 if (revision_field) {
1093 ret = sqlite3_bind_int(statement, bind++, 1);
1094 if (ret != SQLITE_OK) {
1095 __db_backend_sqlite_finalize(statement);
1096 return DB_ERROR_UNKNOWN;
1097 }
1098 }
1099
1100 /*
1101 * Execute the SQL.
1102 */
1103 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1104 __db_backend_sqlite_finalize(statement);
1105 return DB_ERROR_UNKNOWN;
1106 }
1107 __db_backend_sqlite_finalize(statement);
1108
1109 return DB_OK;
1110}
1111
1112static db_result_list_t* db_backend_sqlite_read(void* data, const db_object_t* object, const db_join_list_t* join_list, const db_clause_list_t* clause_list) {
1113 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1114 const db_object_field_t* object_field;
1115 const db_join_t* join;
1116 char sql[4*1024];
1117 char* sqlp;
1118 int ret, left, first, fields, bind;
1119 db_result_list_t* result_list;
1121
1122 if (!__sqlite3_initialized) {
1123 return NULL;
1124 }
1125 if (!backend_sqlite) {
1126 return NULL;
1127 }
1128 if (!object) {
1129 return NULL;
1130 }
1131
1132 left = sizeof(sql);
1133 sqlp = sql;
1134 memset(sql, 0, left);
1135
1136 if ((ret = snprintf(sqlp, left, "SELECT")) >= left) {
1137 return NULL;
1138 }
1139 sqlp += ret;
1140 left -= ret;
1141
1143 first = 1;
1144 fields = 0;
1145 while (object_field) {
1146 if (first) {
1147 if ((ret = snprintf(sqlp, left, " %s.%s", db_object_table(object), db_object_field_name(object_field))) >= left) {
1148 return NULL;
1149 }
1150 first = 0;
1151 }
1152 else {
1153 if ((ret = snprintf(sqlp, left, ", %s.%s", db_object_table(object), db_object_field_name(object_field))) >= left) {
1154 return NULL;
1155 }
1156 }
1157 sqlp += ret;
1158 left -= ret;
1159
1160 object_field = db_object_field_next(object_field);
1161 fields++;
1162 }
1163
1164 if ((ret = snprintf(sqlp, left, " FROM %s", db_object_table(object))) >= left) {
1165 return NULL;
1166 }
1167 sqlp += ret;
1168 left -= ret;
1169
1170 if (join_list) {
1171 join = db_join_list_begin(join_list);
1172 while (join) {
1173 if ((ret = snprintf(sqlp, left, " INNER JOIN %s ON %s.%s = %s.%s",
1174 db_join_to_table(join),
1175 db_join_to_table(join),
1176 db_join_to_field(join),
1177 db_join_from_table(join),
1178 db_join_from_field(join))) >= left)
1179 {
1180 return NULL;
1181 }
1182 sqlp += ret;
1183 left -= ret;
1184 join = db_join_next(join);
1185 }
1186 }
1187
1188 if (clause_list) {
1189 if (db_clause_list_begin(clause_list)) {
1190 if ((ret = snprintf(sqlp, left, " WHERE")) >= left) {
1191 return NULL;
1192 }
1193 sqlp += ret;
1194 left -= ret;
1195 }
1196 if (__db_backend_sqlite_build_clause(object, clause_list, &sqlp, &left)) {
1197 return NULL;
1198 }
1199 }
1200
1201 statement = calloc(1, sizeof(db_backend_sqlite_statement_t));
1202 if (!statement) {
1203 return NULL;
1204 }
1205 statement->backend_sqlite = backend_sqlite;
1206 statement->object = object;
1207 statement->fields = fields;
1208 statement->statement = NULL;
1209
1210 if (__db_backend_sqlite_prepare(backend_sqlite, &(statement->statement), sql, sizeof(sql))) {
1211 free(statement);
1212 return NULL;
1213 }
1214
1215 if (clause_list) {
1216 bind = 1;
1217 if (__db_backend_sqlite_bind_clause(statement->statement, clause_list, &bind)) {
1218 __db_backend_sqlite_finalize(statement->statement);
1219 free(statement);
1220 return NULL;
1221 }
1222 }
1223
1224 if (!(result_list = db_result_list_new())
1225 || db_result_list_set_next(result_list, db_backend_sqlite_next, statement, 0))
1226 {
1227 db_result_list_free(result_list);
1228 __db_backend_sqlite_finalize(statement->statement);
1229 free(statement);
1230 return NULL;
1231 }
1232 return result_list;
1233}
1234
1235static int db_backend_sqlite_update(void* data, const db_object_t* object, const db_object_field_list_t* object_field_list, const db_value_set_t* value_set, const db_clause_list_t* clause_list) {
1236 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1237 const db_object_field_t* object_field;
1238 const db_object_field_t* revision_field = NULL;
1239 const db_clause_t* clause;
1240 const db_clause_t* revision_clause = NULL;
1241 sqlite3_int64 revision_number = -1;
1242 const db_value_t* value;
1243 char sql[4*1024];
1244 char* sqlp;
1245 int ret, left, bind, first;
1246 sqlite3_stmt* statement = NULL;
1247 size_t value_pos;
1248 int to_int;
1249 sqlite3_int64 to_int64;
1250 db_type_int32_t int32;
1251 db_type_uint32_t uint32;
1252 db_type_int64_t int64;
1253 db_type_uint64_t uint64;
1254
1255 if (!__sqlite3_initialized) {
1256 return DB_ERROR_UNKNOWN;
1257 }
1258 if (!backend_sqlite) {
1259 return DB_ERROR_UNKNOWN;
1260 }
1261 if (!object) {
1262 return DB_ERROR_UNKNOWN;
1263 }
1264 if (!object_field_list) {
1265 return DB_ERROR_UNKNOWN;
1266 }
1267 if (!value_set) {
1268 return DB_ERROR_UNKNOWN;
1269 }
1270
1271 /*
1272 * Check if the object has a revision field and keep it for later use.
1273 */
1275 while (object_field) {
1276 if (db_object_field_type(object_field) == DB_TYPE_REVISION) {
1277 if (revision_field) {
1278 /*
1279 * We do not support multiple revision fields.
1280 */
1281 return DB_ERROR_UNKNOWN;
1282 }
1283
1284 revision_field = object_field;
1285 }
1286 object_field = db_object_field_next(object_field);
1287 }
1288 if (revision_field) {
1289 /*
1290 * If we have a revision field we should also have it in the clause,
1291 * find it and get the value for later use or return error if not found.
1292 */
1293 clause = db_clause_list_begin(clause_list);
1294 while (clause) {
1295 if (!strcmp(db_clause_field(clause), db_object_field_name(revision_field))) {
1296 revision_clause = clause;
1297 break;
1298 }
1299 clause = db_clause_next(clause);
1300 }
1301 if (!revision_clause) {
1302 return DB_ERROR_UNKNOWN;
1303 }
1304 switch (db_value_type(db_clause_value(revision_clause))) {
1305 case DB_TYPE_INT32:
1306 if (db_value_to_int32(db_clause_value(revision_clause), &int32)) {
1307 return DB_ERROR_UNKNOWN;
1308 }
1309 revision_number = int32;
1310 break;
1311
1312 case DB_TYPE_UINT32:
1313 if (db_value_to_uint32(db_clause_value(revision_clause), &uint32)) {
1314 return DB_ERROR_UNKNOWN;
1315 }
1316 revision_number = uint32;
1317 break;
1318
1319 case DB_TYPE_INT64:
1320 if (db_value_to_int64(db_clause_value(revision_clause), &int64)) {
1321 return DB_ERROR_UNKNOWN;
1322 }
1323 revision_number = int64;
1324 break;
1325
1326 case DB_TYPE_UINT64:
1327 if (db_value_to_uint64(db_clause_value(revision_clause), &uint64)) {
1328 return DB_ERROR_UNKNOWN;
1329 }
1330 revision_number = uint64;
1331 break;
1332
1333 default:
1334 return DB_ERROR_UNKNOWN;
1335 }
1336 }
1337
1338 left = sizeof(sql);
1339 sqlp = sql;
1340 memset(sql, 0, left);
1341
1342 if ((ret = snprintf(sqlp, left, "UPDATE %s SET", db_object_table(object))) >= left) {
1343 return DB_ERROR_UNKNOWN;
1344 }
1345 sqlp += ret;
1346 left -= ret;
1347
1348 /*
1349 * Build the update SQL from the object_field_list.
1350 */
1351 object_field = db_object_field_list_begin(object_field_list);
1352 first = 1;
1353 while (object_field) {
1354 if (first) {
1355 if ((ret = snprintf(sqlp, left, " %s = ?", db_object_field_name(object_field))) >= left) {
1356 return DB_ERROR_UNKNOWN;
1357 }
1358 first = 0;
1359 }
1360 else {
1361 if ((ret = snprintf(sqlp, left, ", %s = ?", db_object_field_name(object_field))) >= left) {
1362 return DB_ERROR_UNKNOWN;
1363 }
1364 }
1365 sqlp += ret;
1366 left -= ret;
1367
1368 object_field = db_object_field_next(object_field);
1369 }
1370
1371 /*
1372 * Add a new revision if we have any.
1373 */
1374 if (revision_field) {
1375 if (first) {
1376 if ((ret = snprintf(sqlp, left, " %s = ?", db_object_field_name(revision_field))) >= left) {
1377 return DB_ERROR_UNKNOWN;
1378 }
1379 first = 0;
1380 }
1381 else {
1382 if ((ret = snprintf(sqlp, left, ", %s = ?", db_object_field_name(revision_field))) >= left) {
1383 return DB_ERROR_UNKNOWN;
1384 }
1385 }
1386 sqlp += ret;
1387 left -= ret;
1388 }
1389
1390 /*
1391 * Build the clauses.
1392 */
1393 if (clause_list) {
1394 if (db_clause_list_begin(clause_list)) {
1395 if ((ret = snprintf(sqlp, left, " WHERE")) >= left) {
1396 return DB_ERROR_UNKNOWN;
1397 }
1398 sqlp += ret;
1399 left -= ret;
1400 }
1401 if (__db_backend_sqlite_build_clause(object, clause_list, &sqlp, &left)) {
1402 return DB_ERROR_UNKNOWN;
1403 }
1404 }
1405
1406 /*
1407 * Prepare the SQL.
1408 */
1409 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, sizeof(sql))) {
1410 return DB_ERROR_UNKNOWN;
1411 }
1412
1413 /*
1414 * Bind all the values from value_set.
1415 */
1416 bind = 1;
1417 for (value_pos = 0; value_pos < db_value_set_size(value_set); value_pos++) {
1418 if (!(value = db_value_set_at(value_set, value_pos))) {
1419 __db_backend_sqlite_finalize(statement);
1420 return DB_ERROR_UNKNOWN;
1421 }
1422
1423 switch (db_value_type(value)) {
1424 case DB_TYPE_INT32:
1425 if (db_value_to_int32(value, &int32)) {
1426 __db_backend_sqlite_finalize(statement);
1427 return DB_ERROR_UNKNOWN;
1428 }
1429 to_int = int32;
1430 ret = sqlite3_bind_int(statement, bind++, to_int);
1431 if (ret != SQLITE_OK) {
1432 __db_backend_sqlite_finalize(statement);
1433 return DB_ERROR_UNKNOWN;
1434 }
1435 break;
1436
1437 case DB_TYPE_UINT32:
1438 if (db_value_to_uint32(value, &uint32)) {
1439 __db_backend_sqlite_finalize(statement);
1440 return DB_ERROR_UNKNOWN;
1441 }
1442 to_int = uint32;
1443 ret = sqlite3_bind_int(statement, bind++, to_int);
1444 if (ret != SQLITE_OK) {
1445 __db_backend_sqlite_finalize(statement);
1446 return DB_ERROR_UNKNOWN;
1447 }
1448 break;
1449
1450 case DB_TYPE_INT64:
1451 if (db_value_to_int64(value, &int64)) {
1452 __db_backend_sqlite_finalize(statement);
1453 return DB_ERROR_UNKNOWN;
1454 }
1455 to_int64 = int64;
1456 ret = sqlite3_bind_int64(statement, bind++, to_int64);
1457 if (ret != SQLITE_OK) {
1458 __db_backend_sqlite_finalize(statement);
1459 return DB_ERROR_UNKNOWN;
1460 }
1461 break;
1462
1463 case DB_TYPE_UINT64:
1464 if (db_value_to_uint64(value, &uint64)) {
1465 __db_backend_sqlite_finalize(statement);
1466 return DB_ERROR_UNKNOWN;
1467 }
1468 to_int64 = uint64;
1469 ret = sqlite3_bind_int64(statement, bind++, to_int64);
1470 if (ret != SQLITE_OK) {
1471 __db_backend_sqlite_finalize(statement);
1472 return DB_ERROR_UNKNOWN;
1473 }
1474 break;
1475
1476 case DB_TYPE_TEXT:
1477 ret = sqlite3_bind_text(statement, bind++, db_value_text(value), -1, SQLITE_TRANSIENT);
1478 if (ret != SQLITE_OK) {
1479 __db_backend_sqlite_finalize(statement);
1480 return DB_ERROR_UNKNOWN;
1481 }
1482 break;
1483
1484 case DB_TYPE_ENUM:
1485 if (db_value_enum_value(value, &to_int)) {
1486 __db_backend_sqlite_finalize(statement);
1487 return DB_ERROR_UNKNOWN;
1488 }
1489 ret = sqlite3_bind_int(statement, bind++, to_int);
1490 if (ret != SQLITE_OK) {
1491 __db_backend_sqlite_finalize(statement);
1492 return DB_ERROR_UNKNOWN;
1493 }
1494 break;
1495
1496 default:
1497 __db_backend_sqlite_finalize(statement);
1498 return DB_ERROR_UNKNOWN;
1499 }
1500 }
1501
1502 /*
1503 * Bind the new revision if we have any.
1504 */
1505 if (revision_field) {
1506 ret = sqlite3_bind_int64(statement, bind++, revision_number + 1);
1507 if (ret != SQLITE_OK) {
1508 __db_backend_sqlite_finalize(statement);
1509 return DB_ERROR_UNKNOWN;
1510 }
1511 }
1512
1513 /*
1514 * Bind the clauses values.
1515 */
1516 if (clause_list) {
1517 if (__db_backend_sqlite_bind_clause(statement, clause_list, &bind)) {
1518 __db_backend_sqlite_finalize(statement);
1519 return DB_ERROR_UNKNOWN;
1520 }
1521 }
1522
1523 /*
1524 * Execute the SQL.
1525 */
1526 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1527 __db_backend_sqlite_finalize(statement);
1528 return DB_ERROR_UNKNOWN;
1529 }
1530 __db_backend_sqlite_finalize(statement);
1531
1532 /*
1533 * If we are using revision we have to have a positive number of changes
1534 * otherwise its a failure.
1535 */
1536 if (revision_field) {
1537 if (sqlite3_changes(backend_sqlite->db) < 1) {
1538 return DB_ERROR_UNKNOWN;
1539 }
1540 }
1541
1542 return DB_OK;
1543}
1544
1545static int db_backend_sqlite_delete(void* data, const db_object_t* object, const db_clause_list_t* clause_list) {
1546 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1547 char sql[4*1024];
1548 char* sqlp;
1549 int ret, left, bind;
1550 sqlite3_stmt* statement = NULL;
1551 const db_object_field_t* revision_field = NULL;
1552 const db_object_field_t* object_field;
1553 const db_clause_t* clause;
1554
1555 if (!__sqlite3_initialized) {
1556 return DB_ERROR_UNKNOWN;
1557 }
1558 if (!backend_sqlite) {
1559 return DB_ERROR_UNKNOWN;
1560 }
1561 if (!object) {
1562 return DB_ERROR_UNKNOWN;
1563 }
1564
1565 /*
1566 * Check if the object has a revision field and keep it for later use.
1567 */
1569 while (object_field) {
1570 if (db_object_field_type(object_field) == DB_TYPE_REVISION) {
1571 if (revision_field) {
1572 /*
1573 * We do not support multiple revision fields.
1574 */
1575 return DB_ERROR_UNKNOWN;
1576 }
1577
1578 revision_field = object_field;
1579 }
1580 object_field = db_object_field_next(object_field);
1581 }
1582 if (revision_field) {
1583 /*
1584 * If we have a revision field we should also have it in the clause,
1585 * find it or return error if not found.
1586 */
1587 clause = db_clause_list_begin(clause_list);
1588 while (clause) {
1589 if (!strcmp(db_clause_field(clause), db_object_field_name(revision_field))) {
1590 break;
1591 }
1592 clause = db_clause_next(clause);
1593 }
1594 if (!clause) {
1595 return DB_ERROR_UNKNOWN;
1596 }
1597 }
1598
1599 left = sizeof(sql);
1600 sqlp = sql;
1601 memset(sql, 0, left);
1602
1603 if ((ret = snprintf(sqlp, left, "DELETE FROM %s", db_object_table(object))) >= left) {
1604 return DB_ERROR_UNKNOWN;
1605 }
1606 sqlp += ret;
1607 left -= ret;
1608
1609 if (clause_list) {
1610 if (db_clause_list_begin(clause_list)) {
1611 if ((ret = snprintf(sqlp, left, " WHERE")) >= left) {
1612 return DB_ERROR_UNKNOWN;
1613 }
1614 sqlp += ret;
1615 left -= ret;
1616 }
1617 if (__db_backend_sqlite_build_clause(object, clause_list, &sqlp, &left)) {
1618 return DB_ERROR_UNKNOWN;
1619 }
1620 }
1621
1622 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, sizeof(sql))) {
1623 return DB_ERROR_UNKNOWN;
1624 }
1625
1626 if (clause_list) {
1627 bind = 1;
1628 if (__db_backend_sqlite_bind_clause(statement, clause_list, &bind)) {
1629 __db_backend_sqlite_finalize(statement);
1630 return DB_ERROR_UNKNOWN;
1631 }
1632 }
1633
1634 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1635 __db_backend_sqlite_finalize(statement);
1636 return DB_ERROR_UNKNOWN;
1637 }
1638 __db_backend_sqlite_finalize(statement);
1639
1640 /*
1641 * If we are using revision we have to have a positive number of changes
1642 * otherwise its a failure.
1643 */
1644 if (revision_field) {
1645 if (sqlite3_changes(backend_sqlite->db) < 1) {
1646 return DB_ERROR_UNKNOWN;
1647 }
1648 }
1649
1650 return DB_OK;
1651}
1652
1653static int db_backend_sqlite_count(void* data, const db_object_t* object, const db_join_list_t* join_list, const db_clause_list_t* clause_list, size_t* count) {
1654 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1655 const db_join_t* join;
1656 char sql[4*1024];
1657 char* sqlp;
1658 int ret, left, bind;
1659 sqlite3_stmt* statement = NULL;
1660 int sqlite_count;
1661
1662 if (!__sqlite3_initialized) {
1663 return DB_ERROR_UNKNOWN;
1664 }
1665 if (!backend_sqlite) {
1666 return DB_ERROR_UNKNOWN;
1667 }
1668 if (!object) {
1669 return DB_ERROR_UNKNOWN;
1670 }
1671 if (!count) {
1672 return DB_ERROR_UNKNOWN;
1673 }
1674
1675 left = sizeof(sql);
1676 sqlp = sql;
1677 memset(sql, 0, left);
1678
1679 if ((ret = snprintf(sqlp, left, "SELECT COUNT(*)")) >= left) {
1680 return DB_ERROR_UNKNOWN;
1681 }
1682 sqlp += ret;
1683 left -= ret;
1684
1685 if ((ret = snprintf(sqlp, left, " FROM %s", db_object_table(object))) >= left) {
1686 return DB_ERROR_UNKNOWN;
1687 }
1688 sqlp += ret;
1689 left -= ret;
1690
1691 if (join_list) {
1692 join = db_join_list_begin(join_list);
1693 while (join) {
1694 if ((ret = snprintf(sqlp, left, " INNER JOIN %s ON %s.%s = %s.%s",
1695 db_join_to_table(join),
1696 db_join_to_table(join),
1697 db_join_to_field(join),
1698 db_join_from_table(join),
1699 db_join_from_field(join))) >= left)
1700 {
1701 return DB_ERROR_UNKNOWN;
1702 }
1703 sqlp += ret;
1704 left -= ret;
1705 join = db_join_next(join);
1706 }
1707 }
1708
1709 if (clause_list) {
1710 if (db_clause_list_begin(clause_list)) {
1711 if ((ret = snprintf(sqlp, left, " WHERE")) >= left) {
1712 return DB_ERROR_UNKNOWN;
1713 }
1714 sqlp += ret;
1715 left -= ret;
1716 }
1717 if (__db_backend_sqlite_build_clause(object, clause_list, &sqlp, &left)) {
1718 return DB_ERROR_UNKNOWN;
1719 }
1720 }
1721
1722 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, sizeof(sql))) {
1723 return DB_ERROR_UNKNOWN;
1724 }
1725
1726 if (clause_list) {
1727 bind = 1;
1728 if (__db_backend_sqlite_bind_clause(statement, clause_list, &bind)) {
1729 __db_backend_sqlite_finalize(statement);
1730 return DB_ERROR_UNKNOWN;
1731 }
1732 }
1733
1734 ret = __db_backend_sqlite_step(backend_sqlite, statement);
1735 if (ret != SQLITE_DONE && ret != SQLITE_ROW) {
1736 __db_backend_sqlite_finalize(statement);
1737 return DB_ERROR_UNKNOWN;
1738 }
1739
1740 sqlite_count = sqlite3_column_int(statement, 0);
1741 ret = sqlite3_errcode(backend_sqlite->db);
1742 if ((ret != SQLITE_OK && ret != SQLITE_ROW && ret != SQLITE_DONE)) {
1743 __db_backend_sqlite_finalize(statement);
1744 return DB_ERROR_UNKNOWN;
1745 }
1746
1747 *count = sqlite_count;
1748 __db_backend_sqlite_finalize(statement);
1749 return DB_OK;
1750}
1751
1752static void db_backend_sqlite_free(void* data) {
1753 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1754
1755 if (backend_sqlite) {
1756 if (backend_sqlite->db) {
1757 (void)db_backend_sqlite_disconnect(backend_sqlite);
1758 }
1759 free(backend_sqlite);
1760 }
1761}
1762
1763static int db_backend_sqlite_transaction_begin(void* data) {
1764 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1765 static const char* sql = "BEGIN TRANSACTION";
1766 sqlite3_stmt* statement = NULL;
1767
1768 if (!__sqlite3_initialized) {
1769 return DB_ERROR_UNKNOWN;
1770 }
1771 if (!backend_sqlite) {
1772 return DB_ERROR_UNKNOWN;
1773 }
1774 if (backend_sqlite->transaction) {
1775 return DB_ERROR_UNKNOWN;
1776 }
1777
1778 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, strlen(sql))) {
1779 return DB_ERROR_UNKNOWN;
1780 }
1781
1782 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1783 __db_backend_sqlite_finalize(statement);
1784 return DB_ERROR_UNKNOWN;
1785 }
1786 __db_backend_sqlite_finalize(statement);
1787
1788 backend_sqlite->transaction = 1;
1789 return DB_OK;
1790}
1791
1792static int db_backend_sqlite_transaction_commit(void* data) {
1793 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1794 static const char* sql = "COMMIT TRANSACTION";
1795 sqlite3_stmt* statement = NULL;
1796
1797 if (!__sqlite3_initialized) {
1798 return DB_ERROR_UNKNOWN;
1799 }
1800 if (!backend_sqlite) {
1801 return DB_ERROR_UNKNOWN;
1802 }
1803 if (!backend_sqlite->transaction) {
1804 return DB_ERROR_UNKNOWN;
1805 }
1806
1807 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, strlen(sql))) {
1808 return DB_ERROR_UNKNOWN;
1809 }
1810
1811 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1812 __db_backend_sqlite_finalize(statement);
1813 return DB_ERROR_UNKNOWN;
1814 }
1815 __db_backend_sqlite_finalize(statement);
1816
1817 backend_sqlite->transaction = 0;
1818 return DB_OK;
1819}
1820
1821static int db_backend_sqlite_transaction_rollback(void* data) {
1822 db_backend_sqlite_t* backend_sqlite = (db_backend_sqlite_t*)data;
1823 static const char* sql = "ROLLBACK TRANSACTION";
1824 sqlite3_stmt* statement = NULL;
1825
1826 if (!__sqlite3_initialized) {
1827 return DB_ERROR_UNKNOWN;
1828 }
1829 if (!backend_sqlite) {
1830 return DB_ERROR_UNKNOWN;
1831 }
1832 if (!backend_sqlite->transaction) {
1833 return DB_ERROR_UNKNOWN;
1834 }
1835
1836 if (__db_backend_sqlite_prepare(backend_sqlite, &statement, sql, strlen(sql))) {
1837 return DB_ERROR_UNKNOWN;
1838 }
1839
1840 if (__db_backend_sqlite_step(backend_sqlite, statement) != SQLITE_DONE) {
1841 __db_backend_sqlite_finalize(statement);
1842 return DB_ERROR_UNKNOWN;
1843 }
1844 __db_backend_sqlite_finalize(statement);
1845
1846 backend_sqlite->transaction = 0;
1847 return DB_OK;
1848}
1849
1851 db_backend_handle_t* backend_handle = NULL;
1852 db_backend_sqlite_t* backend_sqlite =
1853 (db_backend_sqlite_t*)calloc(1, sizeof(db_backend_sqlite_t));
1854
1855 if (backend_sqlite && (backend_handle = db_backend_handle_new())) {
1856 if (db_backend_handle_set_data(backend_handle, (void*)backend_sqlite)
1857 || db_backend_handle_set_initialize(backend_handle, db_backend_sqlite_initialize)
1858 || db_backend_handle_set_shutdown(backend_handle, db_backend_sqlite_shutdown)
1859 || db_backend_handle_set_connect(backend_handle, db_backend_sqlite_connect)
1860 || db_backend_handle_set_disconnect(backend_handle, db_backend_sqlite_disconnect)
1861 || db_backend_handle_set_create(backend_handle, db_backend_sqlite_create)
1862 || db_backend_handle_set_read(backend_handle, db_backend_sqlite_read)
1863 || db_backend_handle_set_update(backend_handle, db_backend_sqlite_update)
1864 || db_backend_handle_set_delete(backend_handle, db_backend_sqlite_delete)
1865 || db_backend_handle_set_count(backend_handle, db_backend_sqlite_count)
1866 || db_backend_handle_set_free(backend_handle, db_backend_sqlite_free)
1867 || db_backend_handle_set_transaction_begin(backend_handle, db_backend_sqlite_transaction_begin)
1868 || db_backend_handle_set_transaction_commit(backend_handle, db_backend_sqlite_transaction_commit)
1869 || db_backend_handle_set_transaction_rollback(backend_handle, db_backend_sqlite_transaction_rollback))
1870 {
1871 db_backend_handle_free(backend_handle);
1872 free(backend_sqlite);
1873 return NULL;
1874 }
1875 return backend_handle;
1876 }
1877 free(backend_sqlite);
1878 return NULL;
1879}
int db_backend_handle_set_count(db_backend_handle_t *backend_handle, db_backend_handle_count_t count_function)
Definition: db_backend.c:250
int db_backend_handle_set_update(db_backend_handle_t *backend_handle, db_backend_handle_update_t update_function)
Definition: db_backend.c:232
db_backend_handle_t * db_backend_handle_new(void)
Definition: db_backend.c:49
int db_backend_handle_set_shutdown(db_backend_handle_t *backend_handle, db_backend_handle_shutdown_t shutdown_function)
Definition: db_backend.c:187
int db_backend_handle_set_initialize(db_backend_handle_t *backend_handle, db_backend_handle_initialize_t initialize_function)
Definition: db_backend.c:178
void db_backend_handle_free(db_backend_handle_t *backend_handle)
Definition: db_backend.c:56
int db_backend_handle_set_disconnect(db_backend_handle_t *backend_handle, db_backend_handle_disconnect_t disconnect_function)
Definition: db_backend.c:205
int db_backend_handle_set_delete(db_backend_handle_t *backend_handle, db_backend_handle_delete_t delete_function)
Definition: db_backend.c:241
int db_backend_handle_set_transaction_rollback(db_backend_handle_t *backend_handle, db_backend_handle_transaction_rollback_t transaction_rollback_function)
Definition: db_backend.c:286
int db_backend_handle_set_transaction_commit(db_backend_handle_t *backend_handle, db_backend_handle_transaction_commit_t transaction_commit_function)
Definition: db_backend.c:277
int db_backend_handle_set_transaction_begin(db_backend_handle_t *backend_handle, db_backend_handle_transaction_begin_t transaction_begin_function)
Definition: db_backend.c:268
int db_backend_handle_set_read(db_backend_handle_t *backend_handle, db_backend_handle_read_t read_function)
Definition: db_backend.c:223
int db_backend_handle_set_create(db_backend_handle_t *backend_handle, db_backend_handle_create_t create_function)
Definition: db_backend.c:214
int db_backend_handle_set_data(db_backend_handle_t *backend_handle, void *data)
Definition: db_backend.c:295
int db_backend_handle_set_free(db_backend_handle_t *backend_handle, db_backend_handle_free_t free_function)
Definition: db_backend.c:259
int db_backend_handle_set_connect(db_backend_handle_t *backend_handle, db_backend_handle_connect_t connect_function)
Definition: db_backend.c:196
struct db_backend_sqlite db_backend_sqlite_t
db_backend_handle_t * db_backend_sqlite_new_handle(void)
struct db_backend_sqlite_statement db_backend_sqlite_statement_t
#define DB_BACKEND_SQLITE_DEFAULT_USLEEP
#define DB_BACKEND_SQLITE_DEFAULT_TIMEOUT
const db_clause_list_t * db_clause_list(const db_clause_t *clause)
Definition: db_clause.c:101
db_clause_operator_t db_clause_operator(const db_clause_t *clause)
Definition: db_clause.c:93
const db_value_t * db_clause_value(const db_clause_t *clause)
Definition: db_clause.c:85
db_clause_type_t db_clause_type(const db_clause_t *clause)
Definition: db_clause.c:77
const db_clause_t * db_clause_next(const db_clause_t *clause)
Definition: db_clause.c:179
const char * db_clause_field(const db_clause_t *clause)
Definition: db_clause.c:69
const db_clause_t * db_clause_list_begin(const db_clause_list_t *clause_list)
Definition: db_clause.c:255
@ DB_CLAUSE_OPERATOR_AND
Definition: db_clause.h:97
@ DB_CLAUSE_OPERATOR_OR
Definition: db_clause.h:101
@ DB_CLAUSE_NESTED
Definition: db_clause.h:76
@ DB_CLAUSE_GREATER_THEN
Definition: db_clause.h:64
@ DB_CLAUSE_NOT_EQUAL
Definition: db_clause.h:48
@ DB_CLAUSE_IS_NOT_NULL
Definition: db_clause.h:72
@ DB_CLAUSE_GREATER_OR_EQUAL
Definition: db_clause.h:60
@ DB_CLAUSE_IS_NULL
Definition: db_clause.h:68
@ DB_CLAUSE_EQUAL
Definition: db_clause.h:44
@ DB_CLAUSE_LESS_OR_EQUAL
Definition: db_clause.h:56
@ DB_CLAUSE_LESS_THEN
Definition: db_clause.h:52
const char * db_configuration_value(const db_configuration_t *configuration)
const db_configuration_t * db_configuration_list_find(const db_configuration_list_t *configuration_list, const char *name)
#define DB_ERROR_UNKNOWN
Definition: db_error.h:40
#define DB_OK
Definition: db_error.h:36
const char * db_join_from_table(const db_join_t *join)
Definition: db_join.c:41
const char * db_join_from_field(const db_join_t *join)
Definition: db_join.c:49
const db_join_t * db_join_list_begin(const db_join_list_t *join_list)
Definition: db_join.c:85
const char * db_join_to_table(const db_join_t *join)
Definition: db_join.c:57
const db_join_t * db_join_next(const db_join_t *join)
Definition: db_join.c:73
const char * db_join_to_field(const db_join_t *join)
Definition: db_join.c:65
const db_object_field_t * db_object_field_list_begin(const db_object_field_list_t *object_field_list)
Definition: db_object.c:284
db_type_t db_object_field_type(const db_object_field_t *object_field)
Definition: db_object.c:102
const db_object_field_list_t * db_object_object_field_list(const db_object_t *object)
Definition: db_object.c:334
const char * db_object_table(const db_object_t *object)
Definition: db_object.c:327
const char * db_object_field_name(const db_object_field_t *object_field)
Definition: db_object.c:94
const db_object_field_t * db_object_field_next(const db_object_field_t *object_field)
Definition: db_object.c:162
int db_result_set_value_set(db_result_t *result, db_value_set_t *value_set)
Definition: db_result.c:105
db_result_list_t * db_result_list_new(void)
Definition: db_result.c:134
int db_result_list_set_next(db_result_list_t *result_list, db_result_list_next_t next_function, void *next_data, size_t size)
Definition: db_result.c:234
db_result_t * db_result_new(void)
Definition: db_result.c:38
void db_result_free(db_result_t *result)
Definition: db_result.c:63
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
@ DB_TYPE_INT64
Definition: db_type.h:74
@ DB_TYPE_UINT64
Definition: db_type.h:78
@ DB_TYPE_PRIMARY_KEY
Definition: db_type.h:62
@ DB_TYPE_REVISION
Definition: db_type.h:97
@ DB_TYPE_TEXT
Definition: db_type.h:82
@ DB_TYPE_INT32
Definition: db_type.h:66
@ DB_TYPE_ENUM
Definition: db_type.h:86
@ DB_TYPE_UINT32
Definition: db_type.h:70
@ DB_TYPE_ANY
Definition: db_type.h:90
uint64_t db_type_uint64_t
Definition: db_type.h:50
uint32_t db_type_uint32_t
Definition: db_type.h:42
int64_t db_type_int64_t
Definition: db_type.h:46
int32_t db_type_int32_t
Definition: db_type.h:38
int db_value_to_int32(const db_value_t *value, db_type_int32_t *to_int32)
Definition: db_value.c:357
db_type_t db_value_type(const db_value_t *value)
Definition: db_value.c:269
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
int db_value_set_primary_key(db_value_t *value)
Definition: db_value.c:595
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
int db_value_from_uint32(db_value_t *value, db_type_uint32_t from_uint32)
Definition: db_value.c:492
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
int db_value_to_int64(const db_value_t *value, db_type_int64_t *to_int64)
Definition: db_value.c:387
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
int db_value_from_int32(db_value_t *value, db_type_int32_t from_int32)
Definition: db_value.c:479
int db_value_from_int64(db_value_t *value, db_type_int64_t from_int64)
Definition: db_value.c:505
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
int db_value_enum_value(const db_value_t *value, int *enum_value)
Definition: db_value.c:332
int db_value_to_uint64(const db_value_t *value, db_type_uint64_t *to_uint64)
Definition: db_value.c:402
int db_value_from_uint64(db_value_t *value, db_type_uint64_t from_uint64)
Definition: db_value.c:518
const char * db_value_text(const db_value_t *value)
Definition: db_value.c:321
db_backend_sqlite_t * backend_sqlite
const db_object_t * object