zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/compare.h

@@ -0,0 +1,23 @@
+#ifndef ZSV_COMPARE_H
+#define ZSV_COMPARE_H
+
+// public
+enum zsv_compare_status {
+  zsv_compare_status_ok = 0,
+  zsv_compare_status_memory,
+  zsv_compare_status_no_data,
+  zsv_compare_status_no_more_input = 100,
+  zsv_compare_status_error = 199
+};
+
+typedef struct zsv_compare_data *zsv_compare_handle;
+
+typedef int (*zsv_compare_cell_func)(void *ctx, struct zsv_cell, struct zsv_cell, void *struct_zsv_compare_data,
+                                     unsigned input_col_ix);
+
+zsv_compare_handle zsv_compare_new(void);
+void zsv_compare_set_input_parser(zsv_compare_handle cmp, zsv_parser p, unsigned ix);
+void zsv_compare_delete(zsv_compare_handle);
+void zsv_compare_set_comparison(zsv_compare_handle, zsv_compare_cell_func, void *);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/compare_added_column.c

@@ -0,0 +1,20 @@
+static struct zsv_compare_added_column **zsv_compare_added_column_add(struct zsv_compare_added_column **next,
+                                                                      struct zsv_compare_unique_colname *added_colname,
+                                                                      enum zsv_compare_status *stat) {
+  struct zsv_compare_added_column *e = calloc(1, sizeof(*e));
+  if (!e)
+    *stat = zsv_compare_status_memory;
+  else {
+    e->colname = added_colname;
+    *next = e;
+    return &e->next;
+  }
+  return next;
+}
+
+static void zsv_compare_added_column_delete(struct zsv_compare_added_column *e) {
+  for (struct zsv_compare_added_column *next; e; e = next) {
+    next = e->next;
+    free(e);
+  }
+}

data/ext/zsv/vendor/zsv-1.3.0/app/compare_internal.h

