tranfi 0.1.2 → 0.2.1

package/csrc/op_datetime.c

@@ -13,9 +13,22 @@
 #include <string.h>
 #include <stdio.h>
 
+typedef enum {
+    DATETIME_MISSING_ERROR,
+    DATETIME_MISSING_NULL,
+    DATETIME_MISSING_IGNORE,
+} datetime_missing_policy;
+
+typedef enum {
+    DATETIME_TYPE_FAIL,
+    DATETIME_TYPE_NULL,
+} datetime_type_policy;
+
 typedef struct {
     char  *column;
     int    w_year, w_month, w_day, w_hour, w_minute, w_second, w_weekday, w_epoch;
+    datetime_missing_policy missing;
+    datetime_type_policy on_type_error;
 } datetime_state;
 
 /* Days in each month (non-leap) */
@@ -82,78 +95,212 @@ static int parse_date(const char *s, int *y, int *mo, int *d, int *h, int *mi, i
     return n >= 3;
 }
 
+static int datetime_is_temporal_type(tf_type type) {
+    return type == TF_TYPE_STRING || type == TF_TYPE_DATE || type == TF_TYPE_TIMESTAMP;
+}
+
+static void datetime_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "datetime: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int datetime_parse_missing_policy(const cJSON *args, datetime_missing_policy *out) {
+    *out = DATETIME_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("datetime: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = DATETIME_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DATETIME_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = DATETIME_MISSING_IGNORE;
+    else {
+        tf_set_last_error("datetime: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int datetime_parse_type_policy(const cJSON *args, datetime_type_policy *out) {
+    *out = DATETIME_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("datetime: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = DATETIME_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DATETIME_TYPE_NULL;
+    else {
+        tf_set_last_error("datetime: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int datetime_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 void datetime_free_extra_names(char **owned_names, size_t n_extra) {
+    for (size_t i = 0; i < n_extra; i++) free(owned_names[i]);
+}
+
+static int datetime_add_extra_column(const datetime_state *st, const char *suffix,
+                                     const char **extra_names, char **owned_names,
+                                     tf_type *extra_types, size_t *n_extra) {
+    char *name = tf_string_append_suffix_checked(st->column, suffix);
+    if (!name) return TF_ERROR;
+    owned_names[*n_extra] = name;
+    extra_names[*n_extra] = name;
+    extra_types[*n_extra] = TF_TYPE_INT64;
+    (*n_extra)++;
+    return TF_OK;
+}
+
+static int datetime_extra_columns(const datetime_state *st, const char **extra_names,
+                                  char **owned_names, tf_type *extra_types, size_t *n_extra) {
+    *n_extra = 0;
+#define ADD_DATETIME_EXTRA(suffix) do { \
+        if (datetime_add_extra_column(st, suffix, extra_names, owned_names, \
+                                      extra_types, n_extra) != TF_OK) { \
+            datetime_free_extra_names(owned_names, *n_extra); \
+            return TF_ERROR; \
+        } \
+    } while (0)
+    if (st->w_year) ADD_DATETIME_EXTRA("_year");
+    if (st->w_month) ADD_DATETIME_EXTRA("_month");
+    if (st->w_day) ADD_DATETIME_EXTRA("_day");
+    if (st->w_hour) ADD_DATETIME_EXTRA("_hour");
+    if (st->w_minute) ADD_DATETIME_EXTRA("_minute");
+    if (st->w_second) ADD_DATETIME_EXTRA("_second");
+    if (st->w_weekday) ADD_DATETIME_EXTRA("_weekday");
+    if (st->w_epoch) ADD_DATETIME_EXTRA("_epoch");
+#undef ADD_DATETIME_EXTRA
+    return TF_OK;
+}
+
+static int datetime_set_extra_nulls(tf_batch *ob, size_t row, size_t start, size_t n_extra) {
+    for (size_t k = start; k < start + n_extra; k++) {
+        if (tf_batch_set_null(ob, row, k) != TF_OK) return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int datetime_apply_extracts(const datetime_state *st, tf_batch *ob, size_t row,
+                                   size_t *ei, int y, int mo, int d, int h, int mi, int se) {
+    if (st->w_year && tf_batch_set_int64(ob, row, (*ei)++, y) != TF_OK) return TF_ERROR;
+    if (st->w_month && tf_batch_set_int64(ob, row, (*ei)++, mo) != TF_OK) return TF_ERROR;
+    if (st->w_day && tf_batch_set_int64(ob, row, (*ei)++, d) != TF_OK) return TF_ERROR;
+    if (st->w_hour && tf_batch_set_int64(ob, row, (*ei)++, h) != TF_OK) return TF_ERROR;
+    if (st->w_minute && tf_batch_set_int64(ob, row, (*ei)++, mi) != TF_OK) return TF_ERROR;
+    if (st->w_second && tf_batch_set_int64(ob, row, (*ei)++, se) != TF_OK) return TF_ERROR;
+    if (st->w_weekday && tf_batch_set_int64(ob, row, (*ei)++, weekday(y, mo, d)) != TF_OK) return TF_ERROR;
+    if (st->w_epoch && tf_batch_set_int64(ob, row, (*ei)++, date_to_epoch(y, mo, d, h, mi, se)) != TF_OK) return TF_ERROR;
+    return TF_OK;
+}
+
 static int datetime_process(tf_step *self, tf_batch *in, tf_batch **out,
                             tf_side_channels *side) {
     (void)side;
     datetime_state *st = self->state;
     *out = NULL;
 
-    /* Count extra columns */
+    int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == DATETIME_MISSING_ERROR) {
+            datetime_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == DATETIME_MISSING_IGNORE) return datetime_passthrough(in, out);
+        force_null = 1;
+    } else if (!datetime_is_temporal_type(in->col_types[ci])) {
+        if (st->on_type_error == DATETIME_TYPE_FAIL) {
+            datetime_set_col_error(st->column, "must be string, date, or timestamp");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+
+    const char *extra_names[8];
+    char *owned_extra_names[8] = {0};
+    tf_type extra_types[8];
     size_t n_extra = 0;
-    if (st->w_year) n_extra++;
-    if (st->w_month) n_extra++;
-    if (st->w_day) n_extra++;
-    if (st->w_hour) n_extra++;
-    if (st->w_minute) n_extra++;
-    if (st->w_second) n_extra++;
-    if (st->w_weekday) n_extra++;
-    if (st->w_epoch) n_extra++;
-
-    tf_batch *ob = tf_batch_create(in->n_cols + n_extra, 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]);
-
-    size_t ei = in->n_cols;
-    char col_prefix[256];
-    snprintf(col_prefix, sizeof(col_prefix), "%s_", st->column);
-    char col_name[256];
-    if (st->w_year)    { snprintf(col_name, sizeof(col_name), "%syear", col_prefix);    tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_month)   { snprintf(col_name, sizeof(col_name), "%smonth", col_prefix);   tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_day)     { snprintf(col_name, sizeof(col_name), "%sday", col_prefix);     tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_hour)    { snprintf(col_name, sizeof(col_name), "%shour", col_prefix);    tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_minute)  { snprintf(col_name, sizeof(col_name), "%sminute", col_prefix);  tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_second)  { snprintf(col_name, sizeof(col_name), "%ssecond", col_prefix);  tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_weekday) { snprintf(col_name, sizeof(col_name), "%sweekday", col_prefix); tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
-    if (st->w_epoch)   { snprintf(col_name, sizeof(col_name), "%sepoch", col_prefix);   tf_batch_set_schema(ob, ei++, col_name, TF_TYPE_INT64); }
+    if (datetime_extra_columns(st, extra_names, owned_extra_names, extra_types, &n_extra) != TF_OK)
+        return TF_ERROR;
 
-    int ci = tf_batch_col_index(in, st->column);
+    size_t out_cols = 0;
+    if (tf_size_add(in->n_cols, n_extra, &out_cols) != TF_OK) {
+        datetime_free_extra_names(owned_extra_names, n_extra);
+        return TF_ERROR;
+    }
+    tf_batch *ob = tf_batch_create(out_cols, in->n_rows);
+    if (!ob) {
+        datetime_free_extra_names(owned_extra_names, n_extra);
+        return TF_ERROR;
+    }
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, n_extra) != TF_OK) {
+        datetime_free_extra_names(owned_extra_names, n_extra);
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    datetime_free_extra_names(owned_extra_names, n_extra);
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_copy_row(ob, r, in, r);
-
-        ei = in->n_cols;
-        if (ci >= 0 && !tf_batch_is_null(in, r, ci)) {
-            int y = 0, mo = 0, d = 0, h = 0, mi = 0, se = 0;
-            int parsed = 0;
-            if (in->col_types[ci] == TF_TYPE_STRING) {
-                parsed = parse_date(tf_batch_get_string(in, r, ci), &y, &mo, &d, &h, &mi, &se);
-            } else if (in->col_types[ci] == TF_TYPE_DATE) {
-                tf_date_to_ymd(tf_batch_get_date(in, r, ci), &y, &mo, &d);
-                parsed = 1;
-            } else if (in->col_types[ci] == TF_TYPE_TIMESTAMP) {
-                int frac;
-                tf_timestamp_to_parts(tf_batch_get_timestamp(in, r, ci), &y, &mo, &d, &h, &mi, &se, &frac);
-                parsed = 1;
-            }
-            if (parsed) {
-                if (st->w_year)    tf_batch_set_int64(ob, r, ei++, y);
-                if (st->w_month)   tf_batch_set_int64(ob, r, ei++, mo);
-                if (st->w_day)     tf_batch_set_int64(ob, r, ei++, d);
-                if (st->w_hour)    tf_batch_set_int64(ob, r, ei++, h);
-                if (st->w_minute)  tf_batch_set_int64(ob, r, ei++, mi);
-                if (st->w_second)  tf_batch_set_int64(ob, r, ei++, se);
-                if (st->w_weekday) tf_batch_set_int64(ob, r, ei++, weekday(y, mo, d));
-                if (st->w_epoch)   tf_batch_set_int64(ob, r, ei++, date_to_epoch(y, mo, d, h, mi, se));
-            } else {
-                for (size_t k = in->n_cols; k < in->n_cols + n_extra; k++)
-                    tf_batch_set_null(ob, r, k);
-            }
-        } else {
-            for (size_t k = in->n_cols; k < in->n_cols + n_extra; k++)
-                tf_batch_set_null(ob, r, k);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+
+        size_t ei = in->n_cols;
+        if (force_null || tf_batch_is_null(in, r, (size_t)ci)) {
+            if (datetime_set_extra_nulls(ob, r, in->n_cols, n_extra) != 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; }
+            continue;
+        }
+
+        int y = 0, mo = 0, d = 0, h = 0, mi = 0, se = 0;
+        int parsed = 0;
+        if (in->col_types[ci] == TF_TYPE_STRING) {
+            parsed = parse_date(tf_batch_get_string(in, r, ci), &y, &mo, &d, &h, &mi, &se);
+        } else if (in->col_types[ci] == TF_TYPE_DATE) {
+            tf_date_to_ymd(tf_batch_get_date(in, r, ci), &y, &mo, &d);
+            parsed = 1;
+        } else if (in->col_types[ci] == TF_TYPE_TIMESTAMP) {
+            int frac;
+            tf_timestamp_to_parts(tf_batch_get_timestamp(in, r, ci), &y, &mo, &d, &h, &mi, &se, &frac);
+            parsed = 1;
+        }
+        if (parsed) {
+            if (datetime_apply_extracts(st, ob, r, &ei, y, mo, d, h, mi, se) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+        } else if (datetime_set_extra_nulls(ob, r, in->n_cols, n_extra) != 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;
         }
-        ob->n_rows = r + 1;
     }
 
     *out = ob;
@@ -164,36 +311,64 @@ static int datetime_flush(tf_step *self, tf_batch **out, tf_side_channels *side)
     (void)self; (void)side; *out = NULL; return TF_OK;
 }
 
+static void datetime_state_free(datetime_state *st) {
+    if (!st) return;
+    free(st->column);
+    free(st);
+}
+
 static void datetime_destroy(tf_step *self) {
-    datetime_state *st = self->state;
-    if (st) { free(st->column); free(st); }
+    if (self) datetime_state_free(self->state);
     free(self);
 }
 
+static int datetime_enable_component(datetime_state *st, const char *s) {
+    if (strcmp(s, "year") == 0) st->w_year = 1;
+    else if (strcmp(s, "month") == 0) st->w_month = 1;
+    else if (strcmp(s, "day") == 0) st->w_day = 1;
+    else if (strcmp(s, "hour") == 0) st->w_hour = 1;
+    else if (strcmp(s, "minute") == 0) st->w_minute = 1;
+    else if (strcmp(s, "second") == 0) st->w_second = 1;
+    else if (strcmp(s, "weekday") == 0) st->w_weekday = 1;
+    else if (strcmp(s, "epoch") == 0) st->w_epoch = 1;
+    else return TF_ERROR;
+    return TF_OK;
+}
+
+static int datetime_has_component(const datetime_state *st) {
+    return st->w_year || st->w_month || st->w_day || st->w_hour || st->w_minute ||
+           st->w_second || st->w_weekday || st->w_epoch;
+}
+
 tf_step *tf_datetime_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("datetime: column is required");
+        return NULL;
+    }
 
-    datetime_state *st = calloc(1, sizeof(datetime_state));
+    datetime_state *st = tf_callocarray_checked(1, sizeof(datetime_state));
     if (!st) return NULL;
-    st->column = strdup(col_j->valuestring);
+    st->column = tf_strdup_checked(col_j->valuestring);
+    if (!st->column) { free(st); return NULL; }
 
     cJSON *extract = cJSON_GetObjectItemCaseSensitive(args, "extract");
     if (extract && cJSON_IsArray(extract)) {
         int n = cJSON_GetArraySize(extract);
         for (int i = 0; i < n; i++) {
             cJSON *item = cJSON_GetArrayItem(extract, i);
-            if (!cJSON_IsString(item)) continue;
-            const char *s = item->valuestring;
-            if (strcmp(s, "year") == 0) st->w_year = 1;
-            else if (strcmp(s, "month") == 0) st->w_month = 1;
-            else if (strcmp(s, "day") == 0) st->w_day = 1;
-            else if (strcmp(s, "hour") == 0) st->w_hour = 1;
-            else if (strcmp(s, "minute") == 0) st->w_minute = 1;
-            else if (strcmp(s, "second") == 0) st->w_second = 1;
-            else if (strcmp(s, "weekday") == 0) st->w_weekday = 1;
-            else if (strcmp(s, "epoch") == 0) st->w_epoch = 1;
+            if (!cJSON_IsString(item) || !item->valuestring[0] ||
+                datetime_enable_component(st, item->valuestring) != TF_OK) {
+                tf_set_last_error("datetime: extract must contain year, month, day, hour, minute, second, weekday, or epoch");
+                datetime_state_free(st);
+                return NULL;
+            }
+        }
+        if (!datetime_has_component(st)) {
+            tf_set_last_error("datetime: extract must contain at least one component");
+            datetime_state_free(st);
+            return NULL;
         }
     } else {
         /* Default: all */
@@ -202,7 +377,14 @@ tf_step *tf_datetime_create(const cJSON *args) {
         st->w_weekday = st->w_epoch = 1;
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    if (datetime_parse_missing_policy(args, &st->missing) != TF_OK ||
+        datetime_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
+
+    tf_step *step = tf_callocarray_checked(1, sizeof(tf_step));
     if (!step) { free(st->column); free(st); return NULL; }
     step->process = datetime_process;
     step->flush = datetime_flush;

package/csrc/op_derive.c

@@ -11,6 +11,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <limits.h>
+#include <math.h>
 
 typedef struct {
     char    *name;
@@ -24,19 +26,21 @@ typedef struct {
     tf_type    *col_types;       /* resolved type per derived column */
 } derive_state;
 
-/* Evaluate first row to determine derived column types */
-static void resolve_types(derive_state *st, const tf_batch *in) {
-    st->col_types = calloc(st->n_cols, sizeof(tf_type));
-    if (!st->col_types) return;
+/* Evaluate first row to determine derived column types. */
+static int resolve_types(derive_state *st, const tf_batch *in) {
+    st->col_types = calloc(st->n_cols ? st->n_cols : 1, sizeof(tf_type));
+    if (!st->col_types) return TF_ERROR;
 
     for (size_t d = 0; d < st->n_cols; d++) {
         if (in->n_rows == 0) {
-            /* No rows to sample; default to FLOAT64 for arithmetic */
             st->col_types[d] = TF_TYPE_FLOAT64;
             continue;
         }
         tf_eval_result val;
-        tf_expr_eval_val(st->cols[d].expr, in, 0, &val);
+        if (tf_expr_eval_val(st->cols[d].expr, in, 0, &val) != TF_OK) {
+            st->col_types[d] = TF_TYPE_FLOAT64;
+            continue;
+        }
         switch (val.type) {
             case TF_TYPE_INT64:   st->col_types[d] = TF_TYPE_INT64; break;
             case TF_TYPE_FLOAT64: st->col_types[d] = TF_TYPE_FLOAT64; break;
@@ -48,60 +52,49 @@ static void resolve_types(derive_state *st, const tf_batch *in) {
         }
     }
     st->types_resolved = 1;
+    return TF_OK;
 }
 
-static void set_derived_value(tf_batch *ob, size_t row, size_t col,
-                              tf_type col_type, const tf_eval_result *val) {
-    if (val->type == TF_TYPE_NULL) {
-        tf_batch_set_null(ob, row, col);
-        return;
-    }
+static int derive_double_to_i64(double v, int64_t *out) {
+    if (!isfinite(v) || v < (double)INT64_MIN || v > (double)INT64_MAX) return TF_ERROR;
+    *out = (int64_t)v;
+    return TF_OK;
+}
+
+static int set_derived_value(tf_batch *ob, size_t row, size_t col,
+                             tf_type col_type, const tf_eval_result *val) {
+    if (!val || val->type == TF_TYPE_NULL) return tf_batch_set_null(ob, row, col);
 
-    /* Convert value to the column's type */
     switch (col_type) {
         case TF_TYPE_INT64:
-            if (val->type == TF_TYPE_INT64)
-                tf_batch_set_int64(ob, row, col, val->i);
-            else if (val->type == TF_TYPE_FLOAT64)
-                tf_batch_set_int64(ob, row, col, (int64_t)val->f);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_INT64) return tf_batch_set_int64(ob, row, col, val->i);
+            if (val->type == TF_TYPE_FLOAT64) {
+                int64_t iv = 0;
+                if (derive_double_to_i64(val->f, &iv) != TF_OK) return tf_batch_set_null(ob, row, col);
+                return tf_batch_set_int64(ob, row, col, iv);
+            }
+            return tf_batch_set_null(ob, row, col);
         case TF_TYPE_FLOAT64:
-            if (val->type == TF_TYPE_FLOAT64)
-                tf_batch_set_float64(ob, row, col, val->f);
-            else if (val->type == TF_TYPE_INT64)
-                tf_batch_set_float64(ob, row, col, (double)val->i);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_FLOAT64) return tf_batch_set_float64(ob, row, col, val->f);
+            if (val->type == TF_TYPE_INT64) return tf_batch_set_float64(ob, row, col, (double)val->i);
+            return tf_batch_set_null(ob, row, col);
         case TF_TYPE_STRING:
-            if (val->type == TF_TYPE_STRING)
-                tf_batch_set_string(ob, row, col, val->s);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_STRING) {
+                if (!val->s) return tf_batch_set_null(ob, row, col);
+                return tf_batch_set_string(ob, row, col, val->s);
+            }
+            return tf_batch_set_null(ob, row, col);
         case TF_TYPE_BOOL:
-            if (val->type == TF_TYPE_BOOL)
-                tf_batch_set_bool(ob, row, col, val->b);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_BOOL) return tf_batch_set_bool(ob, row, col, val->b);
+            return tf_batch_set_null(ob, row, col);
         case TF_TYPE_DATE:
-            if (val->type == TF_TYPE_DATE)
-                tf_batch_set_date(ob, row, col, val->date);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_DATE) return tf_batch_set_date(ob, row, col, val->date);
+            return tf_batch_set_null(ob, row, col);
         case TF_TYPE_TIMESTAMP:
-            if (val->type == TF_TYPE_TIMESTAMP)
-                tf_batch_set_timestamp(ob, row, col, val->i);
-            else
-                tf_batch_set_null(ob, row, col);
-            break;
+            if (val->type == TF_TYPE_TIMESTAMP) return tf_batch_set_timestamp(ob, row, col, val->i);
+            return tf_batch_set_null(ob, row, col);
         default:
-            tf_batch_set_null(ob, row, col);
-            break;
+            return tf_batch_set_null(ob, row, col);
     }
 }
 
@@ -111,69 +104,40 @@ static int derive_process(tf_step *self, tf_batch *in, tf_batch **out,
     derive_state *st = self->state;
     *out = NULL;
 
-    /* Resolve types on first batch */
-    if (!st->types_resolved) {
-        resolve_types(st, in);
-    }
+    if (!st->types_resolved && resolve_types(st, in) != TF_OK) return TF_ERROR;
+
+    size_t out_n_cols = 0;
+    if (tf_size_add(in->n_cols, st->n_cols, &out_n_cols) != TF_OK) return TF_ERROR;
 
-    size_t out_n_cols = in->n_cols + st->n_cols;
     tf_batch *ob = tf_batch_create(out_n_cols, in->n_rows > 0 ? in->n_rows : 1);
     if (!ob) return TF_ERROR;
 
-    /* Copy input schema */
-    for (size_t c = 0; c < in->n_cols; c++) {
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    const char **extra_names = calloc(st->n_cols ? st->n_cols : 1, sizeof(char *));
+    if (!extra_names) {
+        tf_batch_free(ob);
+        return TF_ERROR;
     }
-    /* Set derived column schemas with resolved types */
-    for (size_t d = 0; d < st->n_cols; d++) {
-        tf_batch_set_schema(ob, in->n_cols + d, st->cols[d].name, st->col_types[d]);
+    for (size_t d = 0; d < st->n_cols; d++) extra_names[d] = st->cols[d].name;
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, st->col_types, st->n_cols) != TF_OK) {
+        free(extra_names);
+        tf_batch_free(ob);
+        return TF_ERROR;
     }
+    free(extra_names);
 
     for (size_t r = 0; r < in->n_rows; r++) {
-        tf_batch_ensure_capacity(ob, r + 1);
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) goto fail;
 
-        /* Copy input columns */
-        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;
-            }
-        }
-
-        /* Evaluate derived columns */
         for (size_t d = 0; d < st->n_cols; d++) {
             size_t col_idx = in->n_cols + d;
             tf_eval_result val;
             if (tf_expr_eval_val(st->cols[d].expr, in, r, &val) != TF_OK) {
-                tf_batch_set_null(ob, r, col_idx);
+                if (tf_batch_set_null(ob, r, col_idx) != TF_OK) goto fail;
                 continue;
             }
-            set_derived_value(ob, r, col_idx, st->col_types[d], &val);
+            if (set_derived_value(ob, r, col_idx, st->col_types[d], &val) != TF_OK) goto fail;
         }
-        ob->n_rows = r + 1;
+        if (tf_batch_expose_row(ob, r) != TF_OK) goto fail;
     }
 
     if (ob->n_rows > 0) {
@@ -182,6 +146,10 @@ static int derive_process(tf_step *self, tf_batch *in, tf_batch **out,
         tf_batch_free(ob);
     }
     return TF_OK;
+
+fail:
+    tf_batch_free(ob);
+    return TF_ERROR;
 }
 
 static int derive_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
@@ -229,7 +197,7 @@ tf_step *tf_derive_create(const cJSON *args) {
         if (!st->cols[i].name || !st->cols[i].expr) goto fail;
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) goto fail;
     step->process = derive_process;
     step->flush = derive_flush;