jim-sqlite.c

   1
   2 /* Jim - Sqlite bindings
   3  * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * A copy of the license is also included in the source distribution
  12  * of Jim, as a TXT file name called LICENSE.
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <sqlite.h>
  24
  25 #include "jim.h"
  26
  27 typedef struct JimSqliteHandle
  28 {
  29     sqlite *db;
  30 } JimSqliteHandle;
  31
  32 static void JimSqliteDelProc(Jim_Interp *interp, void *privData)
  33 {
  34     JimSqliteHandle *sh = privData;
  35
  36     JIM_NOTUSED(interp);
  37
  38     sqlite_close(sh->db);
  39     Jim_Free(sh);
  40 }
  41
  42 static char *JimSqliteQuoteString(const char *str, int len, int *newLenPtr)
  43 {
  44     int i, newLen, c = 0;
  45     const char *s;
  46     char *d, *buf;
  47
  48     for (i = 0; i < len; i++)
  49         if (str[i] == '\'')
  50             c++;
  51     newLen = len + c;
  52     s = str;
  53     d = buf = Jim_Alloc(newLen);
  54     while (len--) {
  55         if (*s == '\'')
  56             *d++ = '\'';
  57         *d++ = *s++;
  58     }
  59     *newLenPtr = newLen;
  60     return buf;
  61 }
  62
  63 static Jim_Obj *JimSqliteFormatQuery(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
  64     int objc, Jim_Obj *const *objv)
  65 {
  66     const char *fmt;
  67     int fmtLen;
  68     Jim_Obj *resObjPtr;
  69
  70     fmt = Jim_GetString(fmtObjPtr, &fmtLen);
  71     resObjPtr = Jim_NewStringObj(interp, "", 0);
  72     while (fmtLen) {
  73         const char *p = fmt;
  74         char spec[2];
  75
  76         while (*fmt != '%' && fmtLen) {
  77             fmt++;
  78             fmtLen--;
  79         }
  80         Jim_AppendString(interp, resObjPtr, p, fmt - p);
  81         if (fmtLen == 0)
  82             break;
  83         fmt++;
  84         fmtLen--;               /* skip '%' */
  85         if (*fmt != '%') {
  86             if (objc == 0) {
  87                 Jim_FreeNewObj(interp, resObjPtr);
  88                 Jim_SetResultString(interp, "not enough arguments for all format specifiers", -1);
  89                 return NULL;
  90             }
  91             else {
  92                 objc--;
  93             }
  94         }
  95         switch (*fmt) {
  96             case 's':
  97                 {
  98                     const char *str;
  99                     char *quoted;
 100                     int len, newLen;
 101
 102                     str = Jim_GetString(objv[0], &len);
 103                     quoted = JimSqliteQuoteString(str, len, &newLen);
 104                     Jim_AppendString(interp, resObjPtr, quoted, newLen);
 105                     Jim_Free(quoted);
 106                 }
 107                 objv++;
 108                 break;
 109             case '%':
 110                 Jim_AppendString(interp, resObjPtr, "%", 1);
 111                 break;
 112             default:
 113                 spec[1] = *fmt;
 114                 spec[2] = '\0';
 115                 Jim_FreeNewObj(interp, resObjPtr);
 116                 Jim_SetResultFormatted(interp,
 117                     "bad field specifier \"%s\", only %%s and %%%% are valid", spec);
 118                 return NULL;
 119         }
 120         fmt++;
 121         fmtLen--;
 122     }
 123     return resObjPtr;
 124 }
 125
 126 /* Calls to [sqlite.open] create commands that are implemented by this
 127  * C command. */
 128 static int JimSqliteHandlerCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 129 {
 130     JimSqliteHandle *sh = Jim_CmdPrivData(interp);
 131     int option;
 132     const char *options[] = {
 133         "close", "query", "lastid", "changes", NULL
 134     };
 135     enum
 136     { OPT_CLOSE, OPT_QUERY, OPT_LASTID, OPT_CHANGES };
 137
 138     if (argc < 2) {
 139         Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
 140         return JIM_ERR;
 141     }
 142     if (Jim_GetEnum(interp, argv[1], options, &option, "Sqlite method", JIM_ERRMSG) != JIM_OK)
 143         return JIM_ERR;
 144     /* CLOSE */
 145     if (option == OPT_CLOSE) {
 146         if (argc != 2) {
 147             Jim_WrongNumArgs(interp, 2, argv, "");
 148             return JIM_ERR;
 149         }
 150         Jim_DeleteCommand(interp, Jim_GetString(argv[0], NULL));
 151         return JIM_OK;
 152     }
 153     else if (option == OPT_QUERY) {
 154         /* QUERY */
 155         Jim_Obj *objPtr, *rowsListPtr;
 156         sqlite_vm *vm;
 157         char *errMsg;
 158         const char *query, *tail, **values, **names;
 159         int columns, rows;
 160         char *nullstr;
 161
 162         if (argc >= 4 && Jim_CompareStringImmediate(interp, argv[2], "-null")) {
 163             nullstr = Jim_StrDup(Jim_GetString(argv[3], NULL));
 164             argv += 2;
 165             argc -= 2;
 166         }
 167         else {
 168             nullstr = Jim_StrDup("");
 169         }
 170         if (argc < 3) {
 171             Jim_WrongNumArgs(interp, 2, argv, "query ?args?");
 172             Jim_Free(nullstr);
 173             return JIM_ERR;
 174         }
 175         objPtr = JimSqliteFormatQuery(interp, argv[2], argc - 3, argv + 3);
 176         if (objPtr == NULL) {
 177             Jim_Free(nullstr);
 178             return JIM_ERR;
 179         }
 180         query = Jim_GetString(objPtr, NULL);
 181         Jim_IncrRefCount(objPtr);
 182         /* Compile the query into VM code */
 183         if (sqlite_compile(sh->db, query, &tail, &vm, &errMsg) != SQLITE_OK) {
 184             Jim_DecrRefCount(interp, objPtr);
 185             Jim_SetResultString(interp, errMsg, -1);
 186             sqlite_freemem(errMsg);
 187             Jim_Free(nullstr);
 188             return JIM_ERR;
 189         }
 190         Jim_DecrRefCount(interp, objPtr);       /* query no longer needed. */
 191         /* Build a list of rows (that are lists in turn) */
 192         rowsListPtr = Jim_NewListObj(interp, NULL, 0);
 193         Jim_IncrRefCount(rowsListPtr);
 194         rows = 0;
 195         while (sqlite_step(vm, &columns, &values, &names) == SQLITE_ROW) {
 196             int i;
 197
 198             objPtr = Jim_NewListObj(interp, NULL, 0);
 199             for (i = 0; i < columns; i++) {
 200                 Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, names[i], -1));
 201                 Jim_ListAppendElement(interp, objPtr,
 202                     Jim_NewStringObj(interp, values[i] != NULL ? values[i] : nullstr, -1));
 203             }
 204             Jim_ListAppendElement(interp, rowsListPtr, objPtr);
 205             rows++;
 206         }
 207         /* Finalize */
 208         Jim_Free(nullstr);
 209         if (sqlite_finalize(vm, &errMsg) != SQLITE_OK) {
 210             Jim_DecrRefCount(interp, rowsListPtr);
 211             Jim_SetResultString(interp, errMsg, -1);
 212             sqlite_freemem(errMsg);
 213             return JIM_ERR;
 214         }
 215         Jim_SetResult(interp, rowsListPtr);
 216         Jim_DecrRefCount(interp, rowsListPtr);
 217     }
 218     else if (option == OPT_LASTID) {
 219         if (argc != 2) {
 220             Jim_WrongNumArgs(interp, 2, argv, "");
 221             return JIM_ERR;
 222         }
 223         Jim_SetResult(interp, Jim_NewIntObj(interp, sqlite_last_insert_rowid(sh->db)));
 224         return JIM_OK;
 225     }
 226     else if (option == OPT_CHANGES) {
 227         if (argc != 2) {
 228             Jim_WrongNumArgs(interp, 2, argv, "");
 229             return JIM_ERR;
 230         }
 231         Jim_SetResult(interp, Jim_NewIntObj(interp, sqlite_changes(sh->db)));
 232         return JIM_OK;
 233     }
 234     return JIM_OK;
 235 }
 236
 237 static int JimSqliteOpenCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 238 {
 239     sqlite *db;
 240     JimSqliteHandle *sh;
 241     char buf[128], *errMsg;
 242
 243     if (argc != 2) {
 244         Jim_WrongNumArgs(interp, 1, argv, "dbname");
 245         return JIM_ERR;
 246     }
 247     db = sqlite_open(Jim_GetString(argv[1], NULL), 0, &errMsg);
 248     if (db == NULL) {
 249         Jim_SetResultString(interp, errMsg, -1);
 250         sqlite_freemem(errMsg);
 251         return JIM_ERR;
 252     }
 253     /* Create the file command */
 254     sh = Jim_Alloc(sizeof(*sh));
 255     sh->db = db;
 256     snprintf(buf, sizeof(buf), "sqlite.handle%ld", Jim_GetId(interp));
 257     Jim_CreateCommand(interp, buf, JimSqliteHandlerCommand, sh, JimSqliteDelProc);
 258     Jim_SetResultString(interp, buf, -1);
 259     return JIM_OK;
 260 }
 261
 262 int Jim_sqliteInit(Jim_Interp *interp)
 263 {
 264     Jim_CreateCommand(interp, "sqlite.open", JimSqliteOpenCommand, NULL, NULL);
 265     return JIM_OK;
 266 }