tranfi 0.0.1 → 0.1.2

package/csrc/op_step.c

@@ -0,0 +1,171 @@
+/*
+ * op_step.c — Running aggregations: running-sum, running-avg, running-min,
+ *             running-max, running-count, delta, lag, ratio.
+ *
+ * Config: {"column": "price", "func": "running-sum", "result": "cumsum"}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+typedef enum {
+    STEP_RUNNING_SUM,
+    STEP_RUNNING_AVG,
+    STEP_RUNNING_MIN,
+    STEP_RUNNING_MAX,
+    STEP_RUNNING_COUNT,
+    STEP_DELTA,
+    STEP_LAG,
+    STEP_RATIO,
+} step_func;
+
+typedef struct {
+    char     *column;
+    char     *result;
+    step_func func;
+    double    running_sum;
+    double    running_min;
+    double    running_max;
+    size_t    running_count;
+    double    prev_val;
+    int       has_prev;
+} step_state;
+
+static step_func parse_func(const char *s) {
+    if (strcmp(s, "running-sum") == 0 || strcmp(s, "cumsum") == 0) return STEP_RUNNING_SUM;
+    if (strcmp(s, "running-avg") == 0 || strcmp(s, "cumavg") == 0) return STEP_RUNNING_AVG;
+    if (strcmp(s, "running-min") == 0) return STEP_RUNNING_MIN;
+    if (strcmp(s, "running-max") == 0) return STEP_RUNNING_MAX;
+    if (strcmp(s, "running-count") == 0) return STEP_RUNNING_COUNT;
+    if (strcmp(s, "delta") == 0) return STEP_DELTA;
+    if (strcmp(s, "lag") == 0) return STEP_LAG;
+    if (strcmp(s, "ratio") == 0) return STEP_RATIO;
+    return STEP_RUNNING_SUM;
+}
+
+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 step_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    step_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);
+        double result = 0;
+
+        switch (st->func) {
+            case STEP_RUNNING_SUM:
+                st->running_sum += val;
+                result = st->running_sum;
+                break;
+            case STEP_RUNNING_AVG:
+                st->running_sum += val;
+                st->running_count++;
+                result = st->running_sum / st->running_count;
+                break;
+            case STEP_RUNNING_MIN:
+                if (st->running_count == 0 || val < st->running_min)
+                    st->running_min = val;
+                st->running_count++;
+                result = st->running_min;
+                break;
+            case STEP_RUNNING_MAX:
+                if (st->running_count == 0 || val > st->running_max)
+                    st->running_max = val;
+                st->running_count++;
+                result = st->running_max;
+                break;
+            case STEP_RUNNING_COUNT:
+                st->running_count++;
+                result = (double)st->running_count;
+                break;
+            case STEP_DELTA:
+                if (st->has_prev) result = val - st->prev_val;
+                else { tf_batch_set_null(ob, r, in->n_cols); st->prev_val = val; st->has_prev = 1; ob->n_rows = r + 1; continue; }
+                st->prev_val = val;
+                break;
+            case STEP_LAG:
+                if (st->has_prev) result = st->prev_val;
+                else { tf_batch_set_null(ob, r, in->n_cols); st->prev_val = val; st->has_prev = 1; ob->n_rows = r + 1; continue; }
+                st->prev_val = val;
+                break;
+            case STEP_RATIO:
+                if (st->has_prev && st->prev_val != 0) result = val / st->prev_val;
+                else { tf_batch_set_null(ob, r, in->n_cols); st->prev_val = val; st->has_prev = 1; ob->n_rows = r + 1; continue; }
+                st->prev_val = val;
+                break;
+        }
+
+        tf_batch_set_float64(ob, r, in->n_cols, result);
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int step_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void step_destroy(tf_step *self) {
+    step_state *st = self->state;
+    if (st) { free(st->column); free(st->result); free(st); }
+    free(self);
+}
+
+tf_step *tf_step_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    cJSON *func_j = cJSON_GetObjectItemCaseSensitive(args, "func");
+    if (!cJSON_IsString(col_j) || !cJSON_IsString(func_j)) return NULL;
+
+    step_state *st = calloc(1, sizeof(step_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+    st->func = parse_func(func_j->valuestring);
+
+    cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
+    if (cJSON_IsString(res_j)) {
+        st->result = strdup(res_j->valuestring);
+    } else {
+        /* Default result name */
+        char buf[256];
+        snprintf(buf, sizeof(buf), "%s_%s", st->column, func_j->valuestring);
+        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 = step_process;
+    step->flush = step_flush;
+    step->destroy = step_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_tail.c