@@ -0,0 +1,140 @@
+#ifndef ZSV_COMPARE_PRIVATE_H
+#define ZSV_COMPARE_PRIVATE_H
+
+#include <sglib.h>
+#include <sqlite3.h>
+
+typedef struct zsv_compare_unique_colname {
+  struct zsv_compare_unique_colname *next; // retain order via linked list
+
+  // name and instance_num must be unique
+  unsigned char *name;
+  size_t name_len;
+  unsigned instance_num;
+
+  // keep track of how many instances we've seen in total
+  unsigned total_instances; // only applies if instance_num == 0
+
+  unsigned output_ix; // only used for output columns
+
+  struct zsv_compare_unique_colname *left;
+  struct zsv_compare_unique_colname *right;
+  unsigned char color;
+  unsigned char is_key;
+} zsv_compare_unique_colname;
+
+SGLIB_DEFINE_RBTREE_PROTOTYPES(zsv_compare_unique_colname, left, right, color, zsv_compare_unique_colname_cmp);
+static void zsv_compare_unique_colnames_delete(zsv_compare_unique_colname **tree);
+
+struct zsv_compare_input_key {
+  struct zsv_compare_key *key;
+  struct zsv_cell value;
+  unsigned col_ix;
+  unsigned char found;
+  unsigned char is_key;
+};
+
+struct zsv_compare_input {
+  const char *path;
+  FILE *stream;
+  zsv_parser parser;
+  zsv_compare_unique_colname *colnames;
+  unsigned index; // order in which this input was added
+
+  unsigned col_count;
+  unsigned *out2in; // out2in[output column ix] = input column ix + 1 (zero for no match)
+  zsv_compare_unique_colname **output_colnames;
+
+  unsigned key_count;
+  struct zsv_compare_input_key *keys;
+
+  sqlite3_stmt *sort_stmt;
+
+  unsigned char row_loaded : 1;
+  unsigned char missing : 1;
+  unsigned char done : 1;
+  unsigned char added : 1;
+  unsigned char _ : 4;
+};
+
+struct zsv_compare_key {
+  struct zsv_compare_key *next;
+  const char *name;
+  unsigned position_plus_1; // position can be specified in lieu of name
+};
+
+struct zsv_compare_added_column {
+  struct zsv_compare_added_column *next;
+  struct zsv_compare_unique_colname *colname;
+  struct zsv_compare_unique_colname *output_colname;
+  struct zsv_compare_input *input;
+  unsigned col_ix; // index of column in input from which to extract this value
+};
+
+struct zsv_compare_data {
+  enum zsv_compare_status status;
+  unsigned input_count; // number of allocated compare_input structs
+  struct zsv_compare_input *inputs;
+  struct zsv_compare_input **inputs_to_sort;
+
+  unsigned key_count;
+  struct zsv_compare_key *keys;
+  unsigned char *combined_key_names;
+
+  size_t row_count; // only matters if no ID columns are specified
+
+  unsigned output_colcount;
+  zsv_compare_unique_colname *output_colnames; // tree
+  zsv_compare_unique_colname **output_colnames_next;
+  zsv_compare_unique_colname *output_colnames_first; // linked list
+
+  struct zsv_compare_added_column *added_columns;
+  zsv_compare_unique_colname *added_colnames;
+  unsigned added_colcount;
+  int diff_count; // total number of differences; will use this as return code if -e option is specified
+
+  zsv_compare_cell_func cmp;
+  void *cmp_ctx;
+
+  enum zsv_status (*next_row)(struct zsv_compare_input *input);
+  struct zsv_cell (*get_cell)(struct zsv_compare_input *input, unsigned ix);
+  struct zsv_cell (*get_column_name)(struct zsv_compare_input *input, unsigned ix);
+  unsigned (*get_column_count)(struct zsv_compare_input *input);
+  enum zsv_compare_status (*input_init)(struct zsv_compare_data *data, struct zsv_compare_input *input,
+                                        struct zsv_opts *opts, struct zsv_prop_handler *custom_prop_handler);
+
+  sqlite3 *sort_db; // used when --sort option was specified
+
+  struct {
+    double value;
+#define ZSV_COMPARE_MAX_NUMBER_BUFF_LEN 128
+    char str1[ZSV_COMPARE_MAX_NUMBER_BUFF_LEN];
+    char str2[ZSV_COMPARE_MAX_NUMBER_BUFF_LEN];
+  } tolerance;
+  struct {
+    char type; // 'j' for json
+    union {
+      zsv_csv_writer csv;
+      jsonwriter_handle jsw;
+    } handle;
+
+    struct {
+      unsigned used;
+      unsigned allocated;
+      char **names;
+    } properties;
+
+    unsigned cell_ix;          // only used for json + object output
+    unsigned char compact : 1; // whether to output compact JSON
+    unsigned char object : 1;  // whether to output JSON as objects
+    unsigned char _ : 6;
+  } writer;
+
+  unsigned char sort : 1;
+  unsigned char sort_in_memory : 1;
+  unsigned char print_key_col_names : 1;
+  unsigned char return_count : 1;
+  unsigned char _ : 4;
+};
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/compare_sort.c

