zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/os.c

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <unistd.h>
+#include <zsv/utils/os.h>
+#include <stdio.h>
+#include <errno.h>
+
+#ifdef WIN32
+#include "win/fopen_longpath.c"
+#include "win/remove_longpath.c"
+#endif
+
+/**
+ * zsv_fopen(): same as normal fopen(), except on Win it also works with long filenames
+ */
+#if defined(_WIN32) || defined(WIN32) || defined(WIN)
+FILE *zsv_fopen(const char *fname, const char *mode) {
+  if (strlen(fname) >= MAX_PATH)
+    return zsv_fopen_longpath(fname, mode);
+  return fopen(fname, mode);
+}
+#endif
+
+#ifndef _WIN32
+
+void zsv_perror(const char *s) {
+  perror(s);
+}
+
+int zsv_replace_file(const char *src, const char *dst) {
+  int save_errno = 0;
+
+  if (rename(src, dst) == 0) {
+    return 0;
+  }
+
+  if (errno != EXDEV) {
+    return errno;
+  }
+
+  // Fallback: copy and remove
+  FILE *fp_in = zsv_fopen(src, "rb");
+  if (!fp_in)
+    return errno;
+
+  FILE *fp_out = zsv_fopen(dst, "wb");
+  if (!fp_out) {
+    save_errno = errno;
+    fclose(fp_in);
+    return save_errno;
+  }
+
+  char buffer[4096];
+  size_t bytes_read;
+  while ((bytes_read = fread(buffer, 1, sizeof(buffer), fp_in)) > 0) {
+    if (fwrite(buffer, 1, bytes_read, fp_out) != bytes_read) {
+      fclose(fp_out);
+      fclose(fp_in);
+      return EOF;
+    }
+  }
+
+  fclose(fp_out);
+  fclose(fp_in);
+
+  if (remove(src) != 0)
+    return errno;
+
+  return 0;
+}
+
+#else
+#include <windows.h>
+#include <strsafe.h>
+
+static void strlcpy(register char *dst, register const char *src, size_t n) {
+  for (; *src != '\0' && n > 1; n--) {
+    *dst++ = *src++;
+  }
+  *dst = '\0';
+}
+
+static void change_slashes_to_backslashes(char *path) {
+  int i;
+  for (i = 0; path[i] != '\0'; i++) {
+    if (path[i] == '/') {
+      path[i] = '\\';
+    }
+    if ((path[i] == '\\') && (i > 0)) {
+      while (path[i + 1] == '\\' || path[i + 1] == '/') {
+        (void)memmove(path + i + 1, path + i + 2, strlen(path + i + 1));
+      }
+    }
+  }
+}
+
+void zsv_win_to_unicode(const void *path, wchar_t *wbuf, size_t wbuf_len) {
+  char buf[PATH_MAX], buf2[PATH_MAX];
+  strlcpy(buf, path, sizeof(buf));
+
+  change_slashes_to_backslashes(buf);
+
+  /* Convert to Unicode and back. If doubly-converted string does not
+   * match the original, something is fishy, reject. */
+  memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
+  MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int)wbuf_len);
+  WideCharToMultiByte(CP_UTF8, 0, wbuf, (int)wbuf_len, buf2, sizeof(buf2), NULL, NULL);
+  if (strcmp(buf, buf2) != 0) {
+    wbuf[0] = L'\0';
+  }
+}
+
+#include <wchar.h>
+
+int zsv_replace_file(const char *src, const char *dest) {
+  wchar_t wdest[PATH_MAX], wsrc[PATH_MAX];
+
+  zsv_win_to_unicode(dest, wdest, ARRAY_SIZE(wdest));
+  zsv_win_to_unicode(src, wsrc, ARRAY_SIZE(wsrc));
+
+  if (MoveFileExW(wsrc, wdest, MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) // success
+    return 0;
+
+  if (GetLastError() == 2)        // file not found, could be target. use simple rename
+    return _wrename(wsrc, wdest); // returns 0 on success
+
+  return 1; // fail
+}
+
+static void zsv_win_printLastError(void) {
+  DWORD dw = GetLastError();
+  LPVOID lpMsgBuf;
+  LPVOID lpDisplayBuf;
+  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw,
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
+  // Display the error message and exit the process
+  lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, (lstrlen((LPCTSTR)lpMsgBuf) + 40) * sizeof(TCHAR));
+  StringCchPrintf((LPTSTR)lpDisplayBuf, LocalSize(lpDisplayBuf) / sizeof(TCHAR), TEXT("%s\r\n"), lpMsgBuf);
+  fprintf(stderr, "%s\r\n", (LPCTSTR)lpDisplayBuf);
+  LocalFree(lpMsgBuf);
+  LocalFree(lpDisplayBuf);
+}
+
+void zsv_perror(const char *s) {
+  if (s && *s)
+    fwrite(s, 1, strlen(s), stderr);
+  zsv_win_printLastError();
+}
+
+#endif
+
+unsigned int zsv_get_number_of_cores() {
+  long ncores = 1; // Default to 1 in case of failure
+
+#ifdef _WIN32
+  // Implementation for Windows (when cross-compiled with mingw64)
+  SYSTEM_INFO sysinfo;
+  GetSystemInfo(&sysinfo);
+  ncores = sysinfo.dwNumberOfProcessors;
+#elif defined(_SC_NPROCESSORS_ONLN)
+  // Implementation for Linux and macOS (uses POSIX standard sysconf)
+  // _SC_NPROCESSORS_ONLN gets the number of *online* processors.
+  ncores = sysconf(_SC_NPROCESSORS_ONLN);
+#else
+  // Fallback for other POSIX-like systems that might not define the symbol
+  // or for unexpected compilation environments.
+#error Undefined! _SC_NPROCESSORS_ONLN
+  xx ncores = 1;
+#endif
+  // Ensure we return a positive value
+  return (unsigned int)(ncores > 0 ? ncores : 1);
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/overwrite.c

@@ -0,0 +1,258 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include <sqlite3.h>
+
+#include <zsv.h>
+#include <zsv/utils/overwrite.h>
+#include <zsv/utils/cache.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/os.h>
+
+#define zsv_overwrite_sqlite3_prefix "sqlite3://"
+#define zsv_overwrite_sql_prefix "sql="
+
+/* Overwrite structure for CSV or SQLITE3 sources */
+void *zsv_overwrite_context_new(struct zsv_overwrite_opts *opts) {
+  struct zsv_overwrite_ctx *ctx = calloc(1, sizeof(*ctx));
+  if (ctx && opts->src) {
+    if (!(ctx->src = strdup(opts->src)))
+      fprintf(stderr, "zsv_overwrite_context_new: out of memory!\n");
+  }
+  return ctx;
+}
+
+enum zsv_status zsv_overwrite_context_delete(void *h) {
+  struct zsv_overwrite_ctx *ctx = h;
+  if (ctx->sqlite3.filename)
+    free(ctx->sqlite3.filename);
+  if (ctx->sqlite3.stmt)
+    sqlite3_finalize(ctx->sqlite3.stmt);
+  if (ctx->sqlite3.db)
+    sqlite3_close(ctx->sqlite3.db);
+  if (ctx->csv.f)
+    fclose(ctx->csv.f);
+  if (ctx->csv.parser)
+    zsv_delete(ctx->csv.parser);
+  free(ctx->src);
+  free(ctx);
+  return zsv_status_ok;
+}
+
+static enum zsv_status zsv_next_overwrite_csv(void *h, struct zsv_overwrite_data *odata) {
+  struct zsv_overwrite_ctx *ctx = h;
+  if (zsv_next_row(ctx->csv.parser) != zsv_status_row)
+    odata->have = 0;
+  else {
+    // row, column, value
+    struct zsv_cell row = zsv_get_cell(ctx->csv.parser, 0);
+    struct zsv_cell col = zsv_get_cell(ctx->csv.parser, 1);
+    struct zsv_cell val = zsv_get_cell(ctx->csv.parser, 2);
+    struct zsv_cell author = {0};
+    struct zsv_cell timestamp = {0};
+    struct zsv_cell old_value = {0};
+    if (ctx->author_ix)
+      author = zsv_get_cell(ctx->csv.parser, ctx->author_ix);
+    if (ctx->timestamp_ix)
+      timestamp = zsv_get_cell(ctx->csv.parser, ctx->timestamp_ix);
+    if (ctx->old_value_ix)
+      old_value = zsv_get_cell(ctx->csv.parser, ctx->old_value_ix);
+    if (row.len && col.len) {
+      char *end = (char *)(row.str + row.len);
+      char **endp = &end;
+      odata->row_ix = strtoumax((char *)row.str, endp, 10);
+      end = (char *)(col.str + col.len);
+      odata->col_ix = strtoumax((char *)col.str, endp, 10);
+      odata->val = val;
+      odata->author = author;
+      odata->old_value = old_value;
+    } else {
+      odata->row_ix = 0;
+      odata->col_ix = 0;
+      odata->val.len = 0;
+      odata->old_value.len = 0;
+      odata->author.len = 0;
+    }
+
+    if (timestamp.len) {
+      char *end = (char *)(timestamp.str + timestamp.len);
+      char **endp = &end;
+      odata->timestamp = strtoumax((char *)timestamp.str, endp, 10);
+    }
+  }
+  return zsv_status_ok;
+}
+
+static enum zsv_status zsv_next_overwrite_sqlite3(void *h, struct zsv_overwrite_data *odata) {
+  struct zsv_overwrite_ctx *ctx = h;
+  if (odata->have) {
+    sqlite3_stmt *stmt = ctx->sqlite3.stmt;
+    if (stmt) {
+      if (sqlite3_step(stmt) == SQLITE_ROW) {
+        // row, column, value
+        odata->row_ix = sqlite3_column_int64(stmt, 0);
+        odata->col_ix = sqlite3_column_int64(stmt, 1);
+        odata->val.str = (unsigned char *)sqlite3_column_text(stmt, 2);
+        odata->val.len = sqlite3_column_bytes(stmt, 2);
+        odata->timestamp = sqlite3_column_int64(stmt, 3);
+        odata->author.str = (unsigned char *)sqlite3_column_text(stmt, 4);
+        odata->author.len = sqlite3_column_bytes(stmt, 4);
+      } else {
+        odata->row_ix = 0;
+        odata->col_ix = 0;
+        odata->val.len = 0;
+        odata->timestamp = 0;
+        odata->author.len = 0;
+        odata->have = 0;
+      }
+    }
+  }
+  return zsv_status_ok;
+}
+
+enum zsv_status zsv_overwrite_next(void *h, struct zsv_overwrite_data *odata) {
+  struct zsv_overwrite_ctx *ctx = h;
+  return ctx->next(ctx, odata);
+}
+
+static enum zsv_status zsv_overwrite_init_sqlite3(struct zsv_overwrite_ctx *ctx, const char *source, size_t len) {
+  char ok = 0;
+  size_t pfx_len;
+  if (len > (pfx_len = strlen(zsv_overwrite_sqlite3_prefix)) &&
+      !memcmp(source, zsv_overwrite_sqlite3_prefix, pfx_len)) {
+    ctx->sqlite3.filename = malloc(len - pfx_len + 1);
+    memcpy(ctx->sqlite3.filename, source + pfx_len, len - pfx_len);
+    ctx->sqlite3.filename[len - pfx_len] = '\0';
+    char *q = memchr(ctx->sqlite3.filename, '?', len - pfx_len);
+    if (q) {
+      *q = '\0';
+      q++;
+      const char *sql = strstr(q, zsv_overwrite_sql_prefix);
+      if (sql)
+        ctx->sqlite3.sql = sql + strlen(zsv_overwrite_sql_prefix);
+    }
+
+    if (!ctx->sqlite3.filename || !*ctx->sqlite3.filename) {
+      fprintf(stderr, "Missing sqlite3 file name\n");
+      return zsv_status_error;
+    }
+
+    if (!ctx->sqlite3.sql || !*ctx->sqlite3.sql) {
+      // to do: detect it from the db
+      fprintf(stderr, "Missing sql select statement for sqlite3 overwrite data e.g.:\n"
+                      "  select row, column, value from overwrites order by row, column\n");
+      return zsv_status_error;
+    }
+    ok = 1;
+  } else if (len > strlen(".sqlite3") && !strcmp(source + len - strlen(".sqlite3"), ".sqlite3")) {
+    ctx->sqlite3.filename = strdup(source);
+    ctx->sqlite3.sql = "select * from overwrites order by row, column";
+    ok = 1;
+  }
+
+  if (ok) {
+    int rc = sqlite3_open_v2(ctx->sqlite3.filename, &ctx->sqlite3.db, SQLITE_OPEN_READONLY, NULL);
+    if (rc != SQLITE_OK || !ctx->sqlite3.db) {
+      fprintf(stderr, "%s: %s\n", sqlite3_errstr(rc), ctx->sqlite3.filename);
+      return zsv_status_error;
+    }
+
+    rc = sqlite3_prepare_v2(ctx->sqlite3.db, ctx->sqlite3.sql, -1, &ctx->sqlite3.stmt, NULL);
+    if (rc != SQLITE_OK || !ctx->sqlite3.stmt) {
+      fprintf(stderr, "%s\n", sqlite3_errmsg(ctx->sqlite3.db));
+      return zsv_status_error;
+    }
+
+    // successful sqlite3 connection
+    return zsv_status_ok;
+  }
+
+  fprintf(stderr, "Invalid overwrite source: %s\n", source);
+  return zsv_status_error;
+}
+
+enum zsv_status zsv_overwrite_open(void *h) {
+  struct zsv_overwrite_ctx *ctx = h;
+  if (!ctx->src)
+    return zsv_status_ok;
+  char ok = 0;
+  size_t src_len = strlen(ctx->src);
+  if ((src_len > strlen(zsv_overwrite_sqlite3_prefix) &&
+       !memcmp(zsv_overwrite_sqlite3_prefix, ctx->src, strlen(zsv_overwrite_sqlite3_prefix))) ||
+      (src_len > strlen(".sqlite3") && !strcmp(ctx->src + src_len - strlen(".sqlite3"), ".sqlite3"))) {
+    if (zsv_overwrite_init_sqlite3(ctx, ctx->src, src_len) == zsv_status_ok) {
+      ctx->next = zsv_next_overwrite_sqlite3;
+      ok = 1;
+    }
+  } else { // csv
+    struct zsv_opts opts = {0};
+    ctx->csv.f = opts.stream = zsv_fopen(ctx->src, "rb");
+    if (!ctx->csv.f) {
+      perror(ctx->src);
+      return zsv_status_error;
+    }
+    if (!(ctx->csv.parser = zsv_new(&opts)))
+      return zsv_status_memory;
+
+    if (zsv_next_row(ctx->csv.parser) != zsv_status_row) {
+      fprintf(stderr, "Unable to fetch any data from overwrite source %s\n", ctx->src);
+    } else {
+      // row, column, value
+      struct zsv_cell row = zsv_get_cell(ctx->csv.parser, 0);
+      struct zsv_cell col = zsv_get_cell(ctx->csv.parser, 1);
+      struct zsv_cell val = zsv_get_cell(ctx->csv.parser, 2);
+      if (row.len < 3 || memcmp(row.str, "row", 3) || col.len < 3 || memcmp(col.str, "col", 3) || val.len < 3 ||
+          memcmp(val.str, "val", 3))
+        fprintf(stderr, "Warning! overwrite expects 'row,col,value' header, got '%.*s,%.*s,%.*s'\n", (int)row.len,
+                row.str, (int)col.len, col.str, (int)val.len, val.str);
+      struct zsv_cell next;
+      for (size_t i = 3; (next = zsv_get_cell(ctx->csv.parser, i)).len > 0; i++) {
+        if (!memcmp(next.str, "timestamp", 9)) {
+          ctx->timestamp_ix = i;
+        } else if (!memcmp(next.str, "author", 6)) {
+          ctx->author_ix = i;
+        } else if (!memcmp(next.str, "old value", 9)) {
+          ctx->old_value_ix = i;
+        }
+      }
+    }
+    ctx->next = zsv_next_overwrite_csv;
+    ok = 1;
+  }
+  return ok ? zsv_status_ok : zsv_status_error;
+}
+
+/*
+ * zsv_overwrite_auto() returns:
+ * - zsv_status_done if a valid overwrite file was found
+ * - zsv_status_no_more_input if no overwrite file was found
+ * - a different status code on error
+ */
+enum zsv_status zsv_overwrite_auto(struct zsv_opts *opts, const char *csv_path) {
+  enum zsv_status status = zsv_status_error;
+  if (opts->overwrite.ctx || opts->overwrite.open || opts->overwrite.next || opts->overwrite.close)
+    status = zsv_status_error;
+  else {
+    unsigned char *overwrite_fn = zsv_cache_filepath((const unsigned char *)csv_path, zsv_cache_type_overwrite, 0, 0);
+    if (!overwrite_fn)
+      status = zsv_status_memory;
+    else if (!zsv_file_exists((char *)overwrite_fn))
+      status = zsv_status_no_more_input;
+    else {
+      struct zsv_overwrite_opts overwrite_opts = {0};
+      overwrite_opts.src = (char *)overwrite_fn;
+      if (!(opts->overwrite.ctx = zsv_overwrite_context_new(&overwrite_opts)))
+        status = zsv_status_memory;
+      else {
+        opts->overwrite.open = zsv_overwrite_open;
+        opts->overwrite.next = zsv_overwrite_next;
+        opts->overwrite.close = zsv_overwrite_context_delete;
+        status = zsv_status_done;
+      }
+    }
+    free(overwrite_fn);
+  }
+  return status;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/overwrite_writer.c

@@ -0,0 +1,246 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sqlite3.h>
+#include <errno.h>
+#include <limits.h>
+
+#include <zsv.h>
+#include <zsv/utils/writer.h>
+#include <zsv/utils/dirs.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/os.h>
+#include <zsv/utils/overwrite.h>
+#include <zsv/utils/overwrite_writer.h>
+
+static enum zsv_status zsv_overwrite_writer_init(struct zsv_overwrite *data) {
+  enum zsv_status err = zsv_status_ok;
+  int tmp_err = 0;
+  if (zsv_mkdirs(data->ctx->src, 1) && !zsv_file_readable(data->ctx->src, &tmp_err, NULL)) {
+    err = zsv_status_error;
+    perror(data->ctx->src);
+    return err;
+  }
+
+  sqlite3_stmt *query = NULL;
+
+  if (sqlite3_open_v2(data->ctx->src, &data->ctx->sqlite3.db, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK ||
+      data->mode == zsvsheet_mode_add || data->mode == zsvsheet_mode_bulk || data->mode == zsvsheet_mode_remove ||
+      data->mode == zsvsheet_mode_clear) {
+    sqlite3_close(data->ctx->sqlite3.db);
+    if (sqlite3_open_v2(data->ctx->src, &data->ctx->sqlite3.db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) !=
+        SQLITE_OK) {
+      err = zsv_status_error;
+      fprintf(stderr, "Failed to open conn: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+      return err;
+    }
+
+    if (sqlite3_exec(data->ctx->sqlite3.db, "PRAGMA foreign_keys = on", NULL, NULL, NULL) != SQLITE_OK) {
+      err = zsv_status_error;
+      fprintf(stderr, "Could not enable foreign keys: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+      return err;
+    }
+
+    if (sqlite3_prepare_v2(data->ctx->sqlite3.db,
+                           "CREATE TABLE IF NOT EXISTS overwrites ( row integer, column integer, value string, "
+                           "timestamp varchar(25), author varchar(25) );",
+                           -1, &query, NULL) == SQLITE_OK) {
+      if (sqlite3_step(query) != SQLITE_DONE) {
+        err = zsv_status_error;
+        fprintf(stderr, "Failed to step: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+        return err;
+      }
+    } else {
+      err = zsv_status_error;
+      fprintf(stderr, "Failed to prepare1: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+    }
+
+    if (query)
+      sqlite3_finalize(query);
+
+    if (sqlite3_prepare_v2(data->ctx->sqlite3.db, "CREATE UNIQUE INDEX overwrites_uix ON overwrites (row, column)", -1,
+                           &query, NULL) == SQLITE_OK) {
+      if (sqlite3_step(query) != SQLITE_DONE) {
+        err = zsv_status_error;
+        fprintf(stderr, "Failed to step: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+        return err;
+      }
+      if (query)
+        sqlite3_finalize(query);
+    }
+  }
+
+  if (!data->ctx->sqlite3.db)
+    err = zsv_status_error;
+
+  return err;
+}
+
+struct zsv_overwrite *zsv_overwrite_writer_new(struct zsv_overwrite_args *args, struct zsv_overwrite_opts *ctx_opts) {
+  struct zsv_overwrite *data = calloc(1, sizeof(*data));
+  data->overwrite = calloc(1, sizeof(*data->overwrite));
+  data->overwrite->old_value = args->overwrite->old_value;
+  data->force = args->force;
+  data->all = args->all;
+  data->a1 = args->a1;
+  data->bulk_file = args->bulk_file;
+  data->mode = args->mode;
+  data->ctx = zsv_overwrite_context_new(ctx_opts);
+  data->overwrite = args->overwrite;
+  data->next = args->next;
+  struct zsv_csv_writer_options writer_opts = {0};
+  data->writer = zsv_writer_new(&writer_opts);
+
+  enum zsv_status err = zsv_status_ok;
+  if (data->mode == zsvsheet_mode_list) {
+    if ((err = (zsv_overwrite_open(data->ctx)))) // use open when it's read-only
+      fprintf(stderr, "Failed to initalize database\n");
+  } else {
+    if ((err = zsv_overwrite_writer_init(data))) // use init when writing to db
+      fprintf(stderr, "Failed to initalize database\n");
+  }
+
+  return err == zsv_status_ok ? data : NULL;
+}
+
+void zsv_overwrite_writer_delete(struct zsv_overwrite *data) {
+  if (data->writer)
+    zsv_writer_delete(data->writer);
+  if (data->ctx)
+    zsv_overwrite_context_delete(data->ctx);
+
+  if (data->overwrite && data->mode != zsvsheet_mode_bulk)
+    free(data->overwrite->val.str);
+
+  if (data->all)
+    zsv_remove(data->ctx->src);
+  free(data);
+}
+
+enum zsv_status zsv_overwrite_writer_add(struct zsv_overwrite *data) {
+  if (!data->overwrite->val.str)
+    return zsv_status_error;
+  if (data->force)
+    data->ctx->sqlite3.sql =
+      "INSERT OR REPLACE INTO overwrites (row, column, value, timestamp, author) VALUES (?, ?, ?, ?, ?)";
+  else if (data->overwrite->old_value.len > 0)
+    data->ctx->sqlite3.sql = "INSERT OR REPLACE INTO overwrites (row, column, value, timestamp, author) SELECT ?, ?, "
+                             "?, ?, ? WHERE EXISTS (SELECT 1 FROM overwrites WHERE value = ?)";
+  else
+    data->ctx->sqlite3.sql = "INSERT INTO overwrites (row, column, value, timestamp, author) VALUES (?, ?, ?, ?, ?)";
+
+  enum zsv_status err = zsv_status_ok;
+  sqlite3_stmt *query = NULL;
+
+  if (sqlite3_prepare_v2(data->ctx->sqlite3.db, data->ctx->sqlite3.sql, -1, &query, NULL) == SQLITE_OK) {
+    sqlite3_bind_int64(query, 1, data->overwrite->row_ix);
+    sqlite3_bind_int64(query, 2, data->overwrite->col_ix);
+    sqlite3_bind_text(query, 3, (const char *)data->overwrite->val.str, data->overwrite->val.len, SQLITE_STATIC);
+    if (data->overwrite->timestamp)
+      sqlite3_bind_int64(query, 4, data->overwrite->timestamp);
+    else
+      sqlite3_bind_null(query, 4);
+    if (data->overwrite->author.len > 0)
+      sqlite3_bind_text(query, 5, (const char *)data->overwrite->author.str, data->overwrite->author.len,
+                        SQLITE_STATIC);
+    else
+      sqlite3_bind_text(query, 5, "", -1, SQLITE_STATIC);
+
+    if (data->overwrite->old_value.len > 0)
+      sqlite3_bind_text(query, 6, (const char *)data->overwrite->old_value.str, data->overwrite->old_value.len,
+                        SQLITE_STATIC);
+
+    if (sqlite3_step(query) != SQLITE_DONE) {
+      err = zsv_status_error;
+      if (data->mode == zsvsheet_mode_bulk)
+        sqlite3_exec(data->ctx->sqlite3.db, "ROLLBACK", NULL, NULL, NULL);
+      fprintf(stderr, "Value already exists at row %zu and column %zu, use --force to force insert\n",
+              data->overwrite->row_ix, data->overwrite->col_ix);
+    }
+  } else {
+    err = zsv_status_error;
+    if (data->mode == zsvsheet_mode_bulk)
+      sqlite3_exec(data->ctx->sqlite3.db, "ROLLBACK", NULL, NULL, NULL);
+    fprintf(stderr, "Failed to prepare2: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+  }
+
+  if (query)
+    sqlite3_finalize(query);
+
+  return err;
+}
+
+enum zsv_status zsv_overwrite_writer_remove(struct zsv_overwrite *data) {
+  enum zsv_status err = zsv_status_ok;
+  if (data->all) {
+    err = zsv_overwrite_writer_clear(data);
+    return err;
+  }
+
+  data->ctx->sqlite3.sql = data->overwrite->old_value.len > 0
+                             ? "DELETE FROM overwrites WHERE row = ? AND column = ? AND value = ?"
+                             : "DELETE FROM overwrites WHERE row = ? AND column = ?";
+
+  sqlite3_stmt *query = NULL;
+  if (sqlite3_prepare_v2(data->ctx->sqlite3.db, data->ctx->sqlite3.sql, -1, &query, NULL) != SQLITE_OK) {
+    err = zsv_status_error;
+    if (data->mode == zsvsheet_mode_bulk)
+      sqlite3_exec(data->ctx->sqlite3.db, "ROLLBACK", NULL, NULL, NULL);
+    fprintf(stderr, "Could not prepare: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+    return err;
+  }
+  sqlite3_bind_int64(query, 1, data->overwrite->row_ix);
+  sqlite3_bind_int64(query, 2, data->overwrite->col_ix);
+  if (data->overwrite->old_value.len > 0)
+    sqlite3_bind_text(query, 3, (const char *)data->overwrite->old_value.str, data->overwrite->old_value.len,
+                      SQLITE_STATIC);
+
+  if (sqlite3_step(query) != SQLITE_DONE) {
+    err = zsv_status_error;
+    if (data->mode == zsvsheet_mode_bulk)
+      sqlite3_exec(data->ctx->sqlite3.db, "ROLLBACK", NULL, NULL, NULL);
+    fprintf(stderr, "Could not step: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+    return err;
+  }
+  if (query)
+    sqlite3_finalize(query);
+  return err;
+}
+
+enum zsv_status zsv_overwrite_writer_bulk(struct zsv_overwrite *data) {
+  free(data->ctx->src);
+  data->ctx->src = (char *)data->bulk_file;
+  if (zsv_overwrite_open(data->ctx) != zsv_status_ok) {
+    fprintf(stderr, "Could not open\n");
+    return zsv_status_error;
+  }
+  data->overwrite->have = 1;
+  data->ctx->row_ix = 1;
+  if (sqlite3_exec(data->ctx->sqlite3.db, "BEGIN TRANSACTION", NULL, NULL, NULL) == SQLITE_OK) {
+    while (data->ctx->next(data->ctx, data->overwrite) == zsv_status_ok && data->overwrite->have) {
+      data->next(data);
+      data->overwrite->timestamp = 0;
+    }
+    if (sqlite3_exec(data->ctx->sqlite3.db, "COMMIT", NULL, NULL, NULL) != SQLITE_OK)
+      fprintf(stderr, "Could not commit changes: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+  } else
+    fprintf(stderr, "Could not begin transaction: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+  return zsv_status_ok;
+}
+
+enum zsv_status zsv_overwrite_writer_clear(struct zsv_overwrite *data) {
+  enum zsv_status err = zsv_status_ok;
+  sqlite3_stmt *query = NULL;
+  if (sqlite3_prepare_v2(data->ctx->sqlite3.db, "DELETE FROM overwrites", -1, &query, NULL) == SQLITE_OK) {
+    if (sqlite3_step(query) != SQLITE_DONE) {
+      err = zsv_status_error;
+      fprintf(stderr, "Failed to step: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+      return err;
+    }
+  } else {
+    err = zsv_status_error;
+    fprintf(stderr, "Could not prepare: %s\n", sqlite3_errmsg(data->ctx->sqlite3.db));
+  }
+  if (query)
+    sqlite3_finalize(query);
+  return err;
+}