zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/sheet-sql.c

@@ -0,0 +1,167 @@
+static zsvsheet_status zsv_sqlite3_to_csv(zsvsheet_proc_context_t pctx, struct zsv_sqlite3_db *zdb, const char *sql,
+                                          const char **err_msg, void *ctx,
+                                          void (*on_header_cell)(void *, size_t, const char *),
+                                          void (*on_data_cell)(void *, size_t, const char *, size_t len)) {
+  zsvsheet_status zst = zsvsheet_status_error;
+  sqlite3_stmt *stmt = NULL;
+  char have_data = 0;
+  if ((zdb->rc = sqlite3_prepare_v2(zdb->db, sql, -1, &stmt, NULL)) == SQLITE_OK) {
+    char *tmp_fn = zsv_get_temp_filename("zsv_mysheet_ext_XXXXXXXX");
+    struct zsv_csv_writer_options writer_opts = zsv_writer_get_default_opts();
+    zsv_csv_writer cw = NULL;
+    if (!tmp_fn)
+      zst = zsvsheet_status_memory;
+    else if (!(writer_opts.stream = fopen(tmp_fn, "wb"))) {
+      zst = zsvsheet_status_error;
+      *err_msg = strerror(errno);
+    } else if (!(cw = zsv_writer_new(&writer_opts)))
+      zst = zsvsheet_status_memory;
+    else {
+      zst = zsvsheet_status_ok;
+      unsigned char cw_buff[1024];
+      zsv_writer_set_temp_buff(cw, cw_buff, sizeof(cw_buff));
+
+      int col_count = sqlite3_column_count(stmt);
+      // write header row
+      for (int i = 0; i < col_count; i++) {
+        const char *colname = sqlite3_column_name(stmt, i);
+        zsv_writer_cell(cw, !i, (const unsigned char *)colname, colname ? strlen(colname) : 0, 1);
+        if (on_header_cell)
+          on_header_cell(ctx, i, colname);
+      }
+
+      // write sql results
+      while (sqlite3_step(stmt) == SQLITE_ROW) {
+        for (int i = 0; i < col_count; i++) {
+          const unsigned char *text = sqlite3_column_text(stmt, i);
+          int len = text ? sqlite3_column_bytes(stmt, i) : 0;
+          zsv_writer_cell(cw, !i, text, len, 1);
+          have_data = 1;
+          if (on_data_cell)
+            on_data_cell(ctx, i, (const char *)text, len);
+        }
+      }
+    }
+    if (cw)
+      zsv_writer_delete(cw);
+    if (writer_opts.stream)
+      fclose(writer_opts.stream);
+
+    if (tmp_fn && zsv_file_exists(tmp_fn) && have_data) {
+      struct zsvsheet_ui_buffer_opts uibopts = {0};
+      uibopts.data_filename = tmp_fn;
+      zst = zsvsheet_open_file_opts(pctx, &uibopts);
+    } else {
+      if (zst == zsvsheet_status_ok) {
+        if (!have_data)
+          zst = zsvsheet_status_no_data;
+        if (!*err_msg && zdb && zdb->rc != SQLITE_OK) {
+          zst = zsvsheet_status_error; // to do: make this more specific
+          *err_msg = sqlite3_errmsg(zdb->db);
+        }
+      }
+      if (tmp_fn && zsv_file_exists(tmp_fn))
+        unlink(tmp_fn);
+    }
+    free(tmp_fn);
+  }
+  if (stmt)
+    sqlite3_finalize(stmt);
+
+  return zst;
+}
+
+static int is_constant_expression(sqlite3 *db, const char *expr, int *err) {
+  sqlite3_stmt *stmt = NULL;
+  // We try to prepare "SELECT [expr]". If this succeeds, the expression
+  // does not depend on any columns and is therefore constant.
+  char *sql_const_test = sqlite3_mprintf("SELECT %s", expr);
+  if (!sql_const_test) {
+    *err = errno;
+    return 0;
+  }
+
+  int rc = sqlite3_prepare_v2(db, sql_const_test, -1, &stmt, NULL);
+  if (stmt) {
+    sqlite3_finalize(stmt);
+    stmt = NULL;
+  }
+  sqlite3_free(sql_const_test);
+
+  int is_constant = (rc == SQLITE_OK);
+  return is_constant;
+}
+
+enum check_select_expression_result {
+  zsv_select_sql_expression_valid = 0,
+  zsv_select_sql_expression_invalid,
+  zsv_select_sql_expression_multiple_statements,
+  zsv_select_sql_expression_multiple_expressions,
+  zsv_select_sql_expression_other
+};
+
+const char *check_select_expression_result_str(enum check_select_expression_result rc) {
+  switch (rc) {
+  case zsv_select_sql_expression_valid:
+    return NULL;
+  case zsv_select_sql_expression_invalid:
+    return "Invalid SQL";
+  case zsv_select_sql_expression_multiple_statements:
+    return "Please enter only a single expression";
+  case zsv_select_sql_expression_multiple_expressions:
+    return "Please enter only a single expression";
+  case zsv_select_sql_expression_other:
+    return "Unknown error";
+  }
+  return NULL;
+}
+
+static int is_str_empty(const char *s) {
+  if (!s)
+    return 1;
+  while (*s) {
+    if (!isspace((unsigned char)*s)) {
+      return 0;
+    }
+    s++;
+  }
+  return 1;
+}
+
+static enum check_select_expression_result check_select_expression(sqlite3 *db, const char *expr, int *err) {
+  sqlite3_stmt *stmt = NULL;
+
+  // Prepare "SELECT [expr] FROM data" to see if it's valid in the
+  // context of the 'data' table.
+  char *sql_valid_test = sqlite3_mprintf("SELECT %s FROM data LIMIT 0", expr);
+  if (!sql_valid_test) {
+    *err = errno;
+    return zsv_select_sql_expression_other;
+  }
+
+  const char *pzTail = NULL;
+  int rc = sqlite3_prepare_v2(db, sql_valid_test, -1, &stmt, &pzTail);
+  sqlite3_free(sql_valid_test); // Free the string immediately
+  if (rc != SQLITE_OK) {
+    if (stmt)
+      sqlite3_finalize(stmt);
+    return zsv_select_sql_expression_invalid;
+  }
+
+  // if we are here, the expression is valid. check it is a single statement
+  // pzTail points to the start of the *next* statement. If it's not
+  // empty or just whitespace, the user tried to inject a second command.
+  if (!is_str_empty(pzTail)) {
+    sqlite3_finalize(stmt);
+    return zsv_select_sql_expression_multiple_statements;
+  }
+
+  // Check that we have a single expression (e.g., not "myvalue, 123")
+  int col_count = sqlite3_column_count(stmt);
+
+  sqlite3_finalize(stmt);
+  if (col_count != 1)
+    return zsv_select_sql_expression_multiple_expressions;
+
+  return zsv_select_sql_expression_valid;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/sheet_internal.h

@@ -0,0 +1,36 @@
+#ifndef ZSVSHEET_INTERNAL_H
+#define ZSVSHEET_INTERNAL_H
+
+#define ZSVSHEET_ROWNUM_HEADER "Row #"
+#define ZSVSHEET_ROWNUM_HEADER_LEN strlen(ZSVSHEET_ROWNUM_HEADER)
+
+enum zsvsheet_priv_status {
+  zsvsheet_priv_status_ok = 0,
+  zsvsheet_priv_status_memory,
+  zsvsheet_priv_status_error, // generic error
+  zsvsheet_priv_status_utf8,
+  zsvsheet_priv_status_continue // ignore / continue
+  //  zsvsheet_priv_status_duplicate
+};
+
+struct zsvsheet_input_dimensions {
+  size_t col_count;
+  size_t row_count;
+};
+
+struct zsvsheet_display_dimensions {
+  size_t rows;
+  size_t columns;
+  size_t header_span;
+  size_t footer_span;
+};
+
+struct zsvsheet_buffer_info_internal {
+  unsigned char index_started : 1;
+  unsigned char index_ready : 1;
+  unsigned char write_in_progress : 1;
+  unsigned char write_done : 1;
+  unsigned char _ : 4;
+};
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/sqlfilter.c

@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2021 Liquidaty and zsv contributors. All rights
+ * reserved.  This file is part of zsv/lib, distributed under the
+ * license defined at https://opensource.org/licenses/MIT
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include "../external/sqlite3/sqlite3.h"
+#include <zsv/ext/implementation.h>
+#include <zsv/ext/sheet.h>
+#include <zsv/utils/writer.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/prop.h>
+#include "file.h"
+#include "handlers_internal.h"
+#include "./curses.h"
+#include "../sql_internal.h"
+
+struct sqlfilter_data {
+  char *value_sql; // the sql expression entered by the user e.g. City
+  char *data_filename;
+};
+
+static void sqlfilter_data_delete(void *h) {
+  struct sqlfilter_data *pd = h;
+  if (pd) {
+    free(pd->value_sql);
+    free(pd->data_filename);
+    free(pd);
+  }
+}
+
+static struct sqlfilter_data *sqlfilter_data_new(const char *data_filename, const char *value_sql) {
+  struct sqlfilter_data *pd = calloc(1, sizeof(*pd));
+  if (pd && (pd->value_sql = strdup(value_sql)) && (pd->data_filename = strdup(data_filename)))
+    return pd;
+  sqlfilter_data_delete(pd);
+  return NULL;
+}
+
+static void zsvsheet_check_buffer_worker_updates(struct zsvsheet_ui_buffer *ub,
+                                                 struct zsvsheet_display_dimensions *display_dims,
+                                                 struct zsvsheet_sheet_context *handler_state);
+
+/**
+ * Here we define a custom command for the zsv `sheet` feature
+ */
+static zsvsheet_status zsvsheet_sqlfilter_handler(struct zsvsheet_proc_context *ctx) {
+  char result_buffer[256] = {0};
+  const char *expr;
+  zsvsheet_buffer_t buff = zsvsheet_buffer_current(ctx);
+  struct zsvsheet_buffer_data bd = zsvsheet_buffer_info(buff);
+  const char add_row_num = !bd.has_row_num;
+  const char *data_filename = NULL;
+  if (buff)
+    data_filename = zsvsheet_buffer_data_filename(buff);
+
+  if (!data_filename) { // TO DO: check that the underlying data is a tabular file and we know how to parse
+    zsvsheet_ui_buffer_set_status(buff, "SQL filter only available for tabular data buffers");
+    return zsvsheet_status_ok;
+  }
+
+  char *selected_cell_str_dup = NULL;
+  switch (ctx->proc_id) {
+  case zsvsheet_builtin_proc_sqlfilter:
+    zsvsheet_ext_prompt(ctx, result_buffer, sizeof(result_buffer), "Enter SQL expr to filter by");
+    if (*result_buffer == '\0')
+      return zsvsheet_status_ok;
+    expr = result_buffer;
+    break;
+  default:
+    assert(0);
+    return zsvsheet_status_error;
+  }
+
+  enum zsvsheet_status zst = zsvsheet_status_ok;
+  struct zsv_sqlite3_dbopts dbopts = {0};
+  struct zsv_opts zopts = zsvsheet_buffer_get_zsv_opts(buff);
+  struct zsv_sqlite3_db *zdb = zsv_sqlite3_db_new(&dbopts);
+  sqlite3_str *sql_str = NULL;
+  struct sqlfilter_data *sqlfd = NULL;
+  if (!zdb || !(sql_str = sqlite3_str_new(zdb->db)))
+    zst = zsvsheet_status_memory;
+  else if (zdb->rc == SQLITE_OK && zsv_sqlite3_add_csv_no_dq(zdb, data_filename, &zopts, NULL) == SQLITE_OK) {
+    int ok = 0;
+    const char *err_msg = NULL;
+    int err = 0;
+    if (is_constant_expression(zdb->db, expr, &err))
+      err_msg = "Please enter an expression that is not a constant";
+    else {
+      enum check_select_expression_result expr_rc = check_select_expression(zdb->db, expr, &err);
+      if (expr_rc != zsv_select_sql_expression_valid)
+        err_msg = check_select_expression_result_str(expr_rc);
+      else if (!err)
+        ok = 1;
+    }
+    if (!ok) {
+      if (err)
+        zsvsheet_ui_buffer_set_status(buff, strerror(err));
+      else if (err_msg)
+        zsvsheet_ui_buffer_set_status(buff, err_msg);
+      else
+        zsvsheet_ui_buffer_set_status(buff, "Unknown error");
+    } else {
+      if (add_row_num)
+        sqlite3_str_appendf(sql_str, "select ROWID as %Q, * from data where %s", ZSVSHEET_ROWNUM_HEADER, expr);
+      else
+        sqlite3_str_appendf(sql_str, "select * from data where %s", expr);
+
+      if (!(sqlfd = sqlfilter_data_new(data_filename, expr)))
+        zst = zsvsheet_status_memory;
+      else {
+        zst = zsv_sqlite3_to_csv(ctx, zdb, sqlite3_str_value(sql_str), &err_msg, sqlfd, NULL, NULL);
+        if (zst != zsvsheet_status_ok) {
+          if (zst == zsvsheet_status_no_data)
+            zsvsheet_ui_buffer_set_status(buff, "No results returned");
+          else
+            zsvsheet_ui_buffer_set_status(buff, err_msg ? err_msg : "Unexpected error preparing SQL");
+        } else {
+          buff = zsvsheet_buffer_current(ctx);
+          zsvsheet_buffer_set_ctx(buff, sqlfd, sqlfilter_data_delete);
+          sqlfd = NULL; // so that it isn't cleaned up below
+
+          while (!zsvsheet_ui_buffer_index_ready(buff, 0))
+            napms(200); // sleep for 200ms, then check index again
+          // TO DO: fix this if there is no data!
+
+          if (selected_cell_str_dup) {
+            struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
+            struct zsvsheet_display_info *di = &state->display_info;
+            zsvsheet_check_buffer_worker_updates(buff, di->dimensions, NULL);
+            zsvsheet_handle_find_next(di, buff, selected_cell_str_dup,
+                                      1, // find value in first column
+                                      1, // exact
+                                      1, // header_span
+                                      di->dimensions, &di->update_buffer, NULL);
+          }
+        }
+      }
+    }
+    // TO DO: add param to ext_sheet_open_file to set filename vs data_filename, and set buffer type or proc owner
+    // TO DO: add way to attach custom context, and custom context destructor, to the new buffer
+    // TO DO: add cell highlighting
+  }
+
+  zsv_sqlite3_db_delete(zdb);
+  if (sql_str)
+    sqlite3_free(sqlite3_str_finish(sql_str));
+  sqlfilter_data_delete(sqlfd);
+  free(selected_cell_str_dup);
+  return zst;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/terminfo.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+// check_or_set_terminfo: return 1 if ok, 0 if not
+static int terminfo_ok(void) {
+  // Check if TERMINFO environment variable is set
+  char *terminfo_env = getenv("TERMINFO");
+  if (terminfo_env != NULL)
+    return 1; // ok
+
+  // Check some default locations
+  const char *default_paths[] = {
+    "/usr/share/terminfo", "/lib/terminfo", "/usr/lib/terminfo", "/etc/terminfo", "/usr/local/share/terminfo", NULL};
+
+  for (int i = 0; default_paths[i] != NULL; i++) {
+    if (access(default_paths[i], R_OK) == 0) {
+      // Set the TERMINFO environment variable
+      if (setenv("TERMINFO", default_paths[i], 1) == 0)
+        return 1; // ok
+      else {
+        perror("Failed to set TERMINFO environment variable");
+        return 0;
+      }
+    }
+  }
+#if defined(WIN32) || defined(_WIN32)
+  return 1; // ok
+#endif
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/transformation.c

@@ -0,0 +1,312 @@
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/prop.h>
+
+#include "handlers_internal.h"
+#include "transformation.h"
+#include "../utils/index.h"
+
+struct zsvsheet_transformation {
+  zsv_parser parser;
+  zsv_csv_writer writer;
+  char *output_filename;
+  FILE *output_stream;
+  unsigned char *output_buffer;
+  int output_fileno;
+  char writer_wrote;
+  struct zsvsheet_transformation_opts opts;
+  void *user_context;
+
+  struct zsvsheet_ui_buffer *ui_buffer;
+  char *default_status;
+  void (*on_done)(zsvsheet_transformation trn);
+};
+
+static size_t transformation_write(const void *restrict ptr, size_t size, size_t nitems, void *restrict stream) {
+  struct zsvsheet_transformation *trn = stream;
+
+  const size_t count = fwrite(ptr, size, nitems, trn->output_stream);
+  trn->writer_wrote = count > 0;
+
+  return count > 0 ? count : 0;
+}
+
+struct transformation_writer_index_ctx {
+  void *index;
+  zsv_csv_writer writer;
+};
+
+static void transformation_writer_index_on_row(void *p) {
+  struct transformation_writer_index_ctx *ctx = p;
+  uint64_t written = zsv_writer_cum_bytes_written(ctx->writer);
+  zsv_index_add_row(ctx->index, written);
+}
+
+static void transformation_writer_index_delete(void *p) {
+  struct transformation_writer_index_ctx *ctx = p;
+  uint64_t written = zsv_writer_cum_bytes_written(ctx->writer);
+  if (written)
+    zsv_index_add_row(ctx->index, written);
+  free(ctx);
+}
+
+enum zsv_status zsvsheet_transformation_new(struct zsvsheet_transformation_opts opts, zsvsheet_transformation *out) {
+  unsigned char *temp_buff = NULL;
+  char *temp_filename = NULL;
+  FILE *temp_f = NULL;
+  zsv_csv_writer temp_file_writer = NULL;
+  struct transformation_writer_index_ctx *ctx = NULL;
+  enum zsv_status zst = zsv_status_memory;
+
+  struct zsvsheet_transformation *trn = calloc(1, sizeof(*trn));
+  if (trn == NULL)
+    return zst;
+
+  trn->on_done = opts.on_done;
+  trn->ui_buffer = opts.ui_buffer;
+  zst = zsv_status_error;
+
+  temp_filename = zsv_get_temp_filename("zsvsheet_filter_XXXXXXXX");
+  if (!temp_filename)
+    goto free;
+  trn->output_filename = temp_filename;
+
+  if (!(temp_f = fopen(temp_filename, "w+")))
+    goto free;
+  if (setvbuf(temp_f, NULL, _IONBF, 0))
+    goto free;
+  trn->output_stream = temp_f;
+
+  ctx = calloc(1, sizeof(*ctx));
+  if (!ctx)
+    goto free;
+  ctx->index = opts.index;
+
+  struct zsv_csv_writer_options writer_opts = {
+    .with_bom = 0,
+    .write = transformation_write,
+    .stream = trn,
+    .table_init = NULL,
+    .table_init_ctx = NULL,
+    .on_row = transformation_writer_index_on_row,
+    .on_row_ctx = ctx,
+    .on_delete = transformation_writer_index_delete,
+    .on_delete_ctx = ctx,
+  };
+  if (!(temp_file_writer = zsv_writer_new(&writer_opts)))
+    goto free;
+
+  ctx->writer = temp_file_writer;
+  const size_t temp_buff_size = 2 * 1024 * 1024;
+  temp_buff = malloc(temp_buff_size);
+  if (!temp_buff)
+    goto free;
+  trn->output_buffer = temp_buff;
+  zsv_writer_set_temp_buff(temp_file_writer, temp_buff, temp_buff_size);
+  trn->writer = temp_file_writer;
+
+  trn->user_context = opts.zsv_opts.ctx;
+  opts.zsv_opts.ctx = trn;
+
+  zst = zsv_new_with_properties(&opts.zsv_opts, opts.custom_prop_handler, opts.input_filename, &trn->parser);
+  if (zst != zsv_status_ok)
+    goto free;
+
+  *out = trn;
+  return zst;
+
+free:
+  if (trn)
+    free(trn);
+  if (temp_filename)
+    free(temp_filename);
+  if (temp_f)
+    fclose(temp_f);
+  if (temp_file_writer)
+    zsv_writer_delete(temp_file_writer);
+  if (temp_buff)
+    free(temp_buff);
+  if (ctx)
+    transformation_writer_index_delete(ctx);
+
+  return zst;
+}
+
+void zsvsheet_transformation_delete(zsvsheet_transformation trn) {
+  zsv_writer_delete(trn->writer);
+  zsv_delete(trn->parser);
+  free(trn->output_filename);
+  fclose(trn->output_stream);
+  free(trn->output_buffer);
+  free(trn);
+}
+
+zsv_parser zsvsheet_transformation_parser(zsvsheet_transformation trn) {
+  return trn->parser;
+}
+
+zsv_csv_writer zsvsheet_transformation_writer(zsvsheet_transformation trn) {
+  return trn->writer;
+}
+
+const char *zsvsheet_transformation_filename(zsvsheet_transformation trn) {
+  return trn->output_filename;
+}
+
+void *zsvsheet_transformation_user_context(zsvsheet_transformation trn) {
+  return trn->user_context;
+}
+
+static void *zsvsheet_run_buffer_transformation(void *arg) {
+  struct zsvsheet_transformation *trn = arg;
+  struct zsvsheet_ui_buffer *uib = trn->ui_buffer;
+  zsv_parser parser = trn->parser;
+  pthread_mutex_t *mutex = &uib->mutex;
+  enum zsv_status zst;
+  char *default_status = trn->default_status;
+
+  char cancelled = 0;
+  while (!cancelled && (zst = zsv_parse_more(parser)) == zsv_status_ok) {
+    pthread_mutex_lock(mutex);
+    cancelled = uib->worker_cancelled;
+    if (trn->writer_wrote) {
+      trn->writer_wrote = 0;
+      zsv_index_commit_rows(uib->index);
+      uib->index_ready = 1;
+    }
+    pthread_mutex_unlock(mutex);
+  }
+
+  if (zst == zsv_status_no_more_input || zst == zsv_status_cancelled)
+    zsv_finish(parser);
+
+  if (trn->on_done)
+    trn->on_done(trn);
+
+  if (trn->user_context)
+    free(trn->user_context);
+
+  zsvsheet_transformation_delete(trn);
+
+  pthread_mutex_lock(mutex);
+  char *buff_status_old = uib->status;
+  uib->write_done = 1;
+  zsv_index_commit_rows(uib->index);
+  uib->index_ready = 1;
+  if (buff_status_old == default_status)
+    uib->status = NULL;
+  pthread_mutex_unlock(mutex);
+
+  if (buff_status_old == default_status)
+    free(buff_status_old);
+
+  return NULL;
+}
+
+enum zsvsheet_status zsvsheet_push_transformation(zsvsheet_proc_context_t ctx,
+                                                  struct zsvsheet_buffer_transformation_opts opts) {
+  zsvsheet_buffer_t buff = zsvsheet_buffer_current(ctx);
+  const char *filename = zsvsheet_buffer_data_filename(buff);
+  enum zsvsheet_status stat = zsvsheet_status_error;
+  struct zsvsheet_buffer_info_internal info = zsvsheet_buffer_info_internal(buff);
+  struct zsv_index *index = NULL;
+
+  // TODO: Starting a second transformation before the first ends works, but if the second is faster
+  //       than the first then it can end prematurely and read a partially written row.
+  //       We could override the input stream reader to wait for more data when it sees EOF
+  if (info.write_in_progress && !info.write_done)
+    return zsvsheet_status_busy;
+
+  if (!(index = zsv_index_new()))
+    return zsvsheet_status_memory;
+
+  // TODO: custom_prop_handler is not passed to extensions?
+  struct zsvsheet_transformation_opts trn_opts = {
+    .custom_prop_handler = NULL,
+    .input_filename = filename,
+    .on_done = opts.on_done,
+    .ui_buffer = NULL,
+    .index = index,
+  };
+  zsvsheet_transformation trn = NULL;
+  struct zsv_opts zopts = zsvsheet_buffer_get_zsv_opts(buff);
+
+  zopts.ctx = opts.user_context;
+  zopts.row_handler = (void (*)(void *))opts.row_handler;
+  zopts.stream = fopen(filename, "rb");
+  zopts.buffsize = 2 * 1024 * 1024;
+
+  if (!zopts.stream)
+    goto error;
+
+  trn_opts.zsv_opts = zopts;
+
+  enum zsv_status zst = zsvsheet_transformation_new(trn_opts, &trn);
+  if (zst != zsv_status_ok)
+    goto error;
+
+  // Transform part of the file to initially populate the UI buffer
+  // TODO: If the transformation is a reduction that doesn't output for some time this will caus a pause
+  zsv_parser parser = zsvsheet_transformation_parser(trn);
+  while ((zst = zsv_parse_more(parser)) == zsv_status_ok) {
+    if (trn->writer_wrote)
+      break;
+  }
+  trn->writer_wrote = 0;
+
+  switch (zst) {
+  case zsv_status_no_more_input:
+  case zsv_status_cancelled:
+    if (zsv_finish(parser) != zsv_status_ok)
+      goto error;
+    zsv_writer_flush(trn->writer);
+    break;
+  case zsv_status_ok:
+    break;
+  default:
+    goto error;
+  }
+
+  struct zsvsheet_ui_buffer_opts uibopts = {0};
+
+  uibopts.data_filename = zsvsheet_transformation_filename(trn);
+  uibopts.write_after_open = 1;
+
+  stat = zsvsheet_open_file_opts(ctx, &uibopts);
+  if (stat != zsvsheet_status_ok)
+    goto error;
+
+  struct zsvsheet_ui_buffer *nbuff = zsvsheet_buffer_current(ctx);
+  trn->ui_buffer = nbuff;
+  zsv_index_commit_rows(index);
+  nbuff->index_started = 1;
+  nbuff->index = index;
+
+  if (zst != zsv_status_ok) {
+    nbuff->write_done = 1;
+    nbuff->index_ready = 1;
+    if (trn->on_done)
+      opts.on_done(trn);
+    zsvsheet_transformation_delete(trn);
+    zsv_index_commit_rows(index);
+    return stat;
+  }
+
+  asprintf(&trn->default_status, "(working) Press ESC to cancel ");
+  nbuff->status = trn->default_status;
+
+  zsvsheet_ui_buffer_create_worker(nbuff, zsvsheet_run_buffer_transformation, trn);
+  return stat;
+
+error:
+  zsv_index_delete(index);
+
+  if (trn && trn->on_done)
+    opts.on_done(trn);
+  if (trn)
+    zsvsheet_transformation_delete(trn);
+
+  return stat;
+}