[nongnu] elpa/sqlite3 781f915cd4 31/62: added sqlite3-fetch_alist

[ELPA Syncer]

branch: elpa/sqlite3
commit 781f915cd4ebbb5941b290aed7109c767e93f5d2
Author: Y. N. Lo <gordonynlo@yahoo.com>
Commit: Y. N. Lo <gordonynlo@yahoo.com>

    added sqlite3-fetch_alist
---
 Makefile        |  7 ++++++-
 consts.c        | 52 +++++++++++++++++++++++++++++++++++++++++++-------
 sqlite3-api.c   | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 tools/md-toc.py | 43 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 151 insertions(+), 10 deletions(-)

diff --git a/Makefile b/Makefile
index b763efcfb7..ceb4d18f6a 100644
--- a/Makefile
+++ b/Makefile
@@ -20,7 +20,7 @@ PKG=sqlite3-api
 
 # dynamic module package
 MODULE=$(PKG)
-MODULE_VERSION=0.11
+MODULE_VERSION=0.12
 MODULE_BASENAME=$(MODULE)-$(MODULE_VERSION)
 MODULE_PKG_EL=$(MODULE_BASENAME)/$(MODULE)-pkg.el
 MODULE_TAR=$(MODULE_BASENAME).tar
@@ -41,6 +41,11 @@ module: $(MODULE).so
 install: module
        emacsclient -e '(package-install-file "$(MODULE_TAR)")'
 
+doc: README.md
+
+README.md: README-in.md
+       tools/md-toc.py $< > $@
+
 %.so: %.o
        $(CC) -shared -o $@ $< $(LIB)
 
diff --git a/consts.c b/consts.c
index 271f50424e..b0d30bc1b7 100644
--- a/consts.c
+++ b/consts.c
@@ -1,3 +1,6 @@
+defconst(env, "sqlite-version", env->make_string(env, SQLITE_VERSION, 
strlen(SQLITE_VERSION)));
+defconst(env, "sqlite-version-number", env->make_integer(env, 
SQLITE_VERSION_NUMBER));
+defconst(env, "sqlite-source-id", env->make_string(env, SQLITE_SOURCE_ID, 
strlen(SQLITE_SOURCE_ID)));
 defconst(env, "sqlite-ok", env->make_integer(env, SQLITE_OK));
 defconst(env, "sqlite-error", env->make_integer(env, SQLITE_ERROR));
 defconst(env, "sqlite-internal", env->make_integer(env, SQLITE_INTERNAL));
@@ -29,6 +32,9 @@ defconst(env, "sqlite-notice", env->make_integer(env, 
SQLITE_NOTICE));
 defconst(env, "sqlite-warning", env->make_integer(env, SQLITE_WARNING));
 defconst(env, "sqlite-row", env->make_integer(env, SQLITE_ROW));
 defconst(env, "sqlite-done", env->make_integer(env, SQLITE_DONE));
