tranfi 0.0.2 → 0.2.0

package/csrc/op_diff.c

@@ -0,0 +1,250 @@
+/*
+ * 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 enum {
+    DIFF_MISSING_ERROR,
+    DIFF_MISSING_NULL,
+    DIFF_MISSING_IGNORE,
+} diff_missing_policy;
+
+typedef enum {
+    DIFF_TYPE_FAIL,
+    DIFF_TYPE_NULL,
+} diff_type_policy;
+
+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_missing_policy missing;
+    diff_type_policy on_type_error;
+} diff_state;
+
+static int diff_is_numeric_type(tf_type type) {
+    return type == TF_TYPE_INT64 || type == TF_TYPE_FLOAT64;
+}
+
+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);
+    return tf_batch_get_float64(b, r, ci);
+}
+
+static void diff_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "diff: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int diff_parse_missing_policy(const cJSON *args, diff_missing_policy *out) {
+    *out = DIFF_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("diff: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = DIFF_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DIFF_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = DIFF_MISSING_IGNORE;
+    else {
+        tf_set_last_error("diff: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int diff_parse_type_policy(const cJSON *args, diff_type_policy *out) {
+    *out = DIFF_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("diff: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = DIFF_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = DIFF_TYPE_NULL;
+    else {
+        tf_set_last_error("diff: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int diff_passthrough(tf_batch *in, tf_batch **out) {
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK ||
+            tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
+}
+
+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;
+
+    int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == DIFF_MISSING_ERROR) {
+            diff_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == DIFF_MISSING_IGNORE) {
+            return diff_passthrough(in, out);
+        }
+        force_null = 1;
+    } else if (!diff_is_numeric_type(in->col_types[(size_t)ci])) {
+        if (st->on_type_error == DIFF_TYPE_FAIL) {
+            diff_set_col_error(st->column, "must be numeric");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_FLOAT64};
+    tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+
+        if (force_null || tf_batch_is_null(in, r, (size_t)ci)) {
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            continue;
+        }
+
+        double val = get_numeric(in, r, ci);
+
+        if (st->count < st->order) {
+            /* Not enough history yet -- shift and insert at front
+             * so prev[0] is always the most recent value */
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            for (int k = st->count; k > 0; k--)
+                st->prev[k] = st->prev[k - 1];
+            st->prev[0] = val;
+            st->count++;
+            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];
+        }
+
+        if (tf_batch_set_float64(ob, r, in->n_cols, result) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+
+        /* 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) || !col_j->valuestring[0]) {
+        tf_set_last_error("diff: column is required");
+        return NULL;
+    }
+
+    diff_state *st = tf_callocarray_checked(1, sizeof(diff_state));
+    if (!st) return NULL;
+    st->column = tf_strdup_checked(col_j->valuestring);
+    if (!st->column) { free(st); return NULL; }
+
+    size_t order = 1;
+    int has_order = tf_json_get_size_arg(args, "order", 1, MAX_DIFF_ORDER, &order, "diff");
+    if (has_order < 0) { free(st->column); free(st); return NULL; }
+    st->order = (int)order;
+    if (diff_parse_missing_policy(args, &st->missing) != TF_OK ||
+        diff_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
+
+    cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
+    if (cJSON_IsString(res_j)) {
+        st->result = tf_strdup_checked(res_j->valuestring);
+    } else {
+        st->result = tf_string_append_suffix_checked(st->column, "_diff");
+    }
+    if (!st->result) { free(st->column); free(st); return NULL; }
+
+    tf_step *step = tf_callocarray_checked(1, 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,222 @@
+/*
+ * 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>
+#include <math.h>
+
+typedef enum {
+    EWMA_MISSING_ERROR,
+    EWMA_MISSING_NULL,
+    EWMA_MISSING_IGNORE,
+} ewma_missing_policy;
+
+typedef enum {
+    EWMA_TYPE_FAIL,
+    EWMA_TYPE_NULL,
+} ewma_type_policy;
+
+typedef struct {
+    char   *column;
+    char   *result;
+    double  alpha;
+    double  ewma;
+    int     initialized;
+    ewma_missing_policy missing;
+    ewma_type_policy on_type_error;
+} ewma_state;
+
+static int ewma_is_numeric_type(tf_type type) {
+    return type == TF_TYPE_INT64 || type == TF_TYPE_FLOAT64;
+}
+
+static double ewma_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);
+    return tf_batch_get_float64(b, r, ci);
+}
+
+static void ewma_set_col_error(const char *column, const char *suffix) {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "ewma: column '%s' %s", column ? column : "", suffix);
+    tf_set_last_error(msg);
+}
+
+static int ewma_parse_missing_policy(const cJSON *args, ewma_missing_policy *out) {
+    *out = EWMA_MISSING_ERROR;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "missing");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("ewma: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "error") == 0) *out = EWMA_MISSING_ERROR;
+    else if (strcmp(j->valuestring, "null") == 0) *out = EWMA_MISSING_NULL;
+    else if (strcmp(j->valuestring, "ignore") == 0) *out = EWMA_MISSING_IGNORE;
+    else {
+        tf_set_last_error("ewma: missing must be error, null, or ignore");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int ewma_parse_type_policy(const cJSON *args, ewma_type_policy *out) {
+    *out = EWMA_TYPE_FAIL;
+    const cJSON *j = cJSON_GetObjectItemCaseSensitive(args, "on_type_error");
+    if (!j) return TF_OK;
+    if (!cJSON_IsString(j)) {
+        tf_set_last_error("ewma: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    if (strcmp(j->valuestring, "fail") == 0) *out = EWMA_TYPE_FAIL;
+    else if (strcmp(j->valuestring, "null") == 0) *out = EWMA_TYPE_NULL;
+    else {
+        tf_set_last_error("ewma: on_type_error must be fail or null");
+        return TF_ERROR;
+    }
+    return TF_OK;
+}
+
+static int ewma_passthrough(tf_batch *in, tf_batch **out) {
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+    *out = ob;
+    return TF_OK;
+}
+
+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;
+
+    int ci = tf_batch_col_index(in, st->column);
+    int force_null = 0;
+    if (ci < 0) {
+        if (st->missing == EWMA_MISSING_ERROR) {
+            ewma_set_col_error(st->column, "not found");
+            return TF_ERROR;
+        }
+        if (st->missing == EWMA_MISSING_IGNORE) return ewma_passthrough(in, out);
+        force_null = 1;
+    } else if (!ewma_is_numeric_type(in->col_types[ci])) {
+        if (st->on_type_error == EWMA_TYPE_FAIL) {
+            ewma_set_col_error(st->column, "must be numeric");
+            return TF_ERROR;
+        }
+        force_null = 1;
+    }
+
+    const char *extra_names[1] = {st->result};
+    tf_type extra_types[1] = {TF_TYPE_FLOAT64};
+    tf_batch *ob = tf_batch_create(in->n_cols + 1, in->n_rows);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_with_extra_cols(ob, in, extra_names, extra_types, 1) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+
+        if (force_null || tf_batch_is_null(in, r, ci)) {
+            if (tf_batch_set_null(ob, r, in->n_cols) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            if (tf_batch_expose_row(ob, r) != TF_OK) { tf_batch_free(ob); return TF_ERROR; }
+            continue;
+        }
+
+        double val = ewma_get_numeric(in, r, ci);
+        double next_ewma = st->initialized
+            ? st->alpha * val + (1.0 - st->alpha) * st->ewma
+            : val;
+
+        if (tf_batch_set_float64(ob, r, in->n_cols, next_ewma) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        st->ewma = next_ewma;
+        st->initialized = 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) || !col_j->valuestring[0] || !cJSON_IsNumber(alpha_j)) {
+        tf_set_last_error("ewma: column and alpha are required");
+        return NULL;
+    }
+    double alpha = alpha_j->valuedouble;
+    if (!isfinite(alpha) || alpha < 0.0 || alpha > 1.0) {
+        tf_set_last_error("ewma: alpha must be a finite number between 0 and 1");
+        return NULL;
+    }
+
+    ewma_state *st = tf_callocarray_checked(1, sizeof(ewma_state));
+    if (!st) return NULL;
+    st->column = tf_strdup_checked(col_j->valuestring);
+    st->alpha = alpha;
+    if (!st->column) { free(st); return NULL; }
+    if (ewma_parse_missing_policy(args, &st->missing) != TF_OK ||
+        ewma_parse_type_policy(args, &st->on_type_error) != TF_OK) {
+        free(st->column);
+        free(st);
+        return NULL;
+    }
+
+    cJSON *res_j = cJSON_GetObjectItemCaseSensitive(args, "result");
+    if (cJSON_IsString(res_j)) {
+        st->result = tf_strdup_checked(res_j->valuestring);
+    } else {
+        st->result = tf_string_append_suffix_checked(st->column, "_ewma");
+    }
+    if (!st->result) { free(st->column); free(st); return NULL; }
+
+    tf_step *step = tf_callocarray_checked(1, 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;
+}

package/csrc/op_explode.c

@@ -0,0 +1,206 @@
+/*
+ * op_explode.c -- Split delimited string into multiple rows.
+ *
+ * Config: {"column": "tags", "delimiter": ",", "max_tokens_per_row": 1024}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    char *column;
+    char *delimiter;
+    size_t max_tokens_per_row;
+    size_t max_output_rows_per_input_row;
+    size_t max_output_rows_per_batch;
+    size_t max_token_bytes;
+} explode_state;
+
+static int explode_set_cap_error(const char *name, size_t limit) {
+    char msg[160];
+    snprintf(msg, sizeof(msg), "explode: %s=%zu exceeded", name, limit);
+    tf_set_last_error(msg);
+    return TF_ERROR;
+}
+
+static int explode_process(tf_step *self, tf_batch *in, tf_batch **out,
+                           tf_side_channels *side) {
+    (void)side;
+    explode_state *st = self->state;
+    *out = NULL;
+
+    int ci = tf_batch_col_index(in, st->column);
+
+    size_t initial_cap = in->n_rows ? in->n_rows : 1;
+    if (initial_cap > st->max_output_rows_per_batch)
+        initial_cap = st->max_output_rows_per_batch;
+    if (initial_cap < 16 && st->max_output_rows_per_batch >= 16)
+        initial_cap = 16;
+    tf_batch *ob = tf_batch_create(in->n_cols, initial_cap);
+    if (!ob) return TF_ERROR;
+    if (tf_batch_clone_schema(ob, in) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    size_t out_row = 0;
+    size_t delim_len = strlen(st->delimiter);
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (ci < 0 || tf_batch_is_null(in, r, ci) || in->col_types[ci] != TF_TYPE_STRING) {
+            if (out_row >= st->max_output_rows_per_batch) {
+                explode_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            out_row++;
+            continue;
+        }
+
+        const char *val = tf_batch_get_string(in, r, ci);
+        const char *p = val;
+        size_t row_outputs = 0;
+
+        while (*p) {
+            if (row_outputs >= st->max_tokens_per_row) {
+                explode_set_cap_error("max_tokens_per_row", st->max_tokens_per_row);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (row_outputs >= st->max_output_rows_per_input_row) {
+                explode_set_cap_error("max_output_rows_per_input_row", st->max_output_rows_per_input_row);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (out_row >= st->max_output_rows_per_batch) {
+                explode_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+
+            const char *found = strstr(p, st->delimiter);
+            size_t tok_len = found ? (size_t)(found - p) : strlen(p);
+            if (tok_len > st->max_token_bytes) {
+                explode_set_cap_error("max_token_bytes", st->max_token_bytes);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            if (tf_batch_copy_row(ob, out_row, in, r) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            /* Override the exploded column */
+            size_t tok_cap = 0;
+            if (tf_size_add(tok_len, 1, &tok_cap) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            char *tok = malloc(tok_cap);
+            if (!tok) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            memcpy(tok, p, tok_len);
+            tok[tok_len] = '\0';
+            /* Trim leading/trailing whitespace */
+            char *s = tok;
+            while (*s == ' ') s++;
+            char *e = s + strlen(s);
+            while (e > s && *(e - 1) == ' ') e--;
+            *e = '\0';
+            if (tf_batch_set_string(ob, out_row, (size_t)ci, s) != TF_OK) {
+                free(tok);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            free(tok);
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) {
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            out_row++;
+            row_outputs++;
+
+            if (found) p = found + delim_len;
+            else break;
+        }
+    }
+
+    if (out_row > 0) {
+        *out = ob;
+    } else {
+        tf_batch_free(ob);
+    }
+    return TF_OK;
+}
+
+static int explode_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void explode_destroy(tf_step *self) {
+    explode_state *st = self->state;
+    if (st) { free(st->column); free(st->delimiter); free(st); }
+    free(self);
+}
+
+tf_step *tf_explode_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    if (!cJSON_IsString(col_j)) return NULL;
+
+    explode_state *st = calloc(1, sizeof(explode_state));
+    if (!st) return NULL;
+    st->max_tokens_per_row = TF_MAX_EXPLODE_TOKENS_PER_ROW;
+    st->max_output_rows_per_input_row = TF_MAX_EXPANDING_ROWS_PER_INPUT;
+    st->max_output_rows_per_batch = TF_MAX_OUTPUT_ROWS_PER_BATCH;
+    st->max_token_bytes = TF_MAX_RECORD_BYTES;
+
+    size_t parsed_size = 0;
+    int has_size = tf_json_get_size_arg(args, "max_tokens_per_row", 1, TF_MAX_EXPLODE_TOKENS_PER_ROW, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_tokens_per_row = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_output_rows_per_input_row", 1, TF_MAX_EXPANDING_ROWS_PER_INPUT, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_output_rows_per_input_row = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_output_rows_per_batch", 1, TF_MAX_OUTPUT_ROWS_PER_BATCH, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_output_rows_per_batch = parsed_size;
+    has_size = tf_json_get_size_arg(args, "max_token_bytes", 0, TF_MAX_RECORD_BYTES, &parsed_size, "explode");
+    if (has_size < 0) goto fail;
+    if (has_size > 0) st->max_token_bytes = parsed_size;
+
+    st->column = strdup(col_j->valuestring);
+    if (!st->column) goto fail;
+
+    cJSON *delim_j = cJSON_GetObjectItemCaseSensitive(args, "delimiter");
+    const char *delim = cJSON_IsString(delim_j) ? delim_j->valuestring : ",";
+    if (delim[0] == '\0') goto fail;
+    st->delimiter = strdup(delim);
+    if (!st->delimiter) goto fail;
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) goto fail;
+    step->process = explode_process;
+    step->flush = explode_flush;
+    step->destroy = explode_destroy;
+    step->state = st;
+    return step;
+
+fail:
+    free(st->column);
+    free(st->delimiter);
+    free(st);
+    return NULL;
+}