zsv 1.3.1 → 1.4.3

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

@@ -1,178 +0,0 @@
-/*
- * 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

@@ -1,258 +0,0 @@
-#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

@@ -1,246 +0,0 @@
-#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;
-}