tranfi 0.1.2 → 0.2.1

package/csrc/op_hash.c

@@ -25,9 +25,12 @@ static int hash_process(tf_step *self, tf_batch *in, tf_batch **out,
 
     tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
-    tf_batch_set_schema(ob, in->n_cols, "_hash", TF_TYPE_INT64);
+    const char *extra_names[] = {"_hash"};
+    const tf_type extra_types[] = {TF_TYPE_INT64};
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     /* Resolve column indices */
     size_t n_keys;
@@ -46,7 +49,11 @@ static int hash_process(tf_step *self, tf_batch *in, tf_batch **out,
     }
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            free(col_indices);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
         /* Compute hash */
         uint32_t h = 5381;
         char val_buf[64];
@@ -75,8 +82,16 @@ static int hash_process(tf_step *self, tf_batch *in, tf_batch **out,
             for (const unsigned char *p = (const unsigned char *)val; *p; p++)
                 h = ((h << 5) + h) ^ *p;
         }
-        tf_batch_set_int64(ob, r, in->n_cols, (int64_t)h);
-        ob->n_rows = r + 1;
+        if (tf_batch_set_int64(ob, r, in->n_cols, (int64_t)h) != TF_OK) {
+            free(col_indices);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            free(col_indices);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
     }
 
     free(col_indices);
@@ -88,12 +103,18 @@ static int hash_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
     (void)self; (void)side; *out = NULL; return TF_OK;
 }
 