@@ -0,0 +1,96 @@
+/*
+ * op_tail.c — Last N rows via circular buffer. Bounded memory.
+ *
+ * Config: {"n": 5}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    size_t    limit;
+    tf_batch *buf;       /* circular buffer of rows */
+    size_t    head;      /* next write position */
+    size_t    count;     /* total rows seen */
+    int       has_schema;
+} tail_state;
+
+static int tail_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    tail_state *st = self->state;
+    *out = NULL;
+
+    if (!st->has_schema) {
+        st->buf = tf_batch_create(in->n_cols, st->limit);
+        if (!st->buf) return TF_ERROR;
+        for (size_t c = 0; c < in->n_cols; c++)
+            tf_batch_set_schema(st->buf, c, in->col_names[c], in->col_types[c]);
+        st->buf->n_rows = 0;
+        st->has_schema = 1;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        size_t dst = st->head % st->limit;
+        tf_batch_copy_row(st->buf, dst, in, r);
+        st->head++;
+        st->count++;
+        if (st->buf->n_rows < st->limit) st->buf->n_rows++;
+    }
+
+    return TF_OK;
+}
+
+static int tail_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    tail_state *st = self->state;
+    *out = NULL;
+
+    if (!st->buf || st->buf->n_rows == 0) return TF_OK;
+
+    size_t n = st->buf->n_rows;
+    tf_batch *ob = tf_batch_create(st->buf->n_cols, n);
+    if (!ob) return TF_ERROR;
+    for (size_t c = 0; c < st->buf->n_cols; c++)
+        tf_batch_set_schema(ob, c, st->buf->col_names[c], st->buf->col_types[c]);
+
+    /* Read from circular buffer in order */
+    size_t start = (st->head >= n) ? (st->head - n) % st->limit : 0;
+    for (size_t i = 0; i < n; i++) {
+        size_t src = (start + i) % st->limit;
+        tf_batch_copy_row(ob, i, st->buf, src);
+        ob->n_rows = i + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static void tail_destroy(tf_step *self) {
+    tail_state *st = self->state;
+    if (st) {
+        if (st->buf) tf_batch_free(st->buf);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_tail_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *n_json = cJSON_GetObjectItemCaseSensitive(args, "n");
+    if (!cJSON_IsNumber(n_json) || n_json->valueint <= 0) return NULL;
+
+    tail_state *st = calloc(1, sizeof(tail_state));
+    if (!st) return NULL;
+    st->limit = (size_t)n_json->valueint;
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st); return NULL; }
+    step->process = tail_process;
+    step->flush = tail_flush;
+    step->destroy = tail_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_top.c

@@ -0,0 +1,150 @@
+/*
+ * op_top.c — Top N rows by column via sorted buffer.
+ *
+ * Config: {"n": 10, "column": "score", "desc": true}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    size_t    n;
+    char     *column;
+    int       desc;       /* 1 = highest first (default) */
+    tf_batch *buf;
+    int       has_schema;
+    int       col_idx;
+} top_state;
+
+static double top_get_val(const tf_batch *b, size_t r, int ci) {
+    if (tf_batch_is_null(b, r, ci)) return -1e308;
+    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);
+    if (b->col_types[ci] == TF_TYPE_STRING) return 0; /* string comparison not supported for top */
+    return 0;
+}
+
+static int top_process(tf_step *self, tf_batch *in, tf_batch **out,
+                       tf_side_channels *side) {
+    (void)side;
+    top_state *st = self->state;
+    *out = NULL;
+
+    if (!st->has_schema) {
+        st->buf = tf_batch_create(in->n_cols, st->n + 1);
+        if (!st->buf) return TF_ERROR;
+        for (size_t c = 0; c < in->n_cols; c++)
+            tf_batch_set_schema(st->buf, c, in->col_names[c], in->col_types[c]);
+        st->col_idx = tf_batch_col_index(in, st->column);
+        st->has_schema = 1;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        double new_val = top_get_val(in, r, st->col_idx >= 0 ? st->col_idx : 0);
+
+        if (st->buf->n_rows < st->n) {
+            /* Buffer not full, just add */
+            size_t dst = st->buf->n_rows;
+            tf_batch_copy_row(st->buf, dst, in, r);
+            st->buf->n_rows++;
+        } else {
+            /* Find the worst element */
+            size_t worst_idx = 0;
+            double worst_val = top_get_val(st->buf, 0, st->col_idx >= 0 ? st->col_idx : 0);
+            for (size_t i = 1; i < st->buf->n_rows; i++) {
+                double v = top_get_val(st->buf, i, st->col_idx >= 0 ? st->col_idx : 0);
+                if (st->desc ? (v < worst_val) : (v > worst_val)) {
+                    worst_val = v;
+                    worst_idx = i;
+                }
+            }
+            /* Replace worst if new value is better */
+            int replace = st->desc ? (new_val > worst_val) : (new_val < worst_val);
+            if (replace) {
+                tf_batch_copy_row(st->buf, worst_idx, in, r);
+            }
+        }
+    }
+
+    return TF_OK;
+}
+
+/* Sort comparator context */
+typedef struct { const tf_batch *batch; int col_idx; int desc; } top_sort_ctx;
+static top_sort_ctx *g_top_ctx;
+
+static int top_compare(const void *a, const void *b) {
+    size_t ra = *(const size_t *)a;
+    size_t rb = *(const size_t *)b;
+    double va = top_get_val(g_top_ctx->batch, ra, g_top_ctx->col_idx);
+    double vb = top_get_val(g_top_ctx->batch, rb, g_top_ctx->col_idx);
+    int cmp = (va > vb) - (va < vb);
+    return g_top_ctx->desc ? -cmp : cmp;
+}
+
+static int top_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    top_state *st = self->state;
+    *out = NULL;
+
+    if (!st->buf || st->buf->n_rows == 0) return TF_OK;
+
+    /* Sort the buffer */
+    size_t n = st->buf->n_rows;
+    size_t *indices = malloc(n * sizeof(size_t));
+    if (!indices) return TF_ERROR;
+    for (size_t i = 0; i < n; i++) indices[i] = i;
+
+    top_sort_ctx ctx = { .batch = st->buf, .col_idx = st->col_idx >= 0 ? st->col_idx : 0, .desc = st->desc };
+    g_top_ctx = &ctx;
+    qsort(indices, n, sizeof(size_t), top_compare);
+    g_top_ctx = NULL;
+
+    tf_batch *ob = tf_batch_create(st->buf->n_cols, n);
+    if (!ob) { free(indices); return TF_ERROR; }
+    for (size_t c = 0; c < st->buf->n_cols; c++)
+        tf_batch_set_schema(ob, c, st->buf->col_names[c], st->buf->col_types[c]);
+    for (size_t i = 0; i < n; i++) {
+        tf_batch_copy_row(ob, i, st->buf, indices[i]);
+        ob->n_rows = i + 1;
+    }
+
+    free(indices);
+    *out = ob;
+    return TF_OK;
+}
+
+static void top_destroy(tf_step *self) {
+    top_state *st = self->state;
+    if (st) {
+        free(st->column);
+        if (st->buf) tf_batch_free(st->buf);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_top_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *n_j = cJSON_GetObjectItemCaseSensitive(args, "n");
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsNumber(n_j) || !cJSON_IsString(col_j)) return NULL;
+
+    top_state *st = calloc(1, sizeof(top_state));
+    if (!st) return NULL;
+    st->n = (size_t)n_j->valueint;
+    st->column = strdup(col_j->valuestring);
+
+    cJSON *desc_j = cJSON_GetObjectItemCaseSensitive(args, "desc");
+    st->desc = (desc_j && cJSON_IsBool(desc_j)) ? cJSON_IsTrue(desc_j) : 1; /* default desc */
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->column); free(st); return NULL; }
+    step->process = top_process;
+    step->flush = top_flush;
+    step->destroy = top_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_trim.c

