OpenDNSSEC-enforcer  2.1.5
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 
44 static int db_backend_sqlite_transaction_rollback(void*);
45 
49 static int __sqlite3_initialized = 0;
50 
60 static pthread_mutex_t __sqlite_mutex = PTHREAD_MUTEX_INITIALIZER;
61 static pthread_cond_t __sqlite_cond = PTHREAD_COND_INITIALIZER;
62 
66 typedef struct db_backend_sqlite {
67  sqlite3* db;
69  int timeout;
70  int time;
71  long usleep;
73 
74 
75 
81  sqlite3_stmt* statement;
82  int fields;
85 
86 
87 
91 static 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 
142 static 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 
184 static 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 
244 static 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 
253 static 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 
270 static 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 
287 static 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 
311  backend_sqlite->timeout = DB_BACKEND_SQLITE_DEFAULT_TIMEOUT;
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) {
315  backend_sqlite->timeout = DB_BACKEND_SQLITE_DEFAULT_TIMEOUT;
316  }
317  }
318 
319  backend_sqlite->usleep = DB_BACKEND_SQLITE_DEFAULT_USLEEP;
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) {
323  backend_sqlite->usleep = DB_BACKEND_SQLITE_DEFAULT_TIMEOUT;
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 
351 static 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 
385 static 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 
442  case DB_CLAUSE_NOT_EQUAL:
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 
451  case DB_CLAUSE_LESS_THEN:
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 
487  case DB_CLAUSE_IS_NULL:
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 
538 static 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:
565  case DB_CLAUSE_NOT_EQUAL:
566  case DB_CLAUSE_LESS_THEN:
570  switch (db_value_type(db_clause_value(clause))) {
571  case DB_TYPE_PRIMARY_KEY:
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 
638  case DB_CLAUSE_IS_NULL:
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 
656 static 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)) {
703  case DB_TYPE_PRIMARY_KEY:
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 
824 static 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 
1112 static 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;
1120  db_backend_sqlite_statement_t* statement;
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 
1235 static 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 
1545 static 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 
1653 static 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 
1752 static 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 
1763 static 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 
1792 static 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 
1821 static 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 }
db_backend_handle
Definition: db_backend.h:169
DB_CLAUSE_OPERATOR_OR
@ DB_CLAUSE_OPERATOR_OR
Definition: db_clause.h:101
db_join
Definition: db_join.h:43
db_result
Definition: db_result.h:56
DB_CLAUSE_NESTED
@ DB_CLAUSE_NESTED
Definition: db_clause.h:76
db_backend_handle_set_initialize
int db_backend_handle_set_initialize(db_backend_handle_t *backend_handle, db_backend_handle_initialize_t initialize_function)
Definition: db_backend.c:178
DB_TYPE_PRIMARY_KEY
@ DB_TYPE_PRIMARY_KEY
Definition: db_type.h:62
db_backend_sqlite_t
struct db_backend_sqlite db_backend_sqlite_t
db_backend_sqlite::transaction
int transaction
Definition: db_backend_sqlite.c:68
db_value
Definition: db_value.h:48
db_backend_sqlite_statement::backend_sqlite
db_backend_sqlite_t * backend_sqlite
Definition: db_backend_sqlite.c:80
DB_CLAUSE_IS_NOT_NULL
@ DB_CLAUSE_IS_NOT_NULL
Definition: db_clause.h:72
db_backend_handle_set_transaction_begin
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
db_clause_value
const db_value_t * db_clause_value(const db_clause_t *clause)
Definition: db_clause.c:85
db_backend_sqlite::usleep
long usleep
Definition: db_backend_sqlite.c:71
db_backend_handle_set_transaction_commit
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
db_result_set_value_set
int db_result_set_value_set(db_result_t *result, db_value_set_t *value_set)
Definition: db_result.c:105
DB_TYPE_ANY
@ DB_TYPE_ANY
Definition: db_type.h:90
db_configuration_list_find
const db_configuration_t * db_configuration_list_find(const db_configuration_list_t *configuration_list, const char *name)
Definition: db_configuration.c:179
DB_CLAUSE_GREATER_THEN
@ DB_CLAUSE_GREATER_THEN
Definition: db_clause.h:64
db_result_free
void db_result_free(db_result_t *result)
Definition: db_result.c:63
db_clause_operator
db_clause_operator_t db_clause_operator(const db_clause_t *clause)
Definition: db_clause.c:93
db_clause_list_begin
const db_clause_t * db_clause_list_begin(const db_clause_list_t *clause_list)
Definition: db_clause.c:255
DB_CLAUSE_EQUAL
@ DB_CLAUSE_EQUAL
Definition: db_clause.h:44
db_clause_field
const char * db_clause_field(const db_clause_t *clause)
Definition: db_clause.c:69
db_configuration
Definition: db_configuration.h:41
db_join_list
Definition: db_join.h:94
db_join_from_field
const char * db_join_from_field(const db_join_t *join)
Definition: db_join.c:49
db_backend_handle_set_count
int db_backend_handle_set_count(db_backend_handle_t *backend_handle, db_backend_handle_count_t count_function)
Definition: db_backend.c:250
DB_CLAUSE_GREATER_OR_EQUAL
@ DB_CLAUSE_GREATER_OR_EQUAL
Definition: db_clause.h:60
db_object
Definition: db_object.h:201
db_type_int32_t
int32_t db_type_int32_t
Definition: db_type.h:38
db_clause_next
const db_clause_t * db_clause_next(const db_clause_t *clause)
Definition: db_clause.c:179
db_value_text
const char * db_value_text(const db_value_t *value)
Definition: db_value.c:321
db_join_next
const db_join_t * db_join_next(const db_join_t *join)
Definition: db_join.c:73
db_value_from_int32
int db_value_from_int32(db_value_t *value, db_type_int32_t from_int32)
Definition: db_value.c:479
db_backend_sqlite_statement::object
const db_object_t * object
Definition: db_backend_sqlite.c:83
db_value_set_get
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
db_error.h
db_object_table
const char * db_object_table(const db_object_t *object)
Definition: db_object.c:327
db_object_field
Definition: db_object.h:52
db_join_from_table
const char * db_join_from_table(const db_join_t *join)
Definition: db_join.c:41
db_value_type
db_type_t db_value_type(const db_value_t *value)
Definition: db_value.c:269
db_backend_handle_free
void db_backend_handle_free(db_backend_handle_t *backend_handle)
Definition: db_backend.c:56
db_join_to_field
const char * db_join_to_field(const db_join_t *join)
Definition: db_join.c:65
db_backend_handle_new
db_backend_handle_t * db_backend_handle_new(void)
Definition: db_backend.c:49
db_object_field_name
const char * db_object_field_name(const db_object_field_t *object_field)
Definition: db_object.c:94
db_clause_list
Definition: db_clause.h:226
db_result_list_set_next
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_backend_sqlite_statement::fields
int fields
Definition: db_backend_sqlite.c:82
DB_CLAUSE_LESS_THEN
@ DB_CLAUSE_LESS_THEN
Definition: db_clause.h:52
DB_CLAUSE_IS_NULL
@ DB_CLAUSE_IS_NULL
Definition: db_clause.h:68
DB_TYPE_INT32
@ DB_TYPE_INT32
Definition: db_type.h:66
db_backend_handle_set_connect
int db_backend_handle_set_connect(db_backend_handle_t *backend_handle, db_backend_handle_connect_t connect_function)
Definition: db_backend.c:196
db_value_set
Definition: db_value.h:281
db_value_set_at
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
db_result_list_new
db_result_list_t * db_result_list_new(void)
Definition: db_result.c:134
db_backend_handle_set_shutdown
int db_backend_handle_set_shutdown(db_backend_handle_t *backend_handle, db_backend_handle_shutdown_t shutdown_function)
Definition: db_backend.c:187
db_backend_sqlite_statement_t
struct db_backend_sqlite_statement db_backend_sqlite_statement_t
db_object_field_next
const db_object_field_t * db_object_field_next(const db_object_field_t *object_field)
Definition: db_object.c:162
db_result_list_free
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
db_value_to_int32
int db_value_to_int32(const db_value_t *value, db_type_int32_t *to_int32)
Definition: db_value.c:357
db_type_int64_t
int64_t db_type_int64_t
Definition: db_type.h:46
db_type_uint64_t
uint64_t db_type_uint64_t
Definition: db_type.h:50
DB_TYPE_UINT32
@ DB_TYPE_UINT32
Definition: db_type.h:70
db_backend_handle_set_data
int db_backend_handle_set_data(db_backend_handle_t *backend_handle, void *data)
Definition: db_backend.c:295
db_value_to_int64
int db_value_to_int64(const db_value_t *value, db_type_int64_t *to_int64)
Definition: db_value.c:387
db_value_from_int64
int db_value_from_int64(db_value_t *value, db_type_int64_t from_int64)
Definition: db_value.c:505
DB_BACKEND_SQLITE_DEFAULT_USLEEP
#define DB_BACKEND_SQLITE_DEFAULT_USLEEP
Definition: db_backend_sqlite.h:36
db_value_from_uint32
int db_value_from_uint32(db_value_t *value, db_type_uint32_t from_uint32)
Definition: db_value.c:492
db_backend_sqlite_statement::statement
sqlite3_stmt * statement
Definition: db_backend_sqlite.c:81
db_result_list
Definition: db_result.h:114
DB_TYPE_REVISION
@ DB_TYPE_REVISION
Definition: db_type.h:97
db_backend_handle_set_delete
int db_backend_handle_set_delete(db_backend_handle_t *backend_handle, db_backend_handle_delete_t delete_function)
Definition: db_backend.c:241
db_backend_sqlite::db
sqlite3 * db
Definition: db_backend_sqlite.c:67
db_value_to_uint32
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
db_backend_sqlite_statement
Definition: db_backend_sqlite.c:79
db_backend_handle_set_free
int db_backend_handle_set_free(db_backend_handle_t *backend_handle, db_backend_handle_free_t free_function)
Definition: db_backend.c:259
db_backend_handle_set_transaction_rollback
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
db_value_set_free
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
db_clause
Definition: db_clause.h:118
db_backend_handle_set_read
int db_backend_handle_set_read(db_backend_handle_t *backend_handle, db_backend_handle_read_t read_function)
Definition: db_backend.c:223
db_value_to_uint64
int db_value_to_uint64(const db_value_t *value, db_type_uint64_t *to_uint64)
Definition: db_value.c:402
db_object_field_list
Definition: db_object.h:142
db_clause_list
const db_clause_list_t * db_clause_list(const db_clause_t *clause)
Definition: db_clause.c:101
db_clause_type
db_clause_type_t db_clause_type(const db_clause_t *clause)
Definition: db_clause.c:77
db_backend_handle_set_update
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_CLAUSE_LESS_OR_EQUAL
@ DB_CLAUSE_LESS_OR_EQUAL
Definition: db_clause.h:56
DB_BACKEND_SQLITE_DEFAULT_TIMEOUT
#define DB_BACKEND_SQLITE_DEFAULT_TIMEOUT
Definition: db_backend_sqlite.h:35
db_object_field_type
db_type_t db_object_field_type(const db_object_field_t *object_field)
Definition: db_object.c:102
DB_TYPE_UINT64
@ DB_TYPE_UINT64
Definition: db_type.h:78
db_join_to_table
const char * db_join_to_table(const db_join_t *join)
Definition: db_join.c:57
DB_TYPE_INT64
@ DB_TYPE_INT64
Definition: db_type.h:74
db_object_object_field_list
const db_object_field_list_t * db_object_object_field_list(const db_object_t *object)
Definition: db_object.c:334
DB_CLAUSE_OPERATOR_AND
@ DB_CLAUSE_OPERATOR_AND
Definition: db_clause.h:97
db_result_new
db_result_t * db_result_new(void)
Definition: db_result.c:38
db_type_uint32_t
uint32_t db_type_uint32_t
Definition: db_type.h:42
db_join_list_begin
const db_join_t * db_join_list_begin(const db_join_list_t *join_list)
Definition: db_join.c:85
db_configuration_list
Definition: db_configuration.h:93
db_value_from_text
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
db_value_enum_value
int db_value_enum_value(const db_value_t *value, int *enum_value)
Definition: db_value.c:332
DB_TYPE_ENUM
@ DB_TYPE_ENUM
Definition: db_type.h:86
db_backend_sqlite::timeout
int timeout
Definition: db_backend_sqlite.c:69
db_value_from_uint64
int db_value_from_uint64(db_value_t *value, db_type_uint64_t from_uint64)
Definition: db_value.c:518
db_backend_handle_set_disconnect
int db_backend_handle_set_disconnect(db_backend_handle_t *backend_handle, db_backend_handle_disconnect_t disconnect_function)
Definition: db_backend.c:205
db_value_set_size
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
db_configuration_value
const char * db_configuration_value(const db_configuration_t *configuration)
Definition: db_configuration.c:60
db_backend_sqlite_new_handle
db_backend_handle_t * db_backend_sqlite_new_handle(void)
Definition: db_backend_sqlite.c:1850
DB_ERROR_UNKNOWN
#define DB_ERROR_UNKNOWN
Definition: db_error.h:40
DB_OK
#define DB_OK
Definition: db_error.h:36
db_value_set_primary_key
int db_value_set_primary_key(db_value_t *value)
Definition: db_value.c:595
db_backend_sqlite.h
DB_TYPE_TEXT
@ DB_TYPE_TEXT
Definition: db_type.h:82
db_value_set_new
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
db_object_field_list_begin
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_backend_handle_set_create
int db_backend_handle_set_create(db_backend_handle_t *backend_handle, db_backend_handle_create_t create_function)
Definition: db_backend.c:214
db_backend_sqlite
Definition: db_backend_sqlite.c:66
db_backend_sqlite::time
int time
Definition: db_backend_sqlite.c:70
DB_CLAUSE_NOT_EQUAL
@ DB_CLAUSE_NOT_EQUAL
Definition: db_clause.h:48