-static void hash_destroy(tf_step *self) {
-    hash_state *st = self->state;
+static void hash_state_free(hash_state *st) {
     if (st) {
-        for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
-        free(st->cols); free(st);
+        if (st->cols) {
+            for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
+        }
+        free(st->cols);
+        free(st);
     }
+}
+
+static void hash_destroy(tf_step *self) {
+    hash_state_free(self ? self->state : NULL);
     free(self);
 }
 
@@ -103,21 +124,33 @@ tf_step *tf_hash_create(const cJSON *args) {
 
     if (args) {
         cJSON *columns = cJSON_GetObjectItemCaseSensitive(args, "columns");
-        if (columns && cJSON_IsArray(columns)) {
+        if (columns) {
+            if (!cJSON_IsArray(columns)) {
+                tf_set_last_error("hash: columns must be an array");
+                hash_state_free(st);
+                return NULL;
+            }
             int n = cJSON_GetArraySize(columns);
             if (n > 0) {
                 st->cols = calloc(n, sizeof(char *));
-                st->n_cols = n;
+                if (!st->cols) { hash_state_free(st); return NULL; }
+                st->n_cols = (size_t)n;
                 for (int i = 0; i < n; i++) {
                     cJSON *item = cJSON_GetArrayItem(columns, i);
-                    if (cJSON_IsString(item)) st->cols[i] = strdup(item->valuestring);
+                    if (!cJSON_IsString(item) || !item->valuestring || !item->valuestring[0]) {
+                        tf_set_last_error("hash: column names must be non-empty strings");
+                        hash_state_free(st);
+                        return NULL;
+                    }
+                    st->cols[i] = strdup(item->valuestring);
+                    if (!st->cols[i]) { hash_state_free(st); return NULL; }
                 }
             }
         }
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
-    if (!step) { hash_destroy(&(tf_step){.state = st}); return NULL; }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { hash_state_free(st); return NULL; }
     step->process = hash_process;
     step->flush = hash_flush;
     step->destroy = hash_destroy;

package/csrc/op_head.c

@@ -28,93 +28,27 @@ static int head_process(tf_step *self, tf_batch *in, tf_batch **out,
 
     size_t remaining = st->limit - st->seen;
     size_t take = in->n_rows < remaining ? in->n_rows : remaining;
+    if (take == 0) return TF_OK;
 
-    if (take == in->n_rows) {
-        /* Take all rows — create a copy */
-        tf_batch *ob = tf_batch_create(in->n_cols, take);
-        if (!ob) return TF_ERROR;
-        for (size_t c = 0; c < in->n_cols; c++) {
-            tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
-        }
-        for (size_t r = 0; r < take; r++) {
-            tf_batch_ensure_capacity(ob, r + 1);
-            for (size_t c = 0; c < in->n_cols; c++) {
-                if (tf_batch_is_null(in, r, c)) {
-                    tf_batch_set_null(ob, r, c);
-                    continue;
-                }
-                switch (in->col_types[c]) {
-                    case TF_TYPE_BOOL:
-                        tf_batch_set_bool(ob, r, c, tf_batch_get_bool(in, r, c));
-                        break;
-                    case TF_TYPE_INT64:
-                        tf_batch_set_int64(ob, r, c, tf_batch_get_int64(in, r, c));
-                        break;
-                    case TF_TYPE_FLOAT64:
-                        tf_batch_set_float64(ob, r, c, tf_batch_get_float64(in, r, c));
-                        break;
-                    case TF_TYPE_STRING:
-                        tf_batch_set_string(ob, r, c, tf_batch_get_string(in, r, c));
-                        break;
-                    case TF_TYPE_DATE:
-                        tf_batch_set_date(ob, r, c, tf_batch_get_date(in, r, c));
-                        break;
-                    case TF_TYPE_TIMESTAMP:
-                        tf_batch_set_timestamp(ob, r, c, tf_batch_get_timestamp(in, r, c));
-                        break;
-                    default:
-                        tf_batch_set_null(ob, r, c);
-                        break;
-                }
-            }
-            ob->n_rows = r + 1;
-        }
-        st->seen += take;
-        *out = ob;
-    } else {
-        /* Partial take — only copy first `take` rows */
-        tf_batch *ob = tf_batch_create(in->n_cols, take);
-        if (!ob) return TF_ERROR;
-        for (size_t c = 0; c < in->n_cols; c++) {
-            tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    tf_batch *ob = tf_batch_create(in->n_cols, take);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < take; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
         }
-        for (size_t r = 0; r < take; r++) {
-            tf_batch_ensure_capacity(ob, r + 1);
-            for (size_t c = 0; c < in->n_cols; c++) {
-                if (tf_batch_is_null(in, r, c)) {
-                    tf_batch_set_null(ob, r, c);
-                    continue;
-                }
-                switch (in->col_types[c]) {
-                    case TF_TYPE_BOOL:
-                        tf_batch_set_bool(ob, r, c, tf_batch_get_bool(in, r, c));
-                        break;
-                    case TF_TYPE_INT64:
-                        tf_batch_set_int64(ob, r, c, tf_batch_get_int64(in, r, c));
-                        break;
-                    case TF_TYPE_FLOAT64:
-                        tf_batch_set_float64(ob, r, c, tf_batch_get_float64(in, r, c));
-                        break;
-                    case TF_TYPE_STRING:
-                        tf_batch_set_string(ob, r, c, tf_batch_get_string(in, r, c));
-                        break;
-                    case TF_TYPE_DATE:
-                        tf_batch_set_date(ob, r, c, tf_batch_get_date(in, r, c));
-                        break;
-                    case TF_TYPE_TIMESTAMP:
-                        tf_batch_set_timestamp(ob, r, c, tf_batch_get_timestamp(in, r, c));
-                        break;
-                    default:
-                        tf_batch_set_null(ob, r, c);
-                        break;
-                }
-            }
-            ob->n_rows = r + 1;
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
         }
-        st->seen += take;
-        *out = ob;
     }
 
+    st->seen += take;
+    *out = ob;
     return TF_OK;
 }
 
@@ -131,15 +65,16 @@ static void head_destroy(tf_step *self) {
 
 tf_step *tf_head_create(const cJSON *args) {
     if (!args) return NULL;
-    cJSON *n_json = cJSON_GetObjectItemCaseSensitive(args, "n");
-    if (!cJSON_IsNumber(n_json) || n_json->valueint <= 0) return NULL;
+    size_t n = 0;
+    int has_n = tf_json_get_size_arg(args, "n", 0, TF_MAX_COUNT_ARG, &n, "head");
+    if (has_n <= 0) return NULL;
 
     head_state *st = calloc(1, sizeof(head_state));
     if (!st) return NULL;
-    st->limit = (size_t)n_json->valueint;
+    st->limit = n;
     st->seen = 0;
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) { free(st); return NULL; }
     step->process = head_process;
     step->flush = head_flush;

package/csrc/op_interpolate.c

@@ -20,6 +20,17 @@ typedef enum {
     INTERP_LINEAR
 } interp_method;
 
+typedef enum {
+    INTERP_MISSING_ERROR,
+    INTERP_MISSING_NULL,
+    INTERP_MISSING_IGNORE,
+} interp_missing_policy;
+
+typedef enum {
+    INTERP_TYPE_FAIL,
+    INTERP_TYPE_NULL,
+} interp_type_policy;
+
 /* Buffered row: we store complete batches and track which rows are pending */
 typedef struct pending_row {
     tf_batch *batch; /* single-row batch (copy of original row) */
@@ -31,47 +42,180 @@ typedef struct {
     interp_method  method;
     double         last_val;
     int            has_last;
+    interp_missing_policy missing;
+    interp_type_policy on_type_error;
     /* Pending null rows (for backward/linear) */
     pending_row   *pending;
     size_t         n_pending;
     size_t         cap_pending;
 } interpolate_state;
 
-static interp_method parse_method(const char *s) {
-    if (!s) return INTERP_LINEAR;
-    if (strcmp(s, "forward") == 0) return INTERP_FORWARD;
-    if (strcmp(s, "backward") == 0) return INTERP_BACKWARD;
-    return INTERP_LINEAR;
+static int parse_method(const char *s, interp_method *out) {
+    if (!s) { *out = INTERP_LINEAR; return TF_OK; }
+    if (strcmp(s, "forward") == 0) { *out = INTERP_FORWARD; return TF_OK; }
+    if (strcmp(s, "backward") == 0) { *out = INTERP_BACKWARD; return TF_OK; }
+    if (strcmp(s, "linear") == 0) { *out = INTERP_LINEAR; return TF_OK; }
+    return TF_ERROR;
+}
+
+static int interpolate_is_numeric_type(tf_type type) {
+    return type == TF_TYPE_INT64 || type == TF_TYPE_FLOAT64;
 }
 
-static double get_numeric(const tf_batch *b, size_t r, int ci) {
+static double interpolate_get_numeric(const tf_batch *b, size_t r, int ci) {
     if (b->col_types[ci] == TF_TYPE_INT64) return (double)tf_batch_get_int64(b, r, ci);
-    if (b->col_types[ci] == TF_TYPE_FLOAT64) return tf_batch_get_float64(b, r, ci);
-    return 0;
+    return tf_batch_get_float64(b, r, ci);
+}
+
+static int interpolate_set_numeric(tf_batch *b, size_t r, size_t ci, double val) {
+    if (b->col_types[ci] == TF_TYPE_INT64)
+        return tf_batch_set_int64(b, r, ci, (int64_t)val);
+    if (b->col_types[ci] == TF_TYPE_FLOAT64)
+        return tf_batch_set_float64(b, r, ci, val);
+    return TF_ERROR;
+}
+
+static void interpolate_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "interpolate: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int interpolate_parse_missing_policy(const cJSON *args, interp_missing_policy *out) {
+    *out = INTERP_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("interpolate: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = INTERP_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = INTERP_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = INTERP_MISSING_IGNORE;
+    else {
+        tf_set_last_error("interpolate: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int interpolate_parse_type_policy(const cJSON *args, interp_type_policy *out) {
+    *out = INTERP_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("interpolate: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = INTERP_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = INTERP_TYPE_NULL;
+    else {
+        tf_set_last_error("interpolate: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int interpolate_passthrough(tf_batch *in, tf_batch **out) {
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
+}
+
+static int interpolate_null_output(interpolate_state *st, tf_batch *in, int ci, tf_batch **out) {
+    size_t result_col = ci < 0 ? in->n_cols : (size_t)ci;
+    tf_batch *ob = NULL;
+    if (ci < 0) {
+        const char *extra_names[1] = {st->column};
+        tf_type extra_types[1] = {TF_TYPE_FLOAT64};
+        ob = tf_batch_create(in->n_cols + 1, in->n_rows);
+        if (!ob) return TF_ERROR;
+        if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    } else {
+        ob = tf_batch_create(in->n_cols, in->n_rows);
+        if (!ob) return TF_ERROR;
+        if (tf_batch_clone_schema(ob, in) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK ||
+            tf_batch_set_null(ob, r, result_col) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
 }
 
-static void add_pending(interpolate_state *st, tf_batch *row_batch, size_t target_col) {
-    if (st->n_pending >= st->cap_pending) {
-        size_t newcap = st->cap_pending ? st->cap_pending * 2 : 16;
-        pending_row *tmp = realloc(st->pending, newcap * sizeof(pending_row));
-        if (!tmp) return;
+static int add_pending(interpolate_state *st, tf_batch *row_batch, size_t target_col) {
+    size_t next_pending = 0;
+    if (tf_size_add(st->n_pending, 1, &next_pending) != TF_OK) return TF_ERROR;
+    if (next_pending > st->cap_pending) {
+        size_t newcap = 0;
+        if (tf_size_grow_pow2(st->cap_pending, next_pending, 16, &newcap) != TF_OK) {
+            return TF_ERROR;
+        }
+        pending_row *tmp = tf_reallocarray_checked(st->pending, newcap, sizeof(pending_row));
+        if (!tmp) return TF_ERROR;
         st->pending = tmp;
         st->cap_pending = newcap;
     }
     st->pending[st->n_pending].batch = row_batch;
     st->pending[st->n_pending].target_col = target_col;
-    st->n_pending++;
+    st->n_pending = next_pending;
+    return TF_OK;
+}
+
+static tf_batch *copy_single_row(const tf_batch *in, size_t row) {
+    tf_batch *row_copy = tf_batch_create(in->n_cols, 1);
+    if (!row_copy) return NULL;
+    if (tf_batch_clone_schema(row_copy, in) != TF_OK ||
+        tf_batch_copy_row(row_copy, 0, in, row) != TF_OK) {
+        tf_batch_free(row_copy);
+        return NULL;
+    }
+    if (tf_batch_expose_row(row_copy, 0) != TF_OK) {
+        tf_batch_free(row_copy);
+        return NULL;
+    }
+    return row_copy;
 }
 
 /* Emit all pending rows into output batch, interpolating values */
-static void flush_pending(interpolate_state *st, tf_batch *ob, size_t *out_row,
-                          double end_val, size_t target_col) {
-    if (st->n_pending == 0) return;
+static int flush_pending(interpolate_state *st, tf_batch *ob, size_t *out_row,
+                         double end_val, size_t target_col) {
+    if (st->n_pending == 0) return TF_OK;
 
     for (size_t i = 0; i < st->n_pending; i++) {
         tf_batch *pb = st->pending[i].batch;
         size_t r = *out_row;
-        tf_batch_copy_row(ob, r, pb, 0);
+        if (tf_batch_copy_row(ob, r, pb, 0) != TF_OK) return TF_ERROR;
 
         double interp_val;
         if (st->method == INTERP_BACKWARD) {
@@ -86,13 +230,17 @@ static void flush_pending(interpolate_state *st, tf_batch *ob, size_t *out_row,
             }
         }
 
-        tf_batch_set_float64(ob, r, target_col, interp_val);
-        ob->n_rows = r + 1;
+        if (interpolate_set_numeric(ob, r, target_col, interp_val) != TF_OK) return TF_ERROR;
+        if (tf_batch_expose_row(ob, r) != TF_OK) return TF_ERROR;
         (*out_row)++;
+    }
 
-        tf_batch_free(pb);
+    for (size_t i = 0; i < st->n_pending; i++) {
+        tf_batch_free(st->pending[i].batch);
+        st->pending[i].batch = NULL;
     }
     st->n_pending = 0;
+    return TF_OK;
 }
 
 static int interpolate_process(tf_step *self, tf_batch *in, tf_batch **out,
@@ -102,63 +250,94 @@ static int interpolate_process(tf_step *self, tf_batch *in, tf_batch **out,
     *out = NULL;
 
     int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == INTERP_MISSING_ERROR) {
+            interpolate_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == INTERP_MISSING_IGNORE) return interpolate_passthrough(in, out);
+        force_null = 1;
+    } else if (!interpolate_is_numeric_type(in->col_types[ci])) {
+        if (st->on_type_error == INTERP_TYPE_FAIL) {
+            interpolate_set_col_error(st->column, "must be numeric");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+    if (force_null) return interpolate_null_output(st, in, ci, out);
 
-    /* Count total rows we might output (pending + current batch) */
-    size_t max_rows = st->n_pending + in->n_rows;
+    size_t max_rows = 0;
+    if (tf_size_add(st->n_pending, in->n_rows, &max_rows) != TF_OK) return TF_ERROR;
     tf_batch *ob = tf_batch_create(in->n_cols, max_rows);
     if (!ob) return TF_ERROR;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
 
     size_t out_row = 0;
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        if (ci < 0) {
-            /* No target column — just pass through */
-            tf_batch_copy_row(ob, out_row, in, r);
-            ob->n_rows = out_row + 1;
-            out_row++;
-            continue;
-        }
-
         int is_null = tf_batch_is_null(in, r, ci);
 
         if (is_null) {
             if (st->method == INTERP_FORWARD && st->has_last) {
                 /* Forward fill: use last known value */
-                tf_batch_copy_row(ob, out_row, in, r);
-                tf_batch_set_float64(ob, out_row, ci, st->last_val);
-                ob->n_rows = out_row + 1;
+                if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK ||
+                    interpolate_set_numeric(ob, out_row, (size_t)ci, st->last_val) != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
+                if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
                 out_row++;
             } else if (st->method == INTERP_FORWARD) {
                 /* No previous value yet — pass null through */
-                tf_batch_copy_row(ob, out_row, in, r);
-                ob->n_rows = out_row + 1;
+                if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
+                if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
                 out_row++;
             } else {
                 /* Backward/linear: buffer this row */
-                tf_batch *row_copy = tf_batch_create(in->n_cols, 1);
-                if (row_copy) {
-                    for (size_t c = 0; c < in->n_cols; c++)
-                        tf_batch_set_schema(row_copy, c, in->col_names[c], in->col_types[c]);
-                    tf_batch_copy_row(row_copy, 0, in, r);
-                    row_copy->n_rows = 1;
-                    add_pending(st, row_copy, ci);
+                tf_batch *row_copy = copy_single_row(in, r);
+                if (!row_copy || add_pending(st, row_copy, (size_t)ci) != TF_OK) {
+                    tf_batch_free(row_copy);
+                    tf_batch_free(ob);
+                    return TF_ERROR;
                 }
             }
         } else {
-            double val = get_numeric(in, r, ci);
+            double val = interpolate_get_numeric(in, r, ci);
 
             /* Flush any pending rows */
             if (st->n_pending > 0) {
-                /* Grow output if needed */
-                tf_batch_ensure_capacity(ob, out_row + st->n_pending + 1);
-                flush_pending(st, ob, &out_row, val, ci);
+                size_t needed = 0;
+                if (tf_size_add(out_row, st->n_pending, &needed) != TF_OK ||
+                    tf_size_add(needed, 1, &needed) != TF_OK ||
+                    tf_batch_ensure_capacity(ob, needed) != TF_OK ||
+                    flush_pending(st, ob, &out_row, val, (size_t)ci) != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
             }
 
             /* Output current row */
-            tf_batch_copy_row(ob, out_row, in, r);
-            ob->n_rows = out_row + 1;
+            if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
             out_row++;
 
             st->last_val = val;
@@ -184,19 +363,31 @@ static int interpolate_flush(tf_step *self, tf_batch **out, tf_side_channels *si
     if (st->n_pending > 0) {
         tf_batch *first = st->pending[0].batch;
         tf_batch *ob = tf_batch_create(first->n_cols, st->n_pending);
-        if (!ob) return TF_OK;
-        for (size_t c = 0; c < first->n_cols; c++)
-            tf_batch_set_schema(ob, c, first->col_names[c], first->col_types[c]);
+        if (!ob) return TF_ERROR;
+        if (tf_batch_clone_schema(ob, first) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
 
         for (size_t i = 0; i < st->n_pending; i++) {
             tf_batch *pb = st->pending[i].batch;
-            tf_batch_copy_row(ob, i, pb, 0);
+            if (tf_batch_copy_row(ob, i, pb, 0) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
             /* For linear/backward at end of stream: use last known if available */
-            if (st->has_last) {
-                tf_batch_set_float64(ob, i, st->pending[i].target_col, st->last_val);
+            if (st->has_last && interpolate_set_numeric(ob, i, st->pending[i].target_col, st->last_val) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_expose_row(ob, i) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
             }
-            ob->n_rows = i + 1;
-            tf_batch_free(pb);
+        }
+        for (size_t i = 0; i < st->n_pending; i++) {
+            tf_batch_free(st->pending[i].batch);
+            st->pending[i].batch = NULL;
         }
         st->n_pending = 0;
         *out = ob;
@@ -220,16 +411,31 @@ static void interpolate_destroy(tf_step *self) {
 tf_step *tf_interpolate_create(const cJSON *args) {
     if (!args) return NULL;
     cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
-    if (!cJSON_IsString(col_j)) return NULL;
+    if (!cJSON_IsString(col_j) || !col_j->valuestring[0]) {
+        tf_set_last_error("interpolate: column is required");
+        return NULL;
+    }
 
     interpolate_state *st = calloc(1, sizeof(interpolate_state));
     if (!st) return NULL;
     st->column = strdup(col_j->valuestring);
+    if (!st->column) { free(st); return NULL; }
 
     cJSON *method_j = cJSON_GetObjectItemCaseSensitive(args, "method");
-    st->method = parse_method(cJSON_IsString(method_j) ? method_j->valuestring : NULL);
+    if (parse_method(cJSON_IsString(method_j) ? method_j->valuestring : NULL, &st->method) != TF_OK) {
+        tf_set_last_error("interpolate: method must be forward, backward, or linear");
+        free(st->column);
+        free(st);
+        return NULL;
+    }
+    if (interpolate_parse_missing_policy(args, &st->missing) != TF_OK ||
+        interpolate_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) { free(st->column); free(st); return NULL; }
     step->process = interpolate_process;
     step->flush = interpolate_flush;