@@ -0,0 +1,109 @@
+/*
+ * op_trim.c — Trim whitespace from string columns.
+ *
+ * Config: {"columns": ["name", "city"]}
+ *   or {} for all string columns.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+typedef struct {
+    char  **cols;
+    size_t  n_cols;
+} trim_state;
+
+static const char *trim_str(const char *s, char *buf, size_t buf_sz) {
+    while (*s && isspace((unsigned char)*s)) s++;
+    size_t len = strlen(s);
+    while (len > 0 && isspace((unsigned char)s[len - 1])) len--;
+    if (len >= buf_sz) len = buf_sz - 1;
+    memcpy(buf, s, len);
+    buf[len] = '\0';
+    return buf;
+}
+
+static int trim_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    (void)side;
+    trim_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;
+    }
+
+    /* Trim target columns */
+    for (size_t c = 0; c < in->n_cols; c++) {
+        if (in->col_types[c] != TF_TYPE_STRING) continue;
+        int target = 0;
+        if (st->n_cols == 0) {
+            target = 1; /* all string cols */
+        } else {
+            for (size_t k = 0; k < st->n_cols; k++) {
+                if (strcmp(in->col_names[c], st->cols[k]) == 0) { target = 1; break; }
+            }
+        }
+        if (!target) continue;
+        char buf[4096];
+        for (size_t r = 0; r < ob->n_rows; r++) {
+            if (tf_batch_is_null(ob, r, c)) continue;
+            const char *val = tf_batch_get_string(ob, r, c);
+            tf_batch_set_string(ob, r, c, trim_str(val, buf, sizeof(buf)));
+        }
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int trim_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void trim_destroy(tf_step *self) {
+    trim_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_trim_create(const cJSON *args) {
+    trim_state *st = calloc(1, sizeof(trim_state));
+    if (!st) return NULL;
+
+    if (args) {
+        cJSON *columns = cJSON_GetObjectItemCaseSensitive(args, "columns");
+        if (columns && cJSON_IsArray(columns)) {
+            int n = cJSON_GetArraySize(columns);
+            if (n > 0) {
+                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) { free(st); return NULL; }
+    step->process = trim_process;
+    step->flush = trim_flush;
+    step->destroy = trim_destroy;
+    step->state = st;
+    return step;
+}