tranfi 0.1.2 → 0.2.0

package/csrc/recipes.c

@@ -1,5 +1,5 @@
 /*
- * recipes.c — Built-in named recipes (20 common ETL pipelines).
+ * recipes.c — Built-in named recipes for common ETL pipelines.
  */
 
 #include "recipes.h"
@@ -20,6 +20,8 @@ static const recipe_entry recipes[] = {
      "Quick preview of first 10 rows"},
     {"schema",      "csv | head 0 | csv",
      "Show column names only"},
+    {"sniff",       "csv | schema infer rows=1000 | csv",
+     "Bounded-memory schema/type/nullability sniff (sample 1000 rows)"},
     {"summary",     "csv | stats count,min,max,avg,stddev | csv",
      "Summary statistics"},
     {"count",       "csv | stats count | csv",

package/csrc/report.c

@@ -6,6 +6,7 @@
  */
 
 #include "report.h"
+#include "internal.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@@ -27,41 +28,68 @@ typedef struct {
   char  *data;
   size_t len;
   size_t cap;
+  int    failed;
 } strbuf;
 
 static void sb_init(strbuf *sb) {
   sb->cap = 4096;
-  sb->data = malloc(sb->cap);
   sb->len = 0;
-  if (sb->data) sb->data[0] = '\0';
+  sb->failed = 0;
+  sb->data = tf_mallocarray_checked(sb->cap, sizeof(char));
+  if (sb->data) {
+    sb->data[0] = '\0';
+  } else {
+    sb->cap = 0;
+    sb->failed = 1;
+  }
 }
 
