tranfi 0.0.2 → 0.1.2

package/csrc/op_datetime.c

@@ -0,0 +1,212 @@
+/*
+ * op_datetime.c — Extract date/time components from date strings.
+ *
+ * Config: {"column": "date", "extract": ["year", "month", "day"]}
+ * Supports: YYYY-MM-DD, YYYY-MM-DD HH:MM:SS, epoch seconds.
+ * Components: year, month, day, hour, minute, second, weekday, epoch
+ */
+
+#include "internal.h"
+#include "date_utils.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char  *column;
+    int    w_year, w_month, w_day, w_hour, w_minute, w_second, w_weekday, w_epoch;
+} datetime_state;
+
+/* Days in each month (non-leap) */
+static int days_in_month(int m, int y) {
+    static const int d[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+    if (m == 2 && ((y%4==0 && y%100!=0) || y%400==0)) return 29;
+    return (m >= 1 && m <= 12) ? d[m] : 30;
+}
+
+/* Zeller-like weekday: 0=Sunday..6=Saturday */
+static int weekday(int y, int m, int d) {
+    /* Tomohiko Sakamoto's algorithm */
+    static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
+    if (m < 3) y--;
+    return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
+}
+
+/* Convert date to epoch (seconds since 1970-01-01) */
+static int64_t date_to_epoch(int y, int mo, int d, int h, int mi, int s) {
+    /* Simplified: assume Gregorian, no timezone */
+    int64_t days = 0;
+    for (int yr = 1970; yr < y; yr++) {
+        days += 365 + ((yr%4==0 && yr%100!=0) || yr%400==0);
+    }
+    for (int m = 1; m < mo; m++) days += days_in_month(m, y);
+    days += d - 1;
+    return days * 86400 + h * 3600 + mi * 60 + s;
+}
+
+static int parse_date(const char *s, int *y, int *mo, int *d, int *h, int *mi, int *se) {
+    *y = *mo = *d = *h = *mi = *se = 0;
+
+    /* Try epoch (pure number) */
+    char *end;
+    double epoch = strtod(s, &end);
+    if (*end == '\0' && end != s) {
+        /* Convert epoch to components */
+        int64_t ts = (int64_t)epoch;
+        *se = ts % 60; ts /= 60;
+        *mi = ts % 60; ts /= 60;
+        *h = ts % 24; ts /= 24;
+        /* Days since 1970-01-01 */
+        int64_t dd = ts;
+        *y = 1970;
+        while (1) {
+            int dy = 365 + ((*y%4==0 && *y%100!=0) || *y%400==0);
+            if (dd < dy) break;
+            dd -= dy;
+            (*y)++;
+        }
+        *mo = 1;
+        while (1) {
+            int dm = days_in_month(*mo, *y);
+            if (dd < dm) break;
+            dd -= dm;
+            (*mo)++;
+        }
+        *d = (int)dd + 1;
+        return 1;
+    }
+
+    /* Try YYYY-MM-DD [HH:MM:SS] */
+    int n = sscanf(s, "%d-%d-%d %d:%d:%d", y, mo, d, h, mi, se);
+    return n >= 3;
+}
+
+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 */
+    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); }
+
+    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);
+
+        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);
+        }
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+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_destroy(tf_step *self) {
+    datetime_state *st = self->state;
+    if (st) { free(st->column); free(st); }
+    free(self);
+}
+
+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;
+
+    datetime_state *st = calloc(1, sizeof(datetime_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+
+    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;
+        }
+    } else {
+        /* Default: all */
+        st->w_year = st->w_month = st->w_day = 1;
+        st->w_hour = st->w_minute = st->w_second = 1;
+        st->w_weekday = st->w_epoch = 1;
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st); return NULL; }
+    step->process = datetime_process;
+    step->flush = datetime_flush;
+    step->destroy = datetime_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_derive.c

