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