-static void sb_ensure(strbuf *sb, size_t extra) {
-  if (sb->len + extra + 1 > sb->cap) {
-    while (sb->len + extra + 1 > sb->cap) sb->cap *= 2;
-    sb->data = realloc(sb->data, sb->cap);
+static int sb_ensure(strbuf *sb, size_t extra) {
+  if (!sb || sb->failed) return -1;
+  size_t need;
+  if (tf_size_add(sb->len, extra, &need) != TF_OK ||
+      tf_size_add(need, 1, &need) != TF_OK) {
+    sb->failed = 1;
+    return -1;
+  }
+  if (need <= sb->cap) return 0;
+  size_t new_cap;
+  if (tf_size_grow_pow2(sb->cap, need, 4096, &new_cap) != TF_OK) {
+    sb->failed = 1;
+    return -1;
+  }
+  char *tmp = tf_reallocarray_checked(sb->data, new_cap, sizeof(char));
+  if (!tmp) {
+    sb->failed = 1;
+    return -1;
   }
+  sb->data = tmp;
+  sb->cap = new_cap;
+  return 0;
 }
 
 static void sb_append(strbuf *sb, const char *s) {
+  if (!sb || sb->failed || !s) return;
   size_t n = strlen(s);
-  sb_ensure(sb, n);
+  if (sb_ensure(sb, n) != 0) return;
   memcpy(sb->data + sb->len, s, n);
   sb->len += n;
   sb->data[sb->len] = '\0';
 }
 
 static void sb_printf(strbuf *sb, const char *fmt, ...) {
+  if (!sb || sb->failed || !fmt) return;
   va_list ap;
   va_start(ap, fmt);
   int needed = vsnprintf(NULL, 0, fmt, ap);
   va_end(ap);
-  if (needed < 0) return;
-  sb_ensure(sb, (size_t)needed);
+  if (needed < 0) { sb->failed = 1; return; }
+  if (sb_ensure(sb, (size_t)needed) != 0) return;
   va_start(ap, fmt);
-  vsnprintf(sb->data + sb->len, (size_t)needed + 1, fmt, ap);
+  int written = vsnprintf(sb->data + sb->len, (size_t)needed + 1, fmt, ap);
   va_end(ap);
-  sb->len += (size_t)needed;
+  if (written < 0 || written > needed) { sb->failed = 1; return; }
+  sb->len += (size_t)written;
 }
 
 /* ---- Sparkline ---- */
@@ -90,6 +118,17 @@ typedef struct {
   size_t  n_rows;
 } csv_table;
 
+static void csv_free(csv_table *t);
+
+static char *csv_field_copy(const char *start, size_t len) {
+  if (len > MAX_FIELD - 1) len = MAX_FIELD - 1;
+  char *field = tf_mallocarray_checked(len + 1, sizeof(char));
+  if (!field) return NULL;
+  if (len > 0) memcpy(field, start, len);
+  field[len] = '\0';
+  return field;
+}
+
 /* Find column index by name, -1 if not found */
 static int csv_col(const csv_table *t, const char *name) {
   for (size_t i = 0; i < t->n_cols; i++) {
@@ -99,9 +138,9 @@ static int csv_col(const csv_table *t, const char *name) {
   return -1;
 }
 
-/* Parse a simple CSV (no quoted fields with embedded commas needed for stats) */
+/* Parse the bounded stats CSV format, including quoted comma-containing fields. */
 static csv_table *csv_parse(const char *csv, size_t len) {
-  csv_table *t = calloc(1, sizeof(csv_table));
+  csv_table *t = tf_callocarray_checked(1, sizeof(csv_table));
   if (!t) return NULL;
 
   const char *p = csv;
@@ -112,13 +151,13 @@ static csv_table *csv_parse(const char *csv, size_t len) {
     const char *start = p;
     while (p < end && *p != ',' && *p != '\n' && *p != '\r') p++;
     size_t flen = (size_t)(p - start);
-    if (flen > MAX_FIELD - 1) flen = MAX_FIELD - 1;
     if (t->n_cols < MAX_COLS) {
-      t->headers[t->n_cols] = malloc(flen + 1);
-      if (t->headers[t->n_cols]) {
-        memcpy(t->headers[t->n_cols], start, flen);
-        t->headers[t->n_cols][flen] = '\0';
+      char *field = csv_field_copy(start, flen);
+      if (!field) {
+        csv_free(t);
+        return NULL;
       }
+      t->headers[t->n_cols] = field;
       t->n_cols++;
     }
     if (p < end && *p == ',') p++;
@@ -139,13 +178,13 @@ static csv_table *csv_parse(const char *csv, size_t len) {
         start = p;
         while (p < end && *p != '"') p++;
         size_t flen = (size_t)(p - start);
-        if (flen > MAX_FIELD - 1) flen = MAX_FIELD - 1;
         if (ci < MAX_COLS) {
-          t->cells[t->n_rows][ci] = malloc(flen + 1);
-          if (t->cells[t->n_rows][ci]) {
-            memcpy(t->cells[t->n_rows][ci], start, flen);
-            t->cells[t->n_rows][ci][flen] = '\0';
+          char *field = csv_field_copy(start, flen);
+          if (!field) {
+            csv_free(t);
+            return NULL;
           }
+          t->cells[t->n_rows][ci] = field;
         }
         if (p < end && *p == '"') p++; /* skip closing quote */
         if (p < end && *p == ',') p++;
@@ -154,13 +193,13 @@ static csv_table *csv_parse(const char *csv, size_t len) {
       }
       while (p < end && *p != ',' && *p != '\n' && *p != '\r') p++;
       size_t flen = (size_t)(p - start);
-      if (flen > MAX_FIELD - 1) flen = MAX_FIELD - 1;
       if (ci < MAX_COLS) {
-        t->cells[t->n_rows][ci] = malloc(flen + 1);
-        if (t->cells[t->n_rows][ci]) {
-          memcpy(t->cells[t->n_rows][ci], start, flen);
-          t->cells[t->n_rows][ci][flen] = '\0';
+        char *field = csv_field_copy(start, flen);
+        if (!field) {
+          csv_free(t);
+          return NULL;
         }
+        t->cells[t->n_rows][ci] = field;
       }
       if (p < end && *p == ',') p++;
       ci++;
@@ -176,7 +215,7 @@ static csv_table *csv_parse(const char *csv, size_t len) {
 static void csv_free(csv_table *t) {
   if (!t) return;
   for (size_t i = 0; i < t->n_cols; i++) free(t->headers[i]);
-  for (size_t r = 0; r < t->n_rows; r++)
+  for (size_t r = 0; r < MAX_ROWS; r++)
     for (size_t c = 0; c < t->n_cols; c++)
       free(t->cells[r][c]);
   free(t);
@@ -293,7 +332,7 @@ char *tf_report_format(const char *stats_csv, size_t stats_len, int use_color) {
 
   strbuf sb;
   sb_init(&sb);
-  if (!sb.data) { csv_free(t); return NULL; }
+  if (sb.failed) { csv_free(t); return NULL; }
 
   /* Header */
   long long total_count = 0;
@@ -459,5 +498,9 @@ char *tf_report_format(const char *stats_csv, size_t stats_len, int use_color) {
 
   csv_free(t);
 
+  if (sb.failed) {
+    free(sb.data);
+    return NULL;
+  }
   return sb.data;
 }