tranfi 0.0.1 → 0.1.2

package/csrc/op_anomaly.c

@@ -0,0 +1,120 @@
+/*
+ * op_anomaly.c — Streaming anomaly detection via z-score.
+ * Uses Welford's online algorithm for mean/variance.
+ *
+ * Config: {"column": "price", "threshold": 3.0, "result": "price_anomaly"}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+typedef struct {
+    char   *column;
+    char   *result;
+    double  threshold;
+    /* Welford's online algorithm */
+    size_t  count;
+    double  mean;
+    double  m2;
+} anomaly_state;
+
+static double 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;
+}
+
+static int anomaly_process(tf_step *self, tf_batch *in, tf_batch **out,
+                           tf_side_channels *side) {
+    (void)side;
+    anomaly_state *st = self->state;
+    *out = NULL;
+
+    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, st->result, TF_TYPE_INT64);
+
+    int ci = tf_batch_col_index(in, st->column);
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_copy_row(ob, r, in, r);
+
+        if (ci < 0 || tf_batch_is_null(in, r, ci)) {
+            tf_batch_set_int64(ob, r, in->n_cols, 0);
+            ob->n_rows = r + 1;
+            continue;
+        }
+
+        double val = get_numeric(in, r, ci);
+
+        /* Update Welford's */
+        st->count++;
+        double delta = val - st->mean;
+        st->mean += delta / (double)st->count;
+        double delta2 = val - st->mean;
+        st->m2 += delta * delta2;
+
+        /* Compute z-score (need at least 2 data points for variance) */
+        int is_anomaly = 0;
+        if (st->count >= 2) {
+            double var = st->m2 / (double)(st->count - 1);
+            double std = sqrt(var);
+            if (std > 0) {
+                double z = fabs((val - st->mean) / std);
+                is_anomaly = z > st->threshold ? 1 : 0;
+            }
+        }
+
+        tf_batch_set_int64(ob, r, in->n_cols, is_anomaly);
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int anomaly_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void anomaly_destroy(tf_step *self) {
+    anomaly_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st); }
+    free(self);
+}
+
+tf_step *tf_anomaly_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsString(col_j)) return NULL;
+
+    anomaly_state *st = calloc(1, sizeof(anomaly_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+
+    cJSON *thresh_j = cJSON_GetObjectItemCaseSensitive(args, "threshold");
+    st->threshold = cJSON_IsNumber(thresh_j) ? thresh_j->valuedouble : 3.0;
+
+    cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
+    if (cJSON_IsString(res_j)) {
+        st->result = strdup(res_j->valuestring);
+    } else {
+        char buf[256];
+        snprintf(buf, sizeof(buf), "%s_anomaly", st->column);
+        st->result = strdup(buf);
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st->result); free(st); return NULL; }
+    step->process = anomaly_process;
+    step->flush = anomaly_flush;
+    step->destroy = anomaly_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_bin.c

@@ -0,0 +1,109 @@
+/*
+ * op_bin.c — Discretize numeric column into labeled bins.
+ *
+ * Config: {"column": "age", "boundaries": [18, 30, 50, 65]}
+ * Adds <col>_bin column with labels like "<18", "18-30", "30-50", "50-65", "65+"
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char   *column;
+    double *boundaries;
+    size_t  n_boundaries;
+} bin_state;
+
+static int bin_process(tf_step *self, tf_batch *in, tf_batch **out,
+                       tf_side_channels *side) {
+    (void)side;
+    bin_state *st = self->state;
+    *out = NULL;
+
+    char bin_col_name[256];
+    snprintf(bin_col_name, sizeof(bin_col_name), "%s_bin", st->column);
+
+    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, bin_col_name, TF_TYPE_STRING);
+
+    int ci = tf_batch_col_index(in, st->column);
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_copy_row(ob, r, in, r);
+
+        if (ci < 0 || tf_batch_is_null(in, r, ci)) {
+            tf_batch_set_null(ob, r, in->n_cols);
+        } else {
+            double val = 0;
+            if (in->col_types[ci] == TF_TYPE_INT64) val = (double)tf_batch_get_int64(in, r, ci);
+            else if (in->col_types[ci] == TF_TYPE_FLOAT64) val = tf_batch_get_float64(in, r, ci);
+
+            char label[64];
+            if (st->n_boundaries == 0) {
+                snprintf(label, sizeof(label), "%g", val);
+            } else if (val < st->boundaries[0]) {
+                snprintf(label, sizeof(label), "<%g", st->boundaries[0]);
+            } else {
+                size_t b;
+                for (b = 1; b < st->n_boundaries; b++) {
+                    if (val < st->boundaries[b]) break;
+                }
+                if (b < st->n_boundaries) {
+                    snprintf(label, sizeof(label), "%g-%g", st->boundaries[b - 1], st->boundaries[b]);
+                } else {
+                    snprintf(label, sizeof(label), "%g+", st->boundaries[st->n_boundaries - 1]);
+                }
+            }
+            tf_batch_set_string(ob, r, in->n_cols, label);
+        }
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int bin_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void bin_destroy(tf_step *self) {
+    bin_state *st = self->state;
+    if (st) { free(st->column); free(st->boundaries); free(st); }
+    free(self);
+}
+
+tf_step *tf_bin_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsString(col_j)) return NULL;
+
+    bin_state *st = calloc(1, sizeof(bin_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+
+    cJSON *bounds = cJSON_GetObjectItemCaseSensitive(args, "boundaries");
+    if (bounds && cJSON_IsArray(bounds)) {
+        int n = cJSON_GetArraySize(bounds);
+        st->boundaries = malloc(n * sizeof(double));
+        st->n_boundaries = n;
+        for (int i = 0; i < n; i++) {
+            cJSON *item = cJSON_GetArrayItem(bounds, i);
+            st->boundaries[i] = cJSON_IsNumber(item) ? item->valuedouble : 0;
+        }
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st->boundaries); free(st); return NULL; }
+    step->process = bin_process;
+    step->flush = bin_flush;
+    step->destroy = bin_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_cast.c

@@ -0,0 +1,195 @@
+/*
+ * op_cast.c — Type conversion.
+ *
+ * Config: {"mapping": {"age": "int", "score": "float", "active": "bool"}}
+ */
+
+#include "internal.h"
+#include "date_utils.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char    **col_names;
+    tf_type  *target_types;
+    size_t    n;
+} cast_state;
+
+static tf_type parse_type(const char *s) {
+    if (strcmp(s, "int") == 0 || strcmp(s, "int64") == 0) return TF_TYPE_INT64;
+    if (strcmp(s, "float") == 0 || strcmp(s, "float64") == 0) return TF_TYPE_FLOAT64;
+    if (strcmp(s, "string") == 0 || strcmp(s, "str") == 0) return TF_TYPE_STRING;
+    if (strcmp(s, "bool") == 0 || strcmp(s, "boolean") == 0) return TF_TYPE_BOOL;
+    if (strcmp(s, "date") == 0) return TF_TYPE_DATE;
+    if (strcmp(s, "timestamp") == 0 || strcmp(s, "datetime") == 0) return TF_TYPE_TIMESTAMP;
+    return TF_TYPE_NULL;
+}
+
+static int cast_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    cast_state *st = self->state;
+    *out = NULL;
+
+    /* Determine output types */
+    tf_type *out_types = malloc(in->n_cols * sizeof(tf_type));
+    if (!out_types) return TF_ERROR;
+    for (size_t c = 0; c < in->n_cols; c++) out_types[c] = in->col_types[c];
+    for (size_t k = 0; k < st->n; k++) {
+        int ci = tf_batch_col_index(in, st->col_names[k]);
+        if (ci >= 0) out_types[ci] = st->target_types[k];
+    }
+
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) { free(out_types); return TF_ERROR; }
+    for (size_t c = 0; c < in->n_cols; c++)
+        tf_batch_set_schema(ob, c, in->col_names[c], out_types[c]);
+
+    for (size_t r = 0; r < in->n_rows; 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;
+            }
+            tf_type src_t = in->col_types[c];
+            tf_type dst_t = out_types[c];
+
+            if (src_t == dst_t) {
+                /* No conversion needed */
+                switch (src_t) {
+                    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;
+                }
+                continue;
+            }
+
+            /* Conversion */
+            if (dst_t == TF_TYPE_STRING) {
+                char buf[64];
+                switch (src_t) {
+                    case TF_TYPE_INT64: snprintf(buf, sizeof(buf), "%lld", (long long)tf_batch_get_int64(in, r, c)); break;
+                    case TF_TYPE_FLOAT64: snprintf(buf, sizeof(buf), "%g", tf_batch_get_float64(in, r, c)); break;
+                    case TF_TYPE_BOOL: snprintf(buf, sizeof(buf), "%s", tf_batch_get_bool(in, r, c) ? "true" : "false"); break;
+                    case TF_TYPE_DATE: tf_date_format(tf_batch_get_date(in, r, c), buf, sizeof(buf)); break;
+                    case TF_TYPE_TIMESTAMP: tf_timestamp_format(tf_batch_get_timestamp(in, r, c), buf, sizeof(buf)); break;
+                    default: buf[0] = '\0'; break;
+                }
+                tf_batch_set_string(ob, r, c, buf);
+            } else if (dst_t == TF_TYPE_INT64) {
+                int64_t v = 0;
+                if (src_t == TF_TYPE_FLOAT64) v = (int64_t)tf_batch_get_float64(in, r, c);
+                else if (src_t == TF_TYPE_STRING) { char *end; v = strtoll(tf_batch_get_string(in, r, c), &end, 10); }
+                else if (src_t == TF_TYPE_BOOL) v = tf_batch_get_bool(in, r, c) ? 1 : 0;
+                else if (src_t == TF_TYPE_TIMESTAMP) v = tf_batch_get_timestamp(in, r, c);
+                tf_batch_set_int64(ob, r, c, v);
+            } else if (dst_t == TF_TYPE_FLOAT64) {
+                double v = 0;
+                if (src_t == TF_TYPE_INT64) v = (double)tf_batch_get_int64(in, r, c);
+                else if (src_t == TF_TYPE_STRING) { char *end; v = strtod(tf_batch_get_string(in, r, c), &end); }
+                else if (src_t == TF_TYPE_BOOL) v = tf_batch_get_bool(in, r, c) ? 1.0 : 0.0;
+                tf_batch_set_float64(ob, r, c, v);
+            } else if (dst_t == TF_TYPE_BOOL) {
+                bool v = false;
+                if (src_t == TF_TYPE_INT64) v = tf_batch_get_int64(in, r, c) != 0;
+                else if (src_t == TF_TYPE_FLOAT64) v = tf_batch_get_float64(in, r, c) != 0.0;
+                else if (src_t == TF_TYPE_STRING) v = strlen(tf_batch_get_string(in, r, c)) > 0 && strcmp(tf_batch_get_string(in, r, c), "false") != 0;
+                tf_batch_set_bool(ob, r, c, v);
+            } else if (dst_t == TF_TYPE_DATE) {
+                int32_t v = 0;
+                if (src_t == TF_TYPE_STRING) {
+                    const char *s = tf_batch_get_string(in, r, c);
+                    int y, m, d;
+                    if (sscanf(s, "%d-%d-%d", &y, &m, &d) == 3)
+                        v = tf_date_from_ymd(y, m, d);
+                } else if (src_t == TF_TYPE_TIMESTAMP) {
+                    v = (int32_t)(tf_batch_get_timestamp(in, r, c) / (86400LL * 1000000LL));
+                }
+                tf_batch_set_date(ob, r, c, v);
+            } else if (dst_t == TF_TYPE_TIMESTAMP) {
+                int64_t v = 0;
+                if (src_t == TF_TYPE_STRING) {
+                    const char *s = tf_batch_get_string(in, r, c);
+                    size_t slen = strlen(s);
+                    int32_t dv;
+                    /* Try timestamp first, then date at midnight */
+                    if (slen >= 19) {
+                        int y, mo, d, h, mi, se;
+                        if (sscanf(s, "%d-%d-%dT%d:%d:%d", &y, &mo, &d, &h, &mi, &se) == 6)
+                            v = tf_timestamp_from_parts(y, mo, d, h, mi, se, 0);
+                        else if (sscanf(s, "%d-%d-%d %d:%d:%d", &y, &mo, &d, &h, &mi, &se) == 6)
+                            v = tf_timestamp_from_parts(y, mo, d, h, mi, se, 0);
+                    } else if (slen == 10) {
+                        int y, m, d;
+                        if (sscanf(s, "%d-%d-%d", &y, &m, &d) == 3) {
+                            dv = tf_date_from_ymd(y, m, d);
+                            v = (int64_t)dv * 86400LL * 1000000LL;
+                        }
+                    }
+                } else if (src_t == TF_TYPE_DATE) {
+                    v = (int64_t)tf_batch_get_date(in, r, c) * 86400LL * 1000000LL;
+                } else if (src_t == TF_TYPE_INT64) {
+                    v = tf_batch_get_int64(in, r, c);
+                }
+                tf_batch_set_timestamp(ob, r, c, v);
+            } else {
+                tf_batch_set_null(ob, r, c);
+            }
+        }
+        ob->n_rows = r + 1;
+    }
+
+    free(out_types);
+    *out = ob;
+    return TF_OK;
+}
+
+static int cast_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void cast_destroy(tf_step *self) {
+    cast_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n; i++) free(st->col_names[i]);
+        free(st->col_names); free(st->target_types);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_cast_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *mapping = cJSON_GetObjectItemCaseSensitive(args, "mapping");
+    if (!mapping || !cJSON_IsObject(mapping)) return NULL;
+
+    int n = cJSON_GetArraySize(mapping);
+    cast_state *st = calloc(1, sizeof(cast_state));
+    if (!st) return NULL;
+    st->col_names = calloc(n, sizeof(char *));
+    st->target_types = calloc(n, sizeof(tf_type));
+    st->n = n;
+
+    int i = 0;
+    cJSON *entry = NULL;
+    cJSON_ArrayForEach(entry, mapping) {
+        st->col_names[i] = strdup(entry->string);
+        st->target_types[i] = cJSON_IsString(entry) ? parse_type(entry->valuestring) : TF_TYPE_NULL;
+        i++;
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { cast_destroy(&(tf_step){.state = st}); return NULL; }
+    step->process = cast_process;
+    step->flush = cast_flush;
+    step->destroy = cast_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_clip.c

@@ -0,0 +1,88 @@
+/*
+ * op_clip.c — Clamp numeric values to [min, max].
+ *
+ * Config: {"column": "score", "min": 0, "max": 100}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    char  *column;
+    double min_val;
+    double max_val;
+    int    has_min;
+    int    has_max;
+} clip_state;
+
+static int clip_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    clip_state *st = self->state;
+    *out = NULL;
+
+    tf_batch *ob = tf_batch_create(in->n_cols, 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]);
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_copy_row(ob, r, in, r);
+        ob->n_rows = r + 1;
+    }
+
+    int ci = tf_batch_col_index(ob, st->column);
+    if (ci >= 0) {
+        for (size_t r = 0; r < ob->n_rows; r++) {
+            if (tf_batch_is_null(ob, r, ci)) continue;
+            if (ob->col_types[ci] == TF_TYPE_INT64) {
+                int64_t v = tf_batch_get_int64(ob, r, ci);
+                if (st->has_min && v < (int64_t)st->min_val) v = (int64_t)st->min_val;
+                if (st->has_max && v > (int64_t)st->max_val) v = (int64_t)st->max_val;
+                tf_batch_set_int64(ob, r, ci, v);
+            } else if (ob->col_types[ci] == TF_TYPE_FLOAT64) {
+                double v = tf_batch_get_float64(ob, r, ci);
+                if (st->has_min && v < st->min_val) v = st->min_val;
+                if (st->has_max && v > st->max_val) v = st->max_val;
+                tf_batch_set_float64(ob, r, ci, v);
+            }
+        }
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int clip_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void clip_destroy(tf_step *self) {
+    clip_state *st = self->state;
+    if (st) { free(st->column); free(st); }
+    free(self);
+}
+
+tf_step *tf_clip_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsString(col_j)) return NULL;
+
+    clip_state *st = calloc(1, sizeof(clip_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+
+    cJSON *min_j = cJSON_GetObjectItemCaseSensitive(args, "min");
+    if (cJSON_IsNumber(min_j)) { st->min_val = min_j->valuedouble; st->has_min = 1; }
+    cJSON *max_j = cJSON_GetObjectItemCaseSensitive(args, "max");
+    if (cJSON_IsNumber(max_j)) { st->max_val = max_j->valuedouble; st->has_max = 1; }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st); return NULL; }
+    step->process = clip_process;
+    step->flush = clip_flush;
+    step->destroy = clip_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_date_trunc.c

@@ -0,0 +1,181 @@
+/*
+ * op_date_trunc.c — Truncate date/timestamp to a granularity.
+ *
+ * Config: {"column": "ts", "trunc": "month"}
+ *
+ * Supported granularities: year, month, day, hour, minute, second.
+ * Input: TF_TYPE_DATE, TF_TYPE_TIMESTAMP, or TF_TYPE_STRING (auto-parsed).
+ * Output: same type as input (truncated in place).
+ */
+
+#include "internal.h"
+#include "date_utils.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef enum {
+    TRUNC_YEAR,
+    TRUNC_MONTH,
+    TRUNC_DAY,
+    TRUNC_HOUR,
+    TRUNC_MINUTE,
+    TRUNC_SECOND,
+} trunc_level;
+
+typedef struct {
+    char       *column;
+    char       *result;
+    trunc_level level;
+} date_trunc_state;
+
+static trunc_level parse_level(const char *s) {
+    if (strcmp(s, "year") == 0) return TRUNC_YEAR;
+    if (strcmp(s, "month") == 0) return TRUNC_MONTH;
+    if (strcmp(s, "day") == 0) return TRUNC_DAY;
+    if (strcmp(s, "hour") == 0) return TRUNC_HOUR;
+    if (strcmp(s, "minute") == 0) return TRUNC_MINUTE;
+    if (strcmp(s, "second") == 0) return TRUNC_SECOND;
+    return TRUNC_DAY;
+}
+
+/* Truncate a date (days since epoch) to the given level. */
+static int32_t trunc_date(int32_t days, trunc_level level) {
+    int y, m, d;
+    tf_date_to_ymd(days, &y, &m, &d);
+    switch (level) {
+        case TRUNC_YEAR:   return tf_date_from_ymd(y, 1, 1);
+        case TRUNC_MONTH:  return tf_date_from_ymd(y, m, 1);
+        default:           return days; /* day or finer — date is already at day granularity */
+    }
+}
+
+/* Truncate a timestamp (microseconds since epoch) to the given level. */
+static int64_t trunc_timestamp(int64_t us, trunc_level level) {
+    int y, mo, d, h, mi, s, frac;
+    tf_timestamp_to_parts(us, &y, &mo, &d, &h, &mi, &s, &frac);
+    switch (level) {
+        case TRUNC_YEAR:   return tf_timestamp_from_parts(y, 1, 1, 0, 0, 0, 0);
+        case TRUNC_MONTH:  return tf_timestamp_from_parts(y, mo, 1, 0, 0, 0, 0);
+        case TRUNC_DAY:    return tf_timestamp_from_parts(y, mo, d, 0, 0, 0, 0);
+        case TRUNC_HOUR:   return tf_timestamp_from_parts(y, mo, d, h, 0, 0, 0);
+        case TRUNC_MINUTE: return tf_timestamp_from_parts(y, mo, d, h, mi, 0, 0);
+        case TRUNC_SECOND: return tf_timestamp_from_parts(y, mo, d, h, mi, s, 0);
+    }
+    return us;
+}
+
+/* Try to parse a date string. Returns 1 on success. */
+static int parse_date_string(const char *s, int *y, int *m, int *d) {
+    return sscanf(s, "%d-%d-%d", y, m, d) == 3;
+}
+
+static int date_trunc_process(tf_step *self, tf_batch *in, tf_batch **out,
+                              tf_side_channels *side) {
+    (void)side;
+    date_trunc_state *st = self->state;
+    *out = NULL;
+
+    int ci = tf_batch_col_index(in, st->column);
+    int in_place = (strcmp(st->result, st->column) == 0);
+
+    size_t out_cols = in_place ? in->n_cols : in->n_cols + 1;
+    tf_batch *ob = tf_batch_create(out_cols, 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 result_col;
+    if (in_place) {
+        result_col = (size_t)ci;
+    } else {
+        result_col = in->n_cols;
+        /* Output type matches input column type */
+        tf_type out_type = (ci >= 0) ? in->col_types[ci] : TF_TYPE_STRING;
+        tf_batch_set_schema(ob, result_col, st->result, out_type);
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_copy_row(ob, r, in, r);
+
+        if (ci < 0 || tf_batch_is_null(in, r, ci)) {
+            if (!in_place) tf_batch_set_null(ob, r, result_col);
+            ob->n_rows = r + 1;
+            continue;
+        }
+
+        switch (in->col_types[ci]) {
+            case TF_TYPE_DATE: {
+                int32_t d = tf_batch_get_date(in, r, ci);
+                tf_batch_set_date(ob, r, result_col, trunc_date(d, st->level));
+                break;
+            }
+            case TF_TYPE_TIMESTAMP: {
+                int64_t ts = tf_batch_get_timestamp(in, r, ci);
+                tf_batch_set_timestamp(ob, r, result_col, trunc_timestamp(ts, st->level));
+                break;
+            }
+            case TF_TYPE_STRING: {
+                const char *s = tf_batch_get_string(in, r, ci);
+                int y, m, d;
+                if (parse_date_string(s, &y, &m, &d)) {
+                    int32_t days = tf_date_from_ymd(y, m, d);
+                    int32_t trunc = trunc_date(days, st->level);
+                    char buf[16];
+                    tf_date_format(trunc, buf, sizeof(buf));
+                    tf_batch_set_string(ob, r, result_col, buf);
+                } else {
+                    tf_batch_set_string(ob, r, result_col, s);
+                }
+                break;
+            }
+            default:
+                if (!in_place) tf_batch_set_null(ob, r, result_col);
+                break;
+        }
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int date_trunc_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void date_trunc_destroy(tf_step *self) {
+    date_trunc_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st); }
+    free(self);
+}
+
+tf_step *tf_date_trunc_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    cJSON *trunc_j = cJSON_GetObjectItemCaseSensitive(args, "trunc");
+    if (!cJSON_IsString(col_j) || !cJSON_IsString(trunc_j)) return NULL;
+
+    date_trunc_state *st = calloc(1, sizeof(date_trunc_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+    st->level = parse_level(trunc_j->valuestring);
+
+    cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
+    if (cJSON_IsString(res_j)) {
+        st->result = strdup(res_j->valuestring);
+    } else {
+        /* Default: overwrite in place */
+        st->result = strdup(st->column);
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st->result); free(st); return NULL; }
+    step->process = date_trunc_process;
+    step->flush = date_trunc_flush;
+    step->destroy = date_trunc_destroy;
+    step->state = st;
+    return step;
+}