tranfi 0.0.2 → 0.1.2

package/csrc/op_unique.c

@@ -0,0 +1,300 @@
+/*
+ * op_unique.c — Deduplicate rows by key columns using a hash set.
+ *
+ * Config: {"columns": ["name", "city"]}
+ *   or {} for dedup by all columns.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include "date_utils.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* ---- Simple hash set (open addressing) ---- */
+
+typedef struct {
+    char  **keys;
+    size_t  count;
+    size_t  cap;
+} hash_set;
+
+static void hs_init(hash_set *hs, size_t cap) {
+    hs->cap = cap;
+    hs->count = 0;
+    hs->keys = calloc(cap, sizeof(char *));
+}
+
+static uint32_t hs_hash(const char *key) {
+    uint32_t h = 5381;
+    for (const char *p = key; *p; p++)
+        h = ((h << 5) + h) ^ (uint32_t)(unsigned char)*p;
+    return h;
+}
+
+static int hs_grow(hash_set *hs) {
+    size_t new_cap = hs->cap * 2;
+    char **new_keys = calloc(new_cap, sizeof(char *));
+    if (!new_keys) return -1;
+
+    for (size_t i = 0; i < hs->cap; i++) {
+        if (hs->keys[i]) {
+            uint32_t idx = hs_hash(hs->keys[i]) % new_cap;
+            while (new_keys[idx]) idx = (idx + 1) % new_cap;
+            new_keys[idx] = hs->keys[i];
+        }
+    }
+    free(hs->keys);
+    hs->keys = new_keys;
+    hs->cap = new_cap;
+    return 0;
+}
+
+/* Returns 1 if key was newly inserted, 0 if already present, -1 on error */
+static int hs_insert(hash_set *hs, const char *key) {
+    if (hs->count * 4 >= hs->cap * 3) { /* load factor > 0.75 */
+        if (hs_grow(hs) != 0) return -1;
+    }
+    uint32_t idx = hs_hash(key) % hs->cap;
+    while (hs->keys[idx]) {
+        if (strcmp(hs->keys[idx], key) == 0) return 0; /* already exists */
+        idx = (idx + 1) % hs->cap;
+    }
+    hs->keys[idx] = strdup(key);
+    if (!hs->keys[idx]) return -1;
+    hs->count++;
+    return 1;
+}
+
+static void hs_free(hash_set *hs) {
+    for (size_t i = 0; i < hs->cap; i++) free(hs->keys[i]);
+    free(hs->keys);
+}
+
+/* ---- Unique transform ---- */
+
+typedef struct {
+    char    **key_cols;     /* column names to dedup by (NULL = all) */
+    size_t    n_key_cols;
+    hash_set  seen;
+} unique_state;
+
+static char *build_row_key(const tf_batch *b, size_t row,
+                           int *col_indices, size_t n_keys) {
+    /* Build key by concatenating column values with \x01 separator */
+    size_t buf_cap = 256;
+    char *buf = malloc(buf_cap);
+    if (!buf) return NULL;
+    size_t buf_len = 0;
+
+    for (size_t k = 0; k < n_keys; k++) {
+        int c = col_indices[k];
+        if (c < 0) continue;
+
+        if (k > 0) {
+            if (buf_len + 1 >= buf_cap) {
+                buf_cap *= 2;
+                char *tmp = realloc(buf, buf_cap);
+                if (!tmp) { free(buf); return NULL; }
+                buf = tmp;
+            }
+            buf[buf_len++] = '\x01';
+        }
+
+        char val_buf[64];
+        const char *val = NULL;
+        size_t val_len = 0;
+
+        if (tf_batch_is_null(b, row, c)) {
+            val = "\\N";
+            val_len = 2;
+        } else {
+            switch (b->col_types[c]) {
+                case TF_TYPE_BOOL:
+                    val = tf_batch_get_bool(b, row, c) ? "T" : "F";
+                    val_len = 1;
+                    break;
+                case TF_TYPE_INT64:
+                    val_len = snprintf(val_buf, sizeof(val_buf), "%lld",
+                                       (long long)tf_batch_get_int64(b, row, c));
+                    val = val_buf;
+                    break;
+                case TF_TYPE_FLOAT64:
+                    val_len = snprintf(val_buf, sizeof(val_buf), "%.17g",
+                                       tf_batch_get_float64(b, row, c));
+                    val = val_buf;
+                    break;
+                case TF_TYPE_STRING:
+                    val = tf_batch_get_string(b, row, c);
+                    val_len = strlen(val);
+                    break;
+                case TF_TYPE_DATE:
+                    val_len = snprintf(val_buf, sizeof(val_buf), "%d",
+                                       (int)tf_batch_get_date(b, row, c));
+                    val = val_buf;
+                    break;
+                case TF_TYPE_TIMESTAMP:
+                    val_len = snprintf(val_buf, sizeof(val_buf), "%lld",
+                                       (long long)tf_batch_get_timestamp(b, row, c));
+                    val = val_buf;
+                    break;
+                default:
+                    val = "\\N";
+                    val_len = 2;
+                    break;
+            }
+        }
+
+        while (buf_len + val_len >= buf_cap) {
+            buf_cap *= 2;
+            char *tmp = realloc(buf, buf_cap);
+            if (!tmp) { free(buf); return NULL; }
+            buf = tmp;
+        }
+        memcpy(buf + buf_len, val, val_len);
+        buf_len += val_len;
+    }
+    buf[buf_len] = '\0';
+    return buf;
+}
+
+static int unique_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    (void)side;
+    unique_state *st = self->state;
+    *out = NULL;
+
+    /* Resolve column indices */
+    size_t n_keys;
+    int *col_indices;
+    if (st->n_key_cols > 0) {
+        n_keys = st->n_key_cols;
+        col_indices = malloc(n_keys * sizeof(int));
+        if (!col_indices) return TF_ERROR;
+        for (size_t k = 0; k < n_keys; k++) {
+            col_indices[k] = tf_batch_col_index(in, st->key_cols[k]);
+        }
+    } else {
+        /* All columns */
+        n_keys = in->n_cols;
+        col_indices = malloc(n_keys * sizeof(int));
+        if (!col_indices) return TF_ERROR;
+        for (size_t k = 0; k < n_keys; k++) {
+            col_indices[k] = (int)k;
+        }
+    }
+
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) { free(col_indices); 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 out_row = 0;
+    for (size_t r = 0; r < in->n_rows; r++) {
+        char *key = build_row_key(in, r, col_indices, n_keys);
+        if (!key) { free(col_indices); tf_batch_free(ob); return TF_ERROR; }
+
+        int inserted = hs_insert(&st->seen, key);
+        free(key);
+        if (inserted < 0) { free(col_indices); tf_batch_free(ob); return TF_ERROR; }
+        if (inserted == 0) continue; /* duplicate */
+
+        /* Copy row */
+        tf_batch_ensure_capacity(ob, out_row + 1);
+        for (size_t c = 0; c < in->n_cols; c++) {
+            if (tf_batch_is_null(in, r, c)) {
+                tf_batch_set_null(ob, out_row, c);
+                continue;
+            }
+            switch (in->col_types[c]) {
+                case TF_TYPE_BOOL:
+                    tf_batch_set_bool(ob, out_row, c, tf_batch_get_bool(in, r, c));
+                    break;
+                case TF_TYPE_INT64:
+                    tf_batch_set_int64(ob, out_row, c, tf_batch_get_int64(in, r, c));
+                    break;
+                case TF_TYPE_FLOAT64:
+                    tf_batch_set_float64(ob, out_row, c, tf_batch_get_float64(in, r, c));
+                    break;
+                case TF_TYPE_STRING:
+                    tf_batch_set_string(ob, out_row, c, tf_batch_get_string(in, r, c));
+                    break;
+                case TF_TYPE_DATE:
+                    tf_batch_set_date(ob, out_row, c, tf_batch_get_date(in, r, c));
+                    break;
+                case TF_TYPE_TIMESTAMP:
+                    tf_batch_set_timestamp(ob, out_row, c, tf_batch_get_timestamp(in, r, c));
+                    break;
+                default:
+                    tf_batch_set_null(ob, out_row, c);
+                    break;
+            }
+        }
+        out_row++;
+    }
+    ob->n_rows = out_row;
+    free(col_indices);
+
+    if (out_row > 0) {
+        *out = ob;
+    } else {
+        tf_batch_free(ob);
+    }
+    return TF_OK;
+}
+
+static int unique_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void unique_destroy(tf_step *self) {
+    unique_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_key_cols; i++) free(st->key_cols[i]);
+        free(st->key_cols);
+        hs_free(&st->seen);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_unique_create(const cJSON *args) {
+    unique_state *st = calloc(1, sizeof(unique_state));
+    if (!st) return NULL;
+    hs_init(&st->seen, 256);
+
+    if (args) {
+        cJSON *columns = cJSON_GetObjectItemCaseSensitive(args, "columns");
+        if (columns && cJSON_IsArray(columns)) {
+            int n = cJSON_GetArraySize(columns);
+            if (n > 0) {
+                st->key_cols = calloc(n, sizeof(char *));
+                st->n_key_cols = n;
+                for (int i = 0; i < n; i++) {
+                    cJSON *item = cJSON_GetArrayItem(columns, i);
+                    if (cJSON_IsString(item)) {
+                        st->key_cols[i] = strdup(item->valuestring);
+                    }
+                }
+            }
+        }
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) {
+        for (size_t i = 0; i < st->n_key_cols; i++) free(st->key_cols[i]);
+        free(st->key_cols);
+        hs_free(&st->seen);
+        free(st);
+        return NULL;
+    }
+    step->process = unique_process;
+    step->flush = unique_flush;
+    step->destroy = unique_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_unpivot.c

@@ -0,0 +1,159 @@
+/*
+ * op_unpivot.c — Wide to long. Adds variable + value columns, multiplies rows.
+ *
+ * Config: {"columns": ["q1", "q2", "q3"]}
+ *   Keeps non-listed columns, melts listed columns into variable/value pairs.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include "date_utils.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char  **cols;
+    size_t  n_cols;
+} unpivot_state;
+
+static int unpivot_process(tf_step *self, tf_batch *in, tf_batch **out,
+                           tf_side_channels *side) {
+    (void)side;
+    unpivot_state *st = self->state;
+    *out = NULL;
+
+    /* Determine which columns are value columns and which are id columns */
+    int *is_value = calloc(in->n_cols, sizeof(int));
+    if (!is_value) return TF_ERROR;
+    size_t n_value = 0;
+    for (size_t c = 0; c < in->n_cols; c++) {
+        for (size_t k = 0; k < st->n_cols; k++) {
+            if (strcmp(in->col_names[c], st->cols[k]) == 0) {
+                is_value[c] = 1;
+                n_value++;
+                break;
+            }
+        }
+    }
+    size_t n_id = in->n_cols - n_value;
+    if (n_value == 0) { free(is_value); return TF_OK; }
+
+    /* Output: id columns + "variable" + "value" */
+    size_t out_n_cols = n_id + 2;
+    size_t max_rows = in->n_rows * n_value;
+    tf_batch *ob = tf_batch_create(out_n_cols, max_rows > 0 ? max_rows : 16);
+    if (!ob) { free(is_value); return TF_ERROR; }
+
+    size_t oc = 0;
+    for (size_t c = 0; c < in->n_cols; c++) {
+        if (!is_value[c])
+            tf_batch_set_schema(ob, oc++, in->col_names[c], in->col_types[c]);
+    }
+    tf_batch_set_schema(ob, oc, "variable", TF_TYPE_STRING);
+    tf_batch_set_schema(ob, oc + 1, "value", TF_TYPE_STRING);
+
+    size_t out_row = 0;
+    for (size_t r = 0; r < in->n_rows; r++) {
+        for (size_t c = 0; c < in->n_cols; c++) {
+            if (!is_value[c]) continue;
+
+            tf_batch_ensure_capacity(ob, out_row + 1);
+
+            /* Copy id columns */
+            size_t oidx = 0;
+            for (size_t ic = 0; ic < in->n_cols; ic++) {
+                if (is_value[ic]) continue;
+                if (tf_batch_is_null(in, r, ic))
+                    tf_batch_set_null(ob, out_row, oidx);
+                else {
+                    switch (in->col_types[ic]) {
+                        case TF_TYPE_BOOL: tf_batch_set_bool(ob, out_row, oidx, tf_batch_get_bool(in, r, ic)); break;
+                        case TF_TYPE_INT64: tf_batch_set_int64(ob, out_row, oidx, tf_batch_get_int64(in, r, ic)); break;
+                        case TF_TYPE_FLOAT64: tf_batch_set_float64(ob, out_row, oidx, tf_batch_get_float64(in, r, ic)); break;
+                        case TF_TYPE_STRING: tf_batch_set_string(ob, out_row, oidx, tf_batch_get_string(in, r, ic)); break;
+                        case TF_TYPE_DATE: tf_batch_set_date(ob, out_row, oidx, tf_batch_get_date(in, r, ic)); break;
+                        case TF_TYPE_TIMESTAMP: tf_batch_set_timestamp(ob, out_row, oidx, tf_batch_get_timestamp(in, r, ic)); break;
+                        default: tf_batch_set_null(ob, out_row, oidx); break;
+                    }
+                }
+                oidx++;
+            }
+
+            /* Set variable name */
+            tf_batch_set_string(ob, out_row, n_id, in->col_names[c]);
+
+            /* Set value (convert to string) */
+            if (tf_batch_is_null(in, r, c)) {
+                tf_batch_set_null(ob, out_row, n_id + 1);
+            } else {
+                char buf[64];
+                switch (in->col_types[c]) {
+                    case TF_TYPE_STRING: tf_batch_set_string(ob, out_row, n_id + 1, tf_batch_get_string(in, r, c)); break;
+                    case TF_TYPE_INT64:
+                        snprintf(buf, sizeof(buf), "%lld", (long long)tf_batch_get_int64(in, r, c));
+                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
+                    case TF_TYPE_FLOAT64:
+                        snprintf(buf, sizeof(buf), "%g", tf_batch_get_float64(in, r, c));
+                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
+                    case TF_TYPE_BOOL:
+                        tf_batch_set_string(ob, out_row, n_id + 1, 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));
+                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
+                    case TF_TYPE_TIMESTAMP:
+                        tf_timestamp_format(tf_batch_get_timestamp(in, r, c), buf, sizeof(buf));
+                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
+                    default:
+                        tf_batch_set_null(ob, out_row, n_id + 1); break;
+                }
+            }
+
+            ob->n_rows = ++out_row;
+        }
+    }
+
+    free(is_value);
+    if (out_row > 0) *out = ob;
+    else tf_batch_free(ob);
+    return TF_OK;
+}
+
+static int unpivot_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void unpivot_destroy(tf_step *self) {
+    unpivot_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
+        free(st->cols); free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_unpivot_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;
+
+    unpivot_state *st = calloc(1, sizeof(unpivot_state));
+    if (!st) return NULL;
+    st->cols = calloc(n, sizeof(char *));
+    st->n_cols = n;
+    for (int i = 0; i < n; i++) {
+        cJSON *item = cJSON_GetArrayItem(columns, i);
+        if (cJSON_IsString(item)) st->cols[i] = strdup(item->valuestring);
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { unpivot_destroy(&(tf_step){.state = st}); return NULL; }
+    step->process = unpivot_process;
+    step->flush = unpivot_flush;
+    step->destroy = unpivot_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_validate.c

@@ -0,0 +1,71 @@
+/*
+ * op_validate.c — Like filter but adds _valid bool column, keeps all rows.
+ *
+ * Config: {"expr": "col('age') > 0"}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    tf_expr *expr;
+} validate_state;
+
+static int validate_process(tf_step *self, tf_batch *in, tf_batch **out,
+                            tf_side_channels *side) {
+    (void)side;
+    validate_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, "_valid", TF_TYPE_BOOL);
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_copy_row(ob, r, in, r);
+        bool valid = false;
+        tf_expr_eval(st->expr, in, r, &valid);
+        tf_batch_set_bool(ob, r, in->n_cols, valid);
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int validate_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void validate_destroy(tf_step *self) {
+    validate_state *st = self->state;
+    if (st) { tf_expr_free(st->expr); free(st); }
+    free(self);
+}
+
+tf_step *tf_validate_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *expr_json = cJSON_GetObjectItemCaseSensitive(args, "expr");
+    if (!cJSON_IsString(expr_json)) return NULL;
+
+    tf_expr *expr = tf_expr_parse(expr_json->valuestring);
+    if (!expr) return NULL;
+
+    validate_state *st = calloc(1, sizeof(validate_state));
+    if (!st) { tf_expr_free(expr); return NULL; }
+    st->expr = expr;
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { tf_expr_free(expr); free(st); return NULL; }
+    step->process = validate_process;
+    step->flush = validate_flush;
+    step->destroy = validate_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_window.c

@@ -0,0 +1,150 @@
+/*
+ * op_window.c — Sliding window aggregations.
+ *
+ * Config: {"column": "price", "size": 3, "func": "avg", "result": "price_avg3"}
+ * Supported funcs: avg, sum, min, max, count
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+typedef enum {
+    WIN_AVG, WIN_SUM, WIN_MIN, WIN_MAX, WIN_COUNT,
+} win_func;
+
+typedef struct {
+    char    *column;
+    char    *result;
+    win_func func;
+    size_t   size;
+    double  *ring;     /* circular buffer */
+    size_t   head;     /* next write position */
+    size_t   count;    /* items in buffer */
+} window_state;
+
+static win_func parse_win_func(const char *s) {
+    if (strcmp(s, "avg") == 0) return WIN_AVG;
+    if (strcmp(s, "sum") == 0) return WIN_SUM;
+    if (strcmp(s, "min") == 0) return WIN_MIN;
+    if (strcmp(s, "max") == 0) return WIN_MAX;
+    if (strcmp(s, "count") == 0) return WIN_COUNT;
+    return WIN_AVG;
+}
+
+static int window_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    (void)side;
+    window_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 = 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);
+
+        /* Add to ring buffer */
+        st->ring[st->head] = val;
+        st->head = (st->head + 1) % st->size;
+        if (st->count < st->size) st->count++;
+
+        /* Compute window aggregate */
+        double result = 0;
+        switch (st->func) {
+            case WIN_SUM:
+            case WIN_AVG: {
+                double sum = 0;
+                for (size_t i = 0; i < st->count; i++) sum += st->ring[i];
+                result = (st->func == WIN_AVG) ? sum / st->count : sum;
+                break;
+            }
+            case WIN_MIN: {
+                result = st->ring[0];
+                for (size_t i = 1; i < st->count; i++)
+                    if (st->ring[i] < result) result = st->ring[i];
+                break;
+            }
+            case WIN_MAX: {
+                result = st->ring[0];
+                for (size_t i = 1; i < st->count; i++)
+                    if (st->ring[i] > result) result = st->ring[i];
+                break;
+            }
+            case WIN_COUNT:
+                result = (double)st->count;
+                break;
+        }
+
+        tf_batch_set_float64(ob, r, in->n_cols, result);
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int window_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void window_destroy(tf_step *self) {
+    window_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st->ring); free(st); }
+    free(self);
+}
+
+tf_step *tf_window_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    cJSON *size_j = cJSON_GetObjectItemCaseSensitive(args, "size");
+    cJSON *func_j = cJSON_GetObjectItemCaseSensitive(args, "func");
+    if (!cJSON_IsString(col_j) || !cJSON_IsNumber(size_j) || !cJSON_IsString(func_j))
+        return NULL;
+
+    size_t win_size = (size_t)size_j->valueint;
+    if (win_size == 0) win_size = 1;
+
+    window_state *st = calloc(1, sizeof(window_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+    st->func = parse_win_func(func_j->valuestring);
+    st->size = win_size;
+    st->ring = calloc(win_size, sizeof(double));
+
+    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_%s%zu", st->column,
+                 func_j->valuestring, win_size);
+        st->result = strdup(buf);
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st->result); free(st->ring); free(st); return NULL; }
+    step->process = window_process;
+    step->flush = window_flush;
+    step->destroy = window_destroy;
+    step->state = st;
+    return step;
+}