@@ -0,0 +1,91 @@
+/**
+ * To implement sorting, we will use sqlite, create a table for each CSV file and run "select * order by ..."
+ */
+
+#include "external/sqlite3/sqlite3_csv_vtab-mem.h"
+
+static int zsv_compare_sort_prep_table(struct zsv_compare_data *data, const char *fname, char **err_msg,
+                                       unsigned int table_ix) {
+#define ZSV_COMPARE_MAX_TABLES 1000
+  char *sql = NULL;
+  if (table_ix > ZSV_COMPARE_MAX_TABLES)
+    return -1;
+
+  sql = sqlite3_mprintf("CREATE VIRTUAL TABLE data%i USING csv(filename=%Q)", table_ix, fname);
+
+  if (!sql)
+    return -1;
+
+  int rc = sqlite3_exec(data->sort_db, sql, NULL, NULL, err_msg);
+  sqlite3_free(sql);
+  return rc;
+}
+
+static int zsv_compare_sort_stmt_prep(sqlite3 *db, sqlite3_stmt **stmtp, struct zsv_compare_key *keys, unsigned ix) {
+  sqlite3_str *select_clause = sqlite3_str_new(db);
+  if (!select_clause) {
+    fprintf(stderr, "Out of memory!\n");
+    return -1;
+  }
+
+  sqlite3_str_appendf(select_clause, "select * from data%i order by ", ix);
+  for (struct zsv_compare_key *key = keys; key; key = key->next)
+    sqlite3_str_appendf(select_clause, "%s\"%w\"", key == keys ? "" : ", ", key->name);
+
+  int rc = sqlite3_prepare_v2(db, sqlite3_str_value(select_clause), -1, stmtp, NULL);
+  if (rc != SQLITE_OK)
+    fprintf(stderr, "%s: %s\n", sqlite3_errstr(rc), sqlite3_str_value(select_clause));
+  sqlite3_free(sqlite3_str_finish(select_clause));
+  return rc;
+}
+
+static enum zsv_compare_status input_init_sorted(struct zsv_compare_data *data, struct zsv_compare_input *input,
+                                                 struct zsv_opts *opts, struct zsv_prop_handler *custom_prop_handler) {
+  char *err_msg = NULL;
+  if (!sqlite3_zsv_list_add(input->path, opts, custom_prop_handler))
+    input->added = 1;
+  int rc = zsv_compare_sort_prep_table(data, input->path, &err_msg, input->index);
+
+  if (err_msg) {
+    fprintf(stderr, "%s\n", err_msg);
+    sqlite3_free(err_msg);
+  }
+  if (rc == SQLITE_OK)
+    rc = zsv_compare_sort_stmt_prep(data->sort_db, &input->sort_stmt, data->keys, input->index);
+  return rc == SQLITE_OK ? zsv_compare_status_ok : zsv_compare_status_error;
+}
+
+static enum zsv_status zsv_compare_next_sorted_row(struct zsv_compare_input *input) {
+  if (sqlite3_step(input->sort_stmt) == SQLITE_ROW)
+    return zsv_status_row;
+
+  // to do: check if error; if so return zsv_status_error
+  return zsv_status_done;
+}
+
+static struct zsv_cell zsv_compare_get_sorted_colname(struct zsv_compare_input *input, unsigned ix) {
+  struct zsv_cell c = {
+    .str = (unsigned char *)sqlite3_column_name(input->sort_stmt, (int)ix),
+    .quoted = 1,
+  };
+  c.len = c.str ? strlen((const char *)c.str) : 0;
+  return c;
+}
+
+static unsigned zsv_compare_get_sorted_colcount(struct zsv_compare_input *input) {
+  int col_count = sqlite3_column_count(input->sort_stmt);
+  if (col_count >= 0)
+    return (unsigned)col_count;
+  return 0;
+}
+
+static struct zsv_cell zsv_compare_get_sorted_cell(struct zsv_compare_input *input, unsigned ix) {
+  struct zsv_cell c = {
+    .str = (unsigned char *)sqlite3_column_text(input->sort_stmt, (int)ix),
+    .quoted = 1,
+  };
+  c.len = c.str ? sqlite3_column_bytes(input->sort_stmt, (int)ix) : 0;
+  if (c.len)
+    c.str = (unsigned char *)zsv_strtrim(c.str, &c.len);
+  return c;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/compare_unique_colname.c

@@ -0,0 +1,81 @@
+static int zsv_compare_unique_colname_cmp(zsv_compare_unique_colname *x, zsv_compare_unique_colname *y) {
+  return x->instance_num == y->instance_num  ? zsv_stricmp(x->name, y->name)
+         : x->instance_num > y->instance_num ? 1
+         : x->instance_num < y->instance_num ? -1
+                                             : 0;
+}
+
+SGLIB_DEFINE_RBTREE_FUNCTIONS(zsv_compare_unique_colname, left, right, color, zsv_compare_unique_colname_cmp);
+
+static void zsv_compare_unique_colname_delete(zsv_compare_unique_colname *e) {
+  if (e)
+    free(e->name);
+  free(e);
+}
+
+static void zsv_compare_unique_colnames_delete(zsv_compare_unique_colname **tree) {
+  if (tree && *tree) {
+    struct sglib_zsv_compare_unique_colname_iterator it;
+    struct zsv_compare_unique_colname *e;
+    for (e = sglib_zsv_compare_unique_colname_it_init(&it, *tree); e; e = sglib_zsv_compare_unique_colname_it_next(&it))
+      zsv_compare_unique_colname_delete(e);
+    *tree = NULL;
+  }
+}
+
+static struct zsv_compare_unique_colname *zsv_compare_unique_colname_new(const unsigned char *name, size_t len,
+                                                                         unsigned instance_num) {
+  zsv_compare_unique_colname *col = calloc(1, sizeof(*col));
+  if (!col || !(col->name = malloc(len + 1)))
+    ; // handle out-of-memory error!
+  else {
+    memcpy(col->name, name, len);
+    col->name[len] = '\0';
+    col->name_len = len;
+    col->instance_num = instance_num;
+  }
+  return col;
+}
+
+// zsv_desc_column_update_unique(): return 1 if unique, 0 if dupe
+static zsv_compare_unique_colname *zsv_compare_unique_colname_add_if_not_found(struct zsv_compare_unique_colname **tree,
+                                                                               const unsigned char *utf8_value,
+                                                                               size_t len, unsigned instance_num,
+                                                                               int *added) {
+  *added = 0;
+  zsv_compare_unique_colname *col = zsv_compare_unique_colname_new(utf8_value, len, instance_num);
+  zsv_compare_unique_colname *found = sglib_zsv_compare_unique_colname_find_member(*tree, col);
+  if (found) // not unique
+    zsv_compare_unique_colname_delete(col);
+  else {
+    sglib_zsv_compare_unique_colname_add(tree, col);
+    *added = 1;
+    found = col;
+  }
+  return found;
+}
+
+// add a colname to a list. allow duplicate names, but track instances
+// separately (i.e.
+static enum zsv_compare_status zsv_compare_unique_colname_add(zsv_compare_unique_colname **tree, const unsigned char *s,
+                                                              unsigned len, zsv_compare_unique_colname **new_col) {
+  int added = 0;
+  unsigned instance_num = 0;
+  zsv_compare_unique_colname *_new_col =
+    zsv_compare_unique_colname_add_if_not_found(tree, s, len, instance_num, &added);
+  if (!_new_col)
+    return zsv_compare_status_error;
+
+  if (!added) { // we've seen this column before in this input
+    instance_num = ++_new_col->total_instances;
+    _new_col = zsv_compare_unique_colname_add_if_not_found(tree, s, len, instance_num, &added);
+    if (!added) { // should not happen
+#ifndef NDEBUG
+      fprintf(stderr, "Unexpected error! %s: %i\n", __FILE__, __LINE__);
+#endif
+      return zsv_compare_status_error;
+    }
+  }
+  *new_col = _new_col;
+  return zsv_compare_status_ok;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/count-pull.c

@@ -0,0 +1,82 @@
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define ZSV_COMMAND count_pull
+#include "zsv_command.h"
+
+static int count_usage(void) {
+  static const char *usage = "Usage: count [options]\n"
+                             "\n"
+                             "Options:\n"
+                             "  -h,--help              : show usage\n"
+                             "  -i,--input <filename>  : use specified file input\n";
+  printf("%s\n", usage);
+  return 0;
+}
+
+int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *opts,
+                               struct zsv_prop_handler *custom_prop_handler) {
+  const char *input_path = NULL;
+  int err = 0;
+  for (int i = 1; !err && i < argc; i++) {
+    const char *arg = argv[i];
+    if (!strcmp(arg, "-h") || !strcmp(arg, "--help")) {
+      count_usage();
+      goto count_done;
+    }
+    if (!strcmp(arg, "-i") || !strcmp(arg, "--input") || *arg != '-') {
+      err = 1;
+      if ((!strcmp(arg, "-i") || !strcmp(arg, "--input")) && ++i >= argc)
+        fprintf(stderr, "%s option requires a filename\n", arg);
+      else {
+        if (opts->stream)
+          fprintf(stderr, "Input may not be specified more than once\n");
+        else if (!(opts->stream = fopen(argv[i], "rb")))
+          fprintf(stderr, "Unable to open for reading: %s\n", argv[i]);
+        else {
+          input_path = argv[i];
+          err = 0;
+        }
+      }
+    } else {
+      fprintf(stderr, "Unrecognized option: %s\n", arg);
+      err = 1;
+    }
+  }
+
+#ifdef NO_STDIN
+  if (!opts->stream || opts->stream == stdin) {
+    fprintf(stderr, "Please specify an input file\n");
+    err = 1;
+  }
+#endif
+
+  if (!err) {
+    zsv_parser parser;
+    if (zsv_new_with_properties(opts, custom_prop_handler, input_path, &parser) != zsv_status_ok) {
+      fprintf(stderr, "Unable to initialize parser\n");
+      err = 1;
+    } else {
+      size_t count = 0;
+      while (zsv_next_row(parser) == zsv_status_row)
+        count++;
+      zsv_delete(parser);
+      printf("%zu\n", count > 0 ? count - 1 : 0);
+    }
+  }
+
+count_done:
+  if (opts->stream && opts->stream != stdin)
+    fclose(opts->stream);
+
+  return err;
+}