tranfi 0.0.1 → 0.1.2

package/csrc/op_frequency.c

@@ -0,0 +1,193 @@
+/*
+ * op_frequency.c — Value counts. Hash map → emit sorted by count desc.
+ *
+ * Config: {"columns": ["city"]}
+ *   or {} for frequency of all columns concatenated.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include "date_utils.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char    **keys;
+    size_t   *counts;
+    size_t    count;
+    size_t    cap;
+} freq_map;
+
+typedef struct {
+    char  **cols;
+    size_t  n_cols;
+    freq_map map;
+} frequency_state;
+
+static char *build_freq_key(const tf_batch *b, size_t row,
+                            int *col_indices, size_t n_keys) {
+    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 (k > 0) { if (buf_len + 1 >= buf_cap) { buf_cap *= 2; buf = realloc(buf, buf_cap); } buf[buf_len++] = '\x01'; }
+        char val_buf[64];
+        const char *val;
+        size_t val_len;
+        if (c < 0 || tf_batch_is_null(b, row, c)) {
+            val = "\\N"; val_len = 2;
+        } else {
+            switch (b->col_types[c]) {
+                case TF_TYPE_STRING: val = tf_batch_get_string(b, row, c); val_len = strlen(val); 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), "%g", tf_batch_get_float64(b, row, c));
+                    val = val_buf; break;
+                case TF_TYPE_BOOL:
+                    val = tf_batch_get_bool(b, row, c) ? "T" : "F"; val_len = 1; 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 + 2 >= buf_cap) { buf_cap *= 2; buf = realloc(buf, buf_cap); }
+        memcpy(buf + buf_len, val, val_len);
+        buf_len += val_len;
+    }
+    buf[buf_len] = '\0';
+    return buf;
+}
+
+static int freq_add(freq_map *map, const char *key) {
+    for (size_t i = 0; i < map->count; i++) {
+        if (strcmp(map->keys[i], key) == 0) { map->counts[i]++; return 0; }
+    }
+    if (map->count >= map->cap) {
+        size_t new_cap = map->cap ? map->cap * 2 : 64;
+        map->keys = realloc(map->keys, new_cap * sizeof(char *));
+        map->counts = realloc(map->counts, new_cap * sizeof(size_t));
+        map->cap = new_cap;
+    }
+    map->keys[map->count] = strdup(key);
+    map->counts[map->count] = 1;
+    map->count++;
+    return 0;
+}
+
+static int frequency_process(tf_step *self, tf_batch *in, tf_batch **out,
+                             tf_side_channels *side) {
+    (void)side;
+    frequency_state *st = self->state;
+    *out = NULL;
+
+    size_t n_keys;
+    int *col_indices;
+    if (st->n_cols > 0) {
+        n_keys = st->n_cols;
+        col_indices = malloc(n_keys * sizeof(int));
+        for (size_t k = 0; k < n_keys; k++)
+            col_indices[k] = tf_batch_col_index(in, st->cols[k]);
+    } else {
+        n_keys = in->n_cols;
+        col_indices = malloc(n_keys * sizeof(int));
+        for (size_t k = 0; k < n_keys; k++) col_indices[k] = (int)k;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        char *key = build_freq_key(in, r, col_indices, n_keys);
+        if (!key) { free(col_indices); return TF_ERROR; }
+        freq_add(&st->map, key);
+        free(key);
+    }
+
+    free(col_indices);
+    return TF_OK;
+}
+
+static int frequency_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    frequency_state *st = self->state;
+    *out = NULL;
+
+    if (st->map.count == 0) return TF_OK;
+
+    /* Sort by count descending */
+    size_t n = st->map.count;
+    size_t *indices = malloc(n * sizeof(size_t));
+    if (!indices) return TF_ERROR;
+    for (size_t i = 0; i < n; i++) indices[i] = i;
+
+    /* Simple sort by count */
+    for (size_t i = 0; i < n - 1; i++) {
+        for (size_t j = i + 1; j < n; j++) {
+            if (st->map.counts[indices[j]] > st->map.counts[indices[i]]) {
+                size_t tmp = indices[i]; indices[i] = indices[j]; indices[j] = tmp;
+            }
+        }
+    }
+
+    tf_batch *ob = tf_batch_create(2, n);
+    if (!ob) { free(indices); return TF_ERROR; }
+    tf_batch_set_schema(ob, 0, "value", TF_TYPE_STRING);
+    tf_batch_set_schema(ob, 1, "count", TF_TYPE_INT64);
+
+    for (size_t i = 0; i < n; i++) {
+        tf_batch_ensure_capacity(ob, i + 1);
+        tf_batch_set_string(ob, i, 0, st->map.keys[indices[i]]);
+        tf_batch_set_int64(ob, i, 1, (int64_t)st->map.counts[indices[i]]);
+        ob->n_rows = i + 1;
+    }
+
+    free(indices);
+    *out = ob;
+    return TF_OK;
+}
+
+static void frequency_destroy(tf_step *self) {
+    frequency_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
+        free(st->cols);
+        for (size_t i = 0; i < st->map.count; i++) free(st->map.keys[i]);
+        free(st->map.keys); free(st->map.counts);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_frequency_create(const cJSON *args) {
+    frequency_state *st = calloc(1, sizeof(frequency_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) { frequency_destroy(&(tf_step){.state = st}); return NULL; }
+    step->process = frequency_process;
+    step->flush = frequency_flush;
+    step->destroy = frequency_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_grep.c

@@ -0,0 +1,163 @@
+/*
+ * op_grep.c — Substring/regex filter.
+ *
+ * Config: {"pattern": "error", "invert": false, "column": "_line", "regex": false}
+ * For each row, checks if column value matches pattern.
+ * Uses strstr for substring mode, regexec for regex mode.
+ * Keeps or discards based on invert flag.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <regex.h>
+
+typedef struct {
+    char   *pattern;
+    char   *column;
+    int     invert;
+    int     use_regex;
+    regex_t compiled;
+    size_t  rows_in;
+    size_t  rows_out;
+} grep_state;
+
+static int grep_process(tf_step *self, tf_batch *in, tf_batch **out,
+                        tf_side_channels *side) {
+    grep_state *st = self->state;
+    *out = NULL;
+
+    /* Find target column */
+    int col_idx = tf_batch_col_index(in, st->column);
+    if (col_idx < 0) {
+        /* Column not found — pass through or drop all depending on invert */
+        if (st->invert) {
+            *out = in;
+            /* Don't free — caller owns it, but we need to copy */
+            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 = in->n_rows;
+            *out = ob;
+        }
+        return TF_OK;
+    }
+
+    /* Create output batch with same schema */
+    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]);
+
+    size_t out_row = 0;
+    for (size_t r = 0; r < in->n_rows; r++) {
+        int match = 0;
+
+        if (tf_batch_is_null(in, r, (size_t)col_idx)) {
+            match = 0;
+        } else if (in->col_types[(size_t)col_idx] == TF_TYPE_STRING) {
+            const char *val = tf_batch_get_string(in, r, (size_t)col_idx);
+            if (st->use_regex) {
+                match = (regexec(&st->compiled, val, 0, NULL, 0) == 0) ? 1 : 0;
+            } else {
+                match = (strstr(val, st->pattern) != NULL) ? 1 : 0;
+            }
+        }
+
+        int keep = st->invert ? !match : match;
+        if (!keep) continue;
+
+        if (tf_batch_ensure_capacity(ob, out_row + 1) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+
+        tf_batch_copy_row(ob, out_row, in, r);
+        out_row++;
+    }
+    ob->n_rows = out_row;
+
+    st->rows_in += in->n_rows;
+    st->rows_out += out_row;
+
+    if (side && side->stats) {
+        char stats_buf[128];
+        snprintf(stats_buf, sizeof(stats_buf),
+                 "{\"op\":\"grep\",\"rows_in\":%zu,\"rows_out\":%zu}\n",
+                 in->n_rows, out_row);
+        tf_buffer_write_str(side->stats, stats_buf);
+    }
+
+    if (out_row > 0) {
+        *out = ob;
+    } else {
+        tf_batch_free(ob);
+    }
+    return TF_OK;
+}
+
+static int grep_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void grep_destroy(tf_step *self) {
+    grep_state *st = self->state;
+    if (st) {
+        if (st->use_regex) regfree(&st->compiled);
+        free(st->pattern);
+        free(st->column);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_grep_create(const cJSON *args) {
+    if (!args) return NULL;
+
+    cJSON *pattern_json = cJSON_GetObjectItemCaseSensitive(args, "pattern");
+    if (!cJSON_IsString(pattern_json)) return NULL;
+
+    grep_state *st = calloc(1, sizeof(grep_state));
+    if (!st) return NULL;
+
+    st->pattern = strdup(pattern_json->valuestring);
+    if (!st->pattern) { free(st); return NULL; }
+
+    cJSON *column_json = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (cJSON_IsString(column_json))
+        st->column = strdup(column_json->valuestring);
+    else
+        st->column = strdup("_line");
+    if (!st->column) { free(st->pattern); free(st); return NULL; }
+
+    cJSON *invert_json = cJSON_GetObjectItemCaseSensitive(args, "invert");
+    st->invert = (cJSON_IsBool(invert_json) && cJSON_IsTrue(invert_json)) ? 1 : 0;
+
+    cJSON *regex_json = cJSON_GetObjectItemCaseSensitive(args, "regex");
+    st->use_regex = (cJSON_IsBool(regex_json) && cJSON_IsTrue(regex_json)) ? 1 : 0;
+
+    if (st->use_regex) {
+        int rc = regcomp(&st->compiled, st->pattern, REG_EXTENDED | REG_NOSUB);
+        if (rc != 0) {
+            free(st->pattern);
+            free(st->column);
+            free(st);
+            return NULL;
+        }
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st->pattern); free(st->column); free(st); return NULL; }
+    step->process = grep_process;
+    step->flush = grep_flush;
+    step->destroy = grep_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_group_agg.c

@@ -0,0 +1,285 @@
+/*
+ * op_group_agg.c — Group by + aggregate (sum/avg/count/min/max).
+ *
+ * Config: {"group_by": ["city"], "aggs": [{"column": "sales", "func": "sum", "name": "total"}]}
+ * Buffers all rows, emits on flush.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include "date_utils.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef enum {
+    AGG_SUM, AGG_AVG, AGG_COUNT, AGG_MIN, AGG_MAX,
+} agg_func;
+
+typedef struct {
+    char    *column;
+    char    *name;
+    agg_func func;
+} agg_spec;
+
+typedef struct {
+    double  *sums;
+    double  *mins;
+    double  *maxs;
+    size_t  *counts;
+    size_t   n_aggs;
+} group_accum;
+
+typedef struct {
+    char  **keys;
+    group_accum *accums;
+    size_t  count;
+    size_t  cap;
+} group_map;
+
+typedef struct {
+    char      **group_cols;
+    size_t      n_group_cols;
+    agg_spec   *aggs;
+    size_t      n_aggs;
+    group_map   map;
+} group_agg_state;
+
+static agg_func parse_agg_func(const char *s) {
+    if (strcmp(s, "sum") == 0) return AGG_SUM;
+    if (strcmp(s, "avg") == 0) return AGG_AVG;
+    if (strcmp(s, "count") == 0) return AGG_COUNT;
+    if (strcmp(s, "min") == 0) return AGG_MIN;
+    if (strcmp(s, "max") == 0) return AGG_MAX;
+    return AGG_COUNT;
+}
+
+static char *build_group_key(const tf_batch *b, size_t row,
+                             int *col_indices, size_t n_keys) {
+    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 (k > 0) { buf[buf_len++] = '\x01'; }
+        char val_buf[64];
+        const char *val = "";
+        size_t val_len = 0;
+        if (c < 0 || tf_batch_is_null(b, row, c)) {
+            val = "\\N"; val_len = 2;
+        } else {
+            switch (b->col_types[c]) {
+                case TF_TYPE_STRING: val = tf_batch_get_string(b, row, c); val_len = strlen(val); 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_BOOL:
+                    val = tf_batch_get_bool(b, row, c) ? "T" : "F"; val_len = 1; 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 + 2 >= buf_cap) { buf_cap *= 2; buf = realloc(buf, buf_cap); }
+        memcpy(buf + buf_len, val, val_len);
+        buf_len += val_len;
+    }
+    buf[buf_len] = '\0';
+    return buf;
+}
+
+static int find_or_add_group(group_map *map, const char *key, size_t n_aggs) {
+    for (size_t i = 0; i < map->count; i++) {
+        if (strcmp(map->keys[i], key) == 0) return (int)i;
+    }
+    if (map->count >= map->cap) {
+        size_t new_cap = map->cap ? map->cap * 2 : 64;
+        map->keys = realloc(map->keys, new_cap * sizeof(char *));
+        map->accums = realloc(map->accums, new_cap * sizeof(group_accum));
+        map->cap = new_cap;
+    }
+    size_t idx = map->count++;
+    map->keys[idx] = strdup(key);
+    group_accum *a = &map->accums[idx];
+    a->n_aggs = n_aggs;
+    a->sums = calloc(n_aggs, sizeof(double));
+    a->mins = malloc(n_aggs * sizeof(double));
+    a->maxs = malloc(n_aggs * sizeof(double));
+    a->counts = calloc(n_aggs, sizeof(size_t));
+    for (size_t i = 0; i < n_aggs; i++) { a->mins[i] = 1e308; a->maxs[i] = -1e308; }
+    return (int)idx;
+}
+
+static int group_agg_process(tf_step *self, tf_batch *in, tf_batch **out,
+                             tf_side_channels *side) {
+    (void)side;
+    group_agg_state *st = self->state;
+    *out = NULL;
+
+    int *group_indices = malloc(st->n_group_cols * sizeof(int));
+    int *agg_indices = malloc(st->n_aggs * sizeof(int));
+    if (!group_indices || !agg_indices) { free(group_indices); free(agg_indices); return TF_ERROR; }
+
+    for (size_t k = 0; k < st->n_group_cols; k++)
+        group_indices[k] = tf_batch_col_index(in, st->group_cols[k]);
+    for (size_t k = 0; k < st->n_aggs; k++)
+        agg_indices[k] = tf_batch_col_index(in, st->aggs[k].column);
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        char *key = build_group_key(in, r, group_indices, st->n_group_cols);
+        if (!key) { free(group_indices); free(agg_indices); return TF_ERROR; }
+        int gi = find_or_add_group(&st->map, key, st->n_aggs);
+        free(key);
+        if (gi < 0) { free(group_indices); free(agg_indices); return TF_ERROR; }
+
+        group_accum *a = &st->map.accums[gi];
+        for (size_t k = 0; k < st->n_aggs; k++) {
+            int ci = agg_indices[k];
+            if (st->aggs[k].func == AGG_COUNT) {
+                a->counts[k]++;
+                continue;
+            }
+            if (ci < 0 || tf_batch_is_null(in, r, ci)) continue;
+            double v = 0;
+            if (in->col_types[ci] == TF_TYPE_INT64) v = (double)tf_batch_get_int64(in, r, ci);
+            else if (in->col_types[ci] == TF_TYPE_FLOAT64) v = tf_batch_get_float64(in, r, ci);
+            a->sums[k] += v;
+            if (v < a->mins[k]) a->mins[k] = v;
+            if (v > a->maxs[k]) a->maxs[k] = v;
+            a->counts[k]++;
+        }
+    }
+
+    free(group_indices);
+    free(agg_indices);
+    return TF_OK;
+}
+
+static int group_agg_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    group_agg_state *st = self->state;
+    *out = NULL;
+
+    if (st->map.count == 0) return TF_OK;
+
+    size_t n_out_cols = st->n_group_cols + st->n_aggs;
+    tf_batch *ob = tf_batch_create(n_out_cols, st->map.count);
+    if (!ob) return TF_ERROR;
+
+    for (size_t k = 0; k < st->n_group_cols; k++)
+        tf_batch_set_schema(ob, k, st->group_cols[k], TF_TYPE_STRING);
+    for (size_t k = 0; k < st->n_aggs; k++)
+        tf_batch_set_schema(ob, st->n_group_cols + k, st->aggs[k].name, TF_TYPE_FLOAT64);
+
+    for (size_t g = 0; g < st->map.count; g++) {
+        tf_batch_ensure_capacity(ob, g + 1);
+
+        /* Parse group key back to column values */
+        char *key = strdup(st->map.keys[g]);
+        char *p = key;
+        for (size_t k = 0; k < st->n_group_cols; k++) {
+            char *sep = strchr(p, '\x01');
+            if (sep) *sep = '\0';
+            if (strcmp(p, "\\N") == 0)
+                tf_batch_set_null(ob, g, k);
+            else
+                tf_batch_set_string(ob, g, k, p);
+            p = sep ? sep + 1 : p + strlen(p);
+        }
+        free(key);
+
+        /* Set aggregates */
+        group_accum *a = &st->map.accums[g];
+        for (size_t k = 0; k < st->n_aggs; k++) {
+            double v = 0;
+            switch (st->aggs[k].func) {
+                case AGG_SUM: v = a->sums[k]; break;
+                case AGG_AVG: v = a->counts[k] > 0 ? a->sums[k] / a->counts[k] : 0; break;
+                case AGG_COUNT: v = (double)a->counts[k]; break;
+                case AGG_MIN: v = a->counts[k] > 0 ? a->mins[k] : 0; break;
+                case AGG_MAX: v = a->counts[k] > 0 ? a->maxs[k] : 0; break;
+            }
+            tf_batch_set_float64(ob, g, st->n_group_cols + k, v);
+        }
+        ob->n_rows = g + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static void group_agg_destroy(tf_step *self) {
+    group_agg_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_group_cols; i++) free(st->group_cols[i]);
+        free(st->group_cols);
+        for (size_t i = 0; i < st->n_aggs; i++) { free(st->aggs[i].column); free(st->aggs[i].name); }
+        free(st->aggs);
+        for (size_t i = 0; i < st->map.count; i++) {
+            free(st->map.keys[i]);
+            free(st->map.accums[i].sums);
+            free(st->map.accums[i].mins);
+            free(st->map.accums[i].maxs);
+            free(st->map.accums[i].counts);
+        }
+        free(st->map.keys);
+        free(st->map.accums);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_group_agg_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *group_by = cJSON_GetObjectItemCaseSensitive(args, "group_by");
+    cJSON *aggs_j = cJSON_GetObjectItemCaseSensitive(args, "aggs");
+    if (!cJSON_IsArray(group_by) || !cJSON_IsArray(aggs_j)) return NULL;
+
+    group_agg_state *st = calloc(1, sizeof(group_agg_state));
+    if (!st) return NULL;
+
+    int ng = cJSON_GetArraySize(group_by);
+    st->group_cols = calloc(ng, sizeof(char *));
+    st->n_group_cols = ng;
+    for (int i = 0; i < ng; i++) {
+        cJSON *item = cJSON_GetArrayItem(group_by, i);
+        if (cJSON_IsString(item)) st->group_cols[i] = strdup(item->valuestring);
+    }
+
+    int na = cJSON_GetArraySize(aggs_j);
+    st->aggs = calloc(na, sizeof(agg_spec));
+    st->n_aggs = na;
+    for (int i = 0; i < na; i++) {
+        cJSON *item = cJSON_GetArrayItem(aggs_j, i);
+        cJSON *col = cJSON_GetObjectItemCaseSensitive(item, "column");
+        cJSON *func = cJSON_GetObjectItemCaseSensitive(item, "func");
+        cJSON *name = cJSON_GetObjectItemCaseSensitive(item, "name");
+        st->aggs[i].column = strdup(cJSON_IsString(col) ? col->valuestring : "");
+        st->aggs[i].func = cJSON_IsString(func) ? parse_agg_func(func->valuestring) : AGG_COUNT;
+        if (cJSON_IsString(name)) {
+            st->aggs[i].name = strdup(name->valuestring);
+        } else {
+            char buf[256];
+            snprintf(buf, sizeof(buf), "%s_%s",
+                     st->aggs[i].column,
+                     cJSON_IsString(func) ? func->valuestring : "count");
+            st->aggs[i].name = strdup(buf);
+        }
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { group_agg_destroy(&(tf_step){.state = st}); return NULL; }
+    step->process = group_agg_process;
+    step->flush = group_agg_flush;
+    step->destroy = group_agg_destroy;
+    step->state = st;
+    return step;
+}