+defconst(env, "sqlite-error-missing-collseq", env->make_integer(env, 
SQLITE_ERROR_MISSING_COLLSEQ));
+defconst(env, "sqlite-error-retry", env->make_integer(env, 
SQLITE_ERROR_RETRY));
+defconst(env, "sqlite-error-snapshot", env->make_integer(env, 
SQLITE_ERROR_SNAPSHOT));
 defconst(env, "sqlite-ioerr-read", env->make_integer(env, SQLITE_IOERR_READ));
 defconst(env, "sqlite-ioerr-short-read", env->make_integer(env, 
SQLITE_IOERR_SHORT_READ));
 defconst(env, "sqlite-ioerr-write", env->make_integer(env, 
SQLITE_IOERR_WRITE));
@@ -57,18 +63,26 @@ defconst(env, "sqlite-ioerr-gettemppath", 
env->make_integer(env, SQLITE_IOERR_GE
 defconst(env, "sqlite-ioerr-convpath", env->make_integer(env, 
SQLITE_IOERR_CONVPATH));
 defconst(env, "sqlite-ioerr-vnode", env->make_integer(env, 
SQLITE_IOERR_VNODE));
 defconst(env, "sqlite-ioerr-auth", env->make_integer(env, SQLITE_IOERR_AUTH));
+defconst(env, "sqlite-ioerr-begin-atomic", env->make_integer(env, 
SQLITE_IOERR_BEGIN_ATOMIC));
+defconst(env, "sqlite-ioerr-commit-atomic", env->make_integer(env, 
SQLITE_IOERR_COMMIT_ATOMIC));
+defconst(env, "sqlite-ioerr-rollback-atomic", env->make_integer(env, 
SQLITE_IOERR_ROLLBACK_ATOMIC));
 defconst(env, "sqlite-locked-sharedcache", env->make_integer(env, 
SQLITE_LOCKED_SHAREDCACHE));
+defconst(env, "sqlite-locked-vtab", env->make_integer(env, 
SQLITE_LOCKED_VTAB));
 defconst(env, "sqlite-busy-recovery", env->make_integer(env, 
SQLITE_BUSY_RECOVERY));
 defconst(env, "sqlite-busy-snapshot", env->make_integer(env, 
SQLITE_BUSY_SNAPSHOT));
 defconst(env, "sqlite-cantopen-notempdir", env->make_integer(env, 
SQLITE_CANTOPEN_NOTEMPDIR));
 defconst(env, "sqlite-cantopen-isdir", env->make_integer(env, 
SQLITE_CANTOPEN_ISDIR));
 defconst(env, "sqlite-cantopen-fullpath", env->make_integer(env, 
SQLITE_CANTOPEN_FULLPATH));
 defconst(env, "sqlite-cantopen-convpath", env->make_integer(env, 
SQLITE_CANTOPEN_CONVPATH));
+defconst(env, "sqlite-cantopen-dirtywal", env->make_integer(env, 
SQLITE_CANTOPEN_DIRTYWAL));
 defconst(env, "sqlite-corrupt-vtab", env->make_integer(env, 
SQLITE_CORRUPT_VTAB));
+defconst(env, "sqlite-corrupt-sequence", env->make_integer(env, 
SQLITE_CORRUPT_SEQUENCE));
 defconst(env, "sqlite-readonly-recovery", env->make_integer(env, 
SQLITE_READONLY_RECOVERY));
 defconst(env, "sqlite-readonly-cantlock", env->make_integer(env, 
SQLITE_READONLY_CANTLOCK));
 defconst(env, "sqlite-readonly-rollback", env->make_integer(env, 
SQLITE_READONLY_ROLLBACK));
 defconst(env, "sqlite-readonly-dbmoved", env->make_integer(env, 
SQLITE_READONLY_DBMOVED));
+defconst(env, "sqlite-readonly-cantinit", env->make_integer(env, 
SQLITE_READONLY_CANTINIT));
+defconst(env, "sqlite-readonly-directory", env->make_integer(env, 
SQLITE_READONLY_DIRECTORY));
 defconst(env, "sqlite-abort-rollback", env->make_integer(env, 
SQLITE_ABORT_ROLLBACK));
 defconst(env, "sqlite-constraint-check", env->make_integer(env, 
SQLITE_CONSTRAINT_CHECK));
 defconst(env, "sqlite-constraint-commithook", env->make_integer(env, 
SQLITE_CONSTRAINT_COMMITHOOK));
@@ -105,6 +119,11 @@ defconst(env, "sqlite-open-fullmutex", 
env->make_integer(env, SQLITE_OPEN_FULLMU
 defconst(env, "sqlite-open-sharedcache", env->make_integer(env, 
SQLITE_OPEN_SHAREDCACHE));
 defconst(env, "sqlite-open-privatecache", env->make_integer(env, 
SQLITE_OPEN_PRIVATECACHE));
 defconst(env, "sqlite-open-wal", env->make_integer(env, SQLITE_OPEN_WAL));
+defconst(env, "sqlite-open-fileprotection-complete", env->make_integer(env, 
SQLITE_OPEN_FILEPROTECTION_COMPLETE));
+defconst(env, "sqlite-open-fileprotection-completeunlessopen", 
env->make_integer(env, SQLITE_OPEN_FILEPROTECTION_COMPLETEUNLESSOPEN));
+defconst(env, 
"sqlite-open-fileprotection-completeuntilfirstuserauthentication", 
env->make_integer(env, 
SQLITE_OPEN_FILEPROTECTION_COMPLETEUNTILFIRSTUSERAUTHENTICATION));
+defconst(env, "sqlite-open-fileprotection-none", env->make_integer(env, 
SQLITE_OPEN_FILEPROTECTION_NONE));
+defconst(env, "sqlite-open-fileprotection-mask", env->make_integer(env, 
SQLITE_OPEN_FILEPROTECTION_MASK));
 defconst(env, "sqlite-iocap-atomic", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC));
 defconst(env, "sqlite-iocap-atomic512", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC512));
 defconst(env, "sqlite-iocap-atomic1k", env->make_integer(env, 
SQLITE_IOCAP_ATOMIC1K));
@@ -119,6 +138,7 @@ defconst(env, "sqlite-iocap-sequential", 
env->make_integer(env, SQLITE_IOCAP_SEQ
 defconst(env, "sqlite-iocap-undeletable-when-open", env->make_integer(env, 
SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN));
 defconst(env, "sqlite-iocap-powersafe-overwrite", env->make_integer(env, 
SQLITE_IOCAP_POWERSAFE_OVERWRITE));
 defconst(env, "sqlite-iocap-immutable", env->make_integer(env, 
SQLITE_IOCAP_IMMUTABLE));
+defconst(env, "sqlite-iocap-batch-atomic", env->make_integer(env, 
SQLITE_IOCAP_BATCH_ATOMIC));
 defconst(env, "sqlite-lock-none", env->make_integer(env, SQLITE_LOCK_NONE));
 defconst(env, "sqlite-lock-shared", env->make_integer(env, 
SQLITE_LOCK_SHARED));
 defconst(env, "sqlite-lock-reserved", env->make_integer(env, 
SQLITE_LOCK_RESERVED));
@@ -156,6 +176,10 @@ defconst(env, "sqlite-fcntl-vfs-pointer", 
env->make_integer(env, SQLITE_FCNTL_VF
 defconst(env, "sqlite-fcntl-journal-pointer", env->make_integer(env, 
SQLITE_FCNTL_JOURNAL_POINTER));
 defconst(env, "sqlite-fcntl-win32-get-handle", env->make_integer(env, 
SQLITE_FCNTL_WIN32_GET_HANDLE));
 defconst(env, "sqlite-fcntl-pdb", env->make_integer(env, SQLITE_FCNTL_PDB));
+defconst(env, "sqlite-fcntl-begin-atomic-write", env->make_integer(env, 
SQLITE_FCNTL_BEGIN_ATOMIC_WRITE));
+defconst(env, "sqlite-fcntl-commit-atomic-write", env->make_integer(env, 
SQLITE_FCNTL_COMMIT_ATOMIC_WRITE));
+defconst(env, "sqlite-fcntl-rollback-atomic-write", env->make_integer(env, 
SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE));
+defconst(env, "sqlite-fcntl-lock-timeout", env->make_integer(env, 
SQLITE_FCNTL_LOCK_TIMEOUT));
 defconst(env, "sqlite-get-lockproxyfile", env->make_integer(env, 
SQLITE_GET_LOCKPROXYFILE));
 defconst(env, "sqlite-set-lockproxyfile", env->make_integer(env, 
SQLITE_SET_LOCKPROXYFILE));
 defconst(env, "sqlite-last-errno", env->make_integer(env, SQLITE_LAST_ERRNO));
@@ -192,6 +216,8 @@ defconst(env, "sqlite-config-win32-heapsize", 
env->make_integer(env, SQLITE_CONF
 defconst(env, "sqlite-config-pcache-hdrsz", env->make_integer(env, 
SQLITE_CONFIG_PCACHE_HDRSZ));
 defconst(env, "sqlite-config-pmasz", env->make_integer(env, 
SQLITE_CONFIG_PMASZ));
 defconst(env, "sqlite-config-stmtjrnl-spill", env->make_integer(env, 
SQLITE_CONFIG_STMTJRNL_SPILL));
+defconst(env, "sqlite-config-small-malloc", env->make_integer(env, 
SQLITE_CONFIG_SMALL_MALLOC));
+defconst(env, "sqlite-config-sorterref-size", env->make_integer(env, 
SQLITE_CONFIG_SORTERREF_SIZE));
 defconst(env, "sqlite-dbconfig-maindbname", env->make_integer(env, 
SQLITE_DBCONFIG_MAINDBNAME));
 defconst(env, "sqlite-dbconfig-lookaside", env->make_integer(env, 
SQLITE_DBCONFIG_LOOKASIDE));
 defconst(env, "sqlite-dbconfig-enable-fkey", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_FKEY));
@@ -199,6 +225,10 @@ defconst(env, "sqlite-dbconfig-enable-trigger", 
env->make_integer(env, SQLITE_DB
 defconst(env, "sqlite-dbconfig-enable-fts3-tokenizer", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER));
 defconst(env, "sqlite-dbconfig-enable-load-extension", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION));
 defconst(env, "sqlite-dbconfig-no-ckpt-on-close", env->make_integer(env, 
SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE));
+defconst(env, "sqlite-dbconfig-enable-qpsg", env->make_integer(env, 
SQLITE_DBCONFIG_ENABLE_QPSG));
+defconst(env, "sqlite-dbconfig-trigger-eqp", env->make_integer(env, 
SQLITE_DBCONFIG_TRIGGER_EQP));
+defconst(env, "sqlite-dbconfig-reset-database", env->make_integer(env, 
SQLITE_DBCONFIG_RESET_DATABASE));
+defconst(env, "sqlite-dbconfig-max", env->make_integer(env, 
SQLITE_DBCONFIG_MAX));
 defconst(env, "sqlite-deny", env->make_integer(env, SQLITE_DENY));
 defconst(env, "sqlite-ignore", env->make_integer(env, SQLITE_IGNORE));
 defconst(env, "sqlite-create-index", env->make_integer(env, 
SQLITE_CREATE_INDEX));
@@ -251,11 +281,11 @@ defconst(env, "sqlite-limit-like-pattern-length", 
env->make_integer(env, SQLITE_
 defconst(env, "sqlite-limit-variable-number", env->make_integer(env, 
SQLITE_LIMIT_VARIABLE_NUMBER));
 defconst(env, "sqlite-limit-trigger-depth", env->make_integer(env, 
SQLITE_LIMIT_TRIGGER_DEPTH));
 defconst(env, "sqlite-limit-worker-threads", env->make_integer(env, 
SQLITE_LIMIT_WORKER_THREADS));
+defconst(env, "sqlite-prepare-persistent", env->make_integer(env, 
SQLITE_PREPARE_PERSISTENT));
 defconst(env, "sqlite-integer", env->make_integer(env, SQLITE_INTEGER));
 defconst(env, "sqlite-float", env->make_integer(env, SQLITE_FLOAT));
 defconst(env, "sqlite-blob", env->make_integer(env, SQLITE_BLOB));
 defconst(env, "sqlite-null", env->make_integer(env, SQLITE_NULL));
-defconst(env, "sqlite3-text", env->make_integer(env, SQLITE3_TEXT));
 defconst(env, "sqlite-utf8", env->make_integer(env, SQLITE_UTF8));
 defconst(env, "sqlite-utf16le", env->make_integer(env, SQLITE_UTF16LE));
 defconst(env, "sqlite-utf16be", env->make_integer(env, SQLITE_UTF16BE));
@@ -275,6 +305,11 @@ defconst(env, "sqlite-index-constraint-match", 
env->make_integer(env, SQLITE_IND
 defconst(env, "sqlite-index-constraint-like", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_LIKE));
 defconst(env, "sqlite-index-constraint-glob", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_GLOB));
 defconst(env, "sqlite-index-constraint-regexp", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_REGEXP));
+defconst(env, "sqlite-index-constraint-ne", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_NE));
+defconst(env, "sqlite-index-constraint-isnot", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_ISNOT));
+defconst(env, "sqlite-index-constraint-isnotnull", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_ISNOTNULL));
+defconst(env, "sqlite-index-constraint-isnull", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_ISNULL));
+defconst(env, "sqlite-index-constraint-is", env->make_integer(env, 
SQLITE_INDEX_CONSTRAINT_IS));
 defconst(env, "sqlite-mutex-fast", env->make_integer(env, SQLITE_MUTEX_FAST));
 defconst(env, "sqlite-mutex-recursive", env->make_integer(env, 
SQLITE_MUTEX_RECURSIVE));
 defconst(env, "sqlite-mutex-static-master", env->make_integer(env, 
SQLITE_MUTEX_STATIC_MASTER));
@@ -314,6 +349,7 @@ defconst(env, "sqlite-testctrl-byteorder", 
env->make_integer(env, SQLITE_TESTCTR
 defconst(env, "sqlite-testctrl-isinit", env->make_integer(env, 
SQLITE_TESTCTRL_ISINIT));
 defconst(env, "sqlite-testctrl-sorter-mmap", env->make_integer(env, 
SQLITE_TESTCTRL_SORTER_MMAP));
 defconst(env, "sqlite-testctrl-imposter", env->make_integer(env, 
SQLITE_TESTCTRL_IMPOSTER));
+defconst(env, "sqlite-testctrl-parser-coverage", env->make_integer(env, 
SQLITE_TESTCTRL_PARSER_COVERAGE));
 defconst(env, "sqlite-testctrl-last", env->make_integer(env, 
SQLITE_TESTCTRL_LAST));
 defconst(env, "sqlite-status-memory-used", env->make_integer(env, 
SQLITE_STATUS_MEMORY_USED));
 defconst(env, "sqlite-status-pagecache-used", env->make_integer(env, 
SQLITE_STATUS_PAGECACHE_USED));
@@ -337,11 +373,15 @@ defconst(env, "sqlite-dbstatus-cache-miss", 
env->make_integer(env, SQLITE_DBSTAT
 defconst(env, "sqlite-dbstatus-cache-write", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_WRITE));
 defconst(env, "sqlite-dbstatus-deferred-fks", env->make_integer(env, 
SQLITE_DBSTATUS_DEFERRED_FKS));
 defconst(env, "sqlite-dbstatus-cache-used-shared", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_USED_SHARED));
+defconst(env, "sqlite-dbstatus-cache-spill", env->make_integer(env, 
SQLITE_DBSTATUS_CACHE_SPILL));
 defconst(env, "sqlite-dbstatus-max", env->make_integer(env, 
SQLITE_DBSTATUS_MAX));
 defconst(env, "sqlite-stmtstatus-fullscan-step", env->make_integer(env, 
SQLITE_STMTSTATUS_FULLSCAN_STEP));
 defconst(env, "sqlite-stmtstatus-sort", env->make_integer(env, 
SQLITE_STMTSTATUS_SORT));
 defconst(env, "sqlite-stmtstatus-autoindex", env->make_integer(env, 
SQLITE_STMTSTATUS_AUTOINDEX));
 defconst(env, "sqlite-stmtstatus-vm-step", env->make_integer(env, 
SQLITE_STMTSTATUS_VM_STEP));
+defconst(env, "sqlite-stmtstatus-reprepare", env->make_integer(env, 
SQLITE_STMTSTATUS_REPREPARE));
+defconst(env, "sqlite-stmtstatus-run", env->make_integer(env, 
SQLITE_STMTSTATUS_RUN));
+defconst(env, "sqlite-stmtstatus-memused", env->make_integer(env, 
SQLITE_STMTSTATUS_MEMUSED));
 defconst(env, "sqlite-checkpoint-passive", env->make_integer(env, 
SQLITE_CHECKPOINT_PASSIVE));
 defconst(env, "sqlite-checkpoint-full", env->make_integer(env, 
SQLITE_CHECKPOINT_FULL));
 defconst(env, "sqlite-checkpoint-restart", env->make_integer(env, 
SQLITE_CHECKPOINT_RESTART));
@@ -350,9 +390,7 @@ defconst(env, "sqlite-vtab-constraint-support", 
env->make_integer(env, SQLITE_VT
 defconst(env, "sqlite-rollback", env->make_integer(env, SQLITE_ROLLBACK));
 defconst(env, "sqlite-fail", env->make_integer(env, SQLITE_FAIL));
 defconst(env, "sqlite-replace", env->make_integer(env, SQLITE_REPLACE));
-defconst(env, "sqlite-scanstat-nloop", env->make_integer(env, 
SQLITE_SCANSTAT_NLOOP));
-defconst(env, "sqlite-scanstat-nvisit", env->make_integer(env, 
SQLITE_SCANSTAT_NVISIT));
-defconst(env, "sqlite-scanstat-est", env->make_integer(env, 
SQLITE_SCANSTAT_EST));
-defconst(env, "sqlite-scanstat-name", env->make_integer(env, 
SQLITE_SCANSTAT_NAME));
-defconst(env, "sqlite-scanstat-explain", env->make_integer(env, 
SQLITE_SCANSTAT_EXPLAIN));
-defconst(env, "sqlite-scanstat-selectid", env->make_integer(env, 
SQLITE_SCANSTAT_SELECTID));
+defconst(env, "sqlite-serialize-nocopy", env->make_integer(env, 
SQLITE_SERIALIZE_NOCOPY));
+defconst(env, "sqlite-deserialize-freeonclose", env->make_integer(env, 
SQLITE_DESERIALIZE_FREEONCLOSE));
+defconst(env, "sqlite-deserialize-resizeable", env->make_integer(env, 
SQLITE_DESERIALIZE_RESIZEABLE));
+defconst(env, "sqlite-deserialize-readonly", env->make_integer(env, 
SQLITE_DESERIALIZE_READONLY));
diff --git a/sqlite3-api.c b/sqlite3-api.c
index 11ac7a7b7e..774b964ff2 100644
--- a/sqlite3-api.c
+++ b/sqlite3-api.c
@@ -68,6 +68,10 @@ static emacs_value make_list(emacs_env *env, int n, 
emacs_value *elts) {
   return env->funcall(env, SYM(env, "list"), n, elts);
 }
 
+static emacs_value make_cons(emacs_env *env, emacs_value *elts) {
+  return env->funcall(env, SYM(env, "cons"), 2, elts);
+}
+
 #if 0
 static void message(emacs_env *env, int log_level, const char *fmt, ...) {
   if (log_level < sqlite3_api_log_level)
@@ -564,6 +568,56 @@ static emacs_value sqlite3_api_column_count(
   return env->make_integer(env, sqlite3_column_count(stmt));
 }
 
+static emacs_value sqlite3_api_fetch_alist(
+    emacs_env *env,
+    ptrdiff_t n,
+    emacs_value *args,
+    void *ptr) {
+  (void)ptr;
+  (void)n;
+
+  if (!env->is_not_nil(env, args[0])) {
+    WARN(env, "%s: statement handle is nil", __func__);
+    return SYM(env, "nil");
+  }
+
+  sqlite3_stmt *stmt = (sqlite3_stmt *)env->get_user_ptr(env, args[0]);
+  NON_LOCAL_EXIT_CHECK(env);
+
+  /* Create a list to store the results */
+  int ncols = sqlite3_column_count(stmt);
+  emacs_value *elts = malloc(sizeof(emacs_value)*ncols);
+  for (int i = 0; i < ncols; i++) {
+    /* Create a pair for each column */
+    emacs_value cons[2];
+    const char *col_name = sqlite3_column_name(stmt, i);
+
+    cons[0] = env->make_string(env, col_name, strlen(col_name));
+
+    switch(sqlite3_column_type(stmt, i)) {
+      case SQLITE_INTEGER:
+        cons[1] = env->make_integer(env, sqlite3_column_int64(stmt, i));
+        break;
+      case SQLITE_FLOAT:
+        cons[1] = env->make_float(env, sqlite3_column_double(stmt, i));
+        break;
+      case SQLITE_TEXT:
+        cons[1] = env->make_string(
+            env,
+            (const char *)sqlite3_column_text(stmt, i),
+            sqlite3_column_bytes(stmt, i));
+        break;
+      default:
+        cons[1] = SYM(env, "nil");
+    }
+    elts[i] = make_cons(env, cons);
+  }
+
+  emacs_value res = make_list(env, ncols, elts);
+  FREE(elts);
+  return res;
+}
+
 static emacs_value sqlite3_api_fetch(
     emacs_env *env,
     ptrdiff_t n,
@@ -1021,8 +1075,9 @@ int emacs_module_init(struct emacs_runtime *ert) {
       { "sqlite3-column-double", 2, 2, sqlite3_api_column_double,
         "Return double data of a column." },
       { "sqlite3-fetch", 1, 1, sqlite3_api_fetch,
-        "Return a row as a list." },
-
+        "Return row as a list." },
+      { "sqlite3-fetch-alist", 1, 1, sqlite3_api_fetch_alist,
+        "Return row as an alist." },
       { NULL, 0, 0, NULL, NULL }
     };
 
diff --git a/tools/md-toc.py b/tools/md-toc.py
new file mode 100755
index 0000000000..410401fa7d
--- /dev/null
+++ b/tools/md-toc.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+# Usage: md-toc.py in_file.md > out_file.md
+#
+# Generate a TOC for markdown
+# for 2nd- ("## ....") and 3rd-level ("### ....") headings
+# Put <<TOC>> in the file to mark the location of the TOC
+
+import sys
+
+def main():
+  in_file = sys.argv[1]
+  toc_lines = []
+  lines_before_toc = []
+  lines_after_toc = []
+  anchor_count = 1
+
+  dest = lines_before_toc
+
+  with open(in_file, 'r') as fp:
+    for l in fp.readlines():
+      l = l.rstrip()
+      if l == '<<TOC>>':
+        dest = lines_after_toc
+        dest.append('')
+      elif l.startswith('## '):
+        toc_lines.append(f'* [{l[3:]}](#{anchor_count})')
+        dest.append(f'## <a name="{anchor_count}"/> {l[3:]}')
+        anchor_count += 1
+      elif l.startswith('### '):
+        toc_lines.append(f'    * [{l[4:]}](#{anchor_count})')
+        dest.append(f'### <a name="{anchor_count}"/> {l[4:]}')
+        anchor_count += 1
+      else:
+        dest.append(l)
+
+  for ls in [lines_before_toc, toc_lines, lines_after_toc]:
+    for l in ls:
+      print(l)
+
+
+if __name__ == '__main__':
+  main()