@@ -0,0 +1,248 @@
+/*
+ * op_derive.c — Add computed columns using arithmetic expressions.
+ *
+ * Config: {"columns": [{"name": "total", "expr": "col(price)*col(qty)"}]}
+ * For each row, evaluates each expression and appends the result as a new column.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include "date_utils.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char    *name;
+    tf_expr *expr;
+} derive_col;
+
+typedef struct {
+    derive_col *cols;
+    size_t      n_cols;
+    int         types_resolved;  /* have we determined output types? */
+    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;
+
+    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);
+        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;
+            case TF_TYPE_STRING:  st->col_types[d] = TF_TYPE_STRING; break;
+            case TF_TYPE_BOOL:    st->col_types[d] = TF_TYPE_BOOL; break;
+            case TF_TYPE_DATE:    st->col_types[d] = TF_TYPE_DATE; break;
+            case TF_TYPE_TIMESTAMP: st->col_types[d] = TF_TYPE_TIMESTAMP; break;
+            default:              st->col_types[d] = TF_TYPE_FLOAT64; break;
+        }
+    }
+    st->types_resolved = 1;
+}
+
+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;
+    }
+
+    /* 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;
+        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;
+        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;
+        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;
+        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;
+        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;
+        default:
+            tf_batch_set_null(ob, row, col);
+            break;
+    }
+}
+
+static int derive_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    (void)side;
+    derive_state *st = self->state;
+    *out = NULL;
+
+    /* Resolve types on first batch */
+    if (!st->types_resolved) {
+        resolve_types(st, in);
+    }
+
+    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]);
+    }
+    /* 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 r = 0; r < in->n_rows; r++) {
+        tf_batch_ensure_capacity(ob, r + 1);
+
+        /* 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);
+                continue;
+            }
+            set_derived_value(ob, r, col_idx, st->col_types[d], &val);
+        }
+        ob->n_rows = r + 1;
+    }
+
+    if (ob->n_rows > 0) {
+        *out = ob;
+    } else {
+        tf_batch_free(ob);
+    }
+    return TF_OK;
+}
+
+static int derive_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void derive_destroy(tf_step *self) {
+    derive_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_cols; i++) {
+            free(st->cols[i].name);
+            tf_expr_free(st->cols[i].expr);
+        }
+        free(st->cols);
+        free(st->col_types);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_derive_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *columns = cJSON_GetObjectItemCaseSensitive(args, "columns");
+    if (!columns || !cJSON_IsArray(columns)) return NULL;
+
+    int n = cJSON_GetArraySize(columns);
+    if (n <= 0) return NULL;
+
+    derive_state *st = calloc(1, sizeof(derive_state));
+    if (!st) return NULL;
+    st->cols = calloc(n, sizeof(derive_col));
+    if (!st->cols) { free(st); return NULL; }
+    st->n_cols = n;
+
+    for (int i = 0; i < n; i++) {
+        cJSON *item = cJSON_GetArrayItem(columns, i);
+        cJSON *name_j = cJSON_GetObjectItemCaseSensitive(item, "name");
+        cJSON *expr_j = cJSON_GetObjectItemCaseSensitive(item, "expr");
+        if (!cJSON_IsString(name_j) || !cJSON_IsString(expr_j)) goto fail;
+
+        st->cols[i].name = strdup(name_j->valuestring);
+        st->cols[i].expr = tf_expr_parse(expr_j->valuestring);
+        if (!st->cols[i].name || !st->cols[i].expr) goto fail;
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) goto fail;
+    step->process = derive_process;
+    step->flush = derive_flush;
+    step->destroy = derive_destroy;
+    step->state = st;
+    return step;
+
+fail:
+    for (int i = 0; i < n; i++) {
+        free(st->cols[i].name);
+        tf_expr_free(st->cols[i].expr);
+    }
+    free(st->cols);
+    free(st);
+    return NULL;
+}

package/csrc/op_diff.c

@@ -0,0 +1,134 @@
+/*
+ * op_diff.c — First (or higher-order) differencing.
+ *
+ * Config: {"column": "price", "order": 1, "result": "price_diff"}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#define MAX_DIFF_ORDER 8
+
+typedef struct {
+    char   *column;
+    char   *result;
+    int     order;
+    double  prev[MAX_DIFF_ORDER]; /* circular buffer of previous values */
+    int     count; /* rows seen so far */
+} diff_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 diff_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    diff_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_FLOAT64);
+
+    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);
+            ob->n_rows = r + 1;
+            continue;
+        }
+
+        double val = get_numeric(in, r, ci);
+
+        if (st->count < st->order) {
+            /* Not enough history yet */
+            st->prev[st->count] = val;
+            st->count++;
+            tf_batch_set_null(ob, r, in->n_cols);
+            ob->n_rows = r + 1;
+            continue;
+        }
+
+        /* Compute difference using binomial coefficients:
+         * diff(order=1): val - prev[0]
+         * diff(order=2): val - 2*prev[0] + prev[1]
+         * General: sum_{k=0}^{order} (-1)^k * C(order,k) * x_{n-k}
+         */
+        double result = 0;
+        int binom = 1;
+        int sign = 1;
+        /* x_n (current value) */
+        result = val;
+        /* x_{n-1} ... x_{n-order} from prev buffer (most recent first) */
+        for (int k = 1; k <= st->order; k++) {
+            binom = binom * (st->order - k + 1) / k;
+            sign = -sign;
+            /* prev[0] is the most recent previous value */
+            result += sign * binom * st->prev[k - 1];
+        }
+
+        tf_batch_set_float64(ob, r, in->n_cols, result);
+        ob->n_rows = r + 1;
+
+        /* Shift prev buffer: move everything down, put val at [0] */
+        for (int k = st->order - 1; k > 0; k--)
+            st->prev[k] = st->prev[k - 1];
+        st->prev[0] = val;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int diff_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void diff_destroy(tf_step *self) {
+    diff_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st); }
+    free(self);
+}
+
+tf_step *tf_diff_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsString(col_j)) return NULL;
+
+    diff_state *st = calloc(1, sizeof(diff_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+
+    cJSON *order_j = cJSON_GetObjectItemCaseSensitive(args, "order");
+    st->order = (cJSON_IsNumber(order_j) && order_j->valueint > 0) ?
+                order_j->valueint : 1;
+    if (st->order > MAX_DIFF_ORDER) st->order = MAX_DIFF_ORDER;
+
+    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_diff", 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 = diff_process;
+    step->flush = diff_flush;
+    step->destroy = diff_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_ewma.c

@@ -0,0 +1,103 @@
+/*
+ * op_ewma.c — Exponentially weighted moving average.
+ *
+ * Config: {"column": "price", "alpha": 0.3, "result": "price_ewma"}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char   *column;
+    char   *result;
+    double  alpha;
+    double  ewma;
+    int     initialized;
+} ewma_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 ewma_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    ewma_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_FLOAT64);
+
+    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);
+            ob->n_rows = r + 1;
+            continue;
+        }
+
+        double val = get_numeric(in, r, ci);
+        if (!st->initialized) {
+            st->ewma = val;
+            st->initialized = 1;
+        } else {
+            st->ewma = st->alpha * val + (1.0 - st->alpha) * st->ewma;
+        }
+
+        tf_batch_set_float64(ob, r, in->n_cols, st->ewma);
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int ewma_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void ewma_destroy(tf_step *self) {
+    ewma_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st); }
+    free(self);
+}
+
+tf_step *tf_ewma_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    cJSON *alpha_j = cJSON_GetObjectItemCaseSensitive(args, "alpha");
+    if (!cJSON_IsString(col_j) || !cJSON_IsNumber(alpha_j)) return NULL;
+
+    ewma_state *st = calloc(1, sizeof(ewma_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+    st->alpha = alpha_j->valuedouble;
+
+    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_ewma", 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 = ewma_process;
+    step->flush = ewma_flush;
+    step->destroy = ewma_destroy;
+    step->state = st;
+    return step;
+}