tranfi 0.0.1 → 0.1.2

package/csrc/op_rename.c

@@ -0,0 +1,138 @@
+/*
+ * op_rename.c — Rename columns.
+ *
+ * Config: {"mapping": {"old_name": "new_name", ...}}
+ * Creates output batch with renamed columns. Unmatched columns pass through.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    char  **old_names;
+    char  **new_names;
+    size_t  n_mappings;
+} rename_state;
+
+static const char *find_rename(rename_state *st, const char *name) {
+    for (size_t i = 0; i < st->n_mappings; i++) {
+        if (strcmp(st->old_names[i], name) == 0)
+            return st->new_names[i];
+    }
+    return name; /* unchanged */
+}
+
+static int rename_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    (void)side;
+    rename_state *st = self->state;
+
+    /* Create output batch with renamed columns */
+    tf_batch *ob = tf_batch_create(in->n_cols, in->n_rows);
+    if (!ob) return TF_ERROR;
+
+    for (size_t i = 0; i < in->n_cols; i++) {
+        const char *new_name = find_rename(st, in->col_names[i]);
+        tf_batch_set_schema(ob, i, new_name, in->col_types[i]);
+    }
+
+    /* Copy all rows */
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_ensure_capacity(ob, r + 1);
+        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;
+            }
+        }
+        ob->n_rows = r + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int rename_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void rename_destroy(tf_step *self) {
+    rename_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_mappings; i++) {
+            free(st->old_names[i]);
+            free(st->new_names[i]);
+        }
+        free(st->old_names);
+        free(st->new_names);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_rename_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *mapping = cJSON_GetObjectItemCaseSensitive(args, "mapping");
+    if (!mapping || !cJSON_IsObject(mapping)) return NULL;
+
+    int n = cJSON_GetArraySize(mapping);
+    if (n <= 0) return NULL;
+
+    rename_state *st = calloc(1, sizeof(rename_state));
+    if (!st) return NULL;
+    st->n_mappings = (size_t)n;
+    st->old_names = malloc(n * sizeof(char *));
+    st->new_names = malloc(n * sizeof(char *));
+    if (!st->old_names || !st->new_names) {
+        free(st->old_names);
+        free(st->new_names);
+        free(st);
+        return NULL;
+    }
+
+    int i = 0;
+    cJSON *item;
+    cJSON_ArrayForEach(item, mapping) {
+        st->old_names[i] = strdup(item->string);
+        st->new_names[i] = strdup(cJSON_IsString(item) ? item->valuestring : item->string);
+        i++;
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) {
+        rename_destroy(&(tf_step){.state = st});
+        return NULL;
+    }
+    step->process = rename_process;
+    step->flush = rename_flush;
+    step->destroy = rename_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_replace.c

@@ -0,0 +1,202 @@
+/*
+ * op_replace.c — String find/replace (substring or regex).
+ *
+ * Config: {"column": "name", "pattern": "foo", "replacement": "bar", "regex": false}
+ * In regex mode, & in replacement refers to the whole match.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <regex.h>
+
+typedef struct {
+    char   *column;
+    char   *pattern;
+    char   *replacement;
+    int     use_regex;
+    regex_t compiled;
+} replace_state;
+
+static int replace_process(tf_step *self, tf_batch *in, tf_batch **out,
+                           tf_side_channels *side) {
+    (void)side;
+    replace_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;
+    }
+
+    int ci = tf_batch_col_index(ob, st->column);
+    if (ci >= 0 && ob->col_types[ci] == TF_TYPE_STRING) {
+        if (st->use_regex) {
+            /* Regex mode: use regexec to find matches */
+            for (size_t r = 0; r < ob->n_rows; r++) {
+                if (tf_batch_is_null(ob, r, ci)) continue;
+                const char *val = tf_batch_get_string(ob, r, ci);
+                /* Build result by repeatedly matching and replacing */
+                size_t val_len = strlen(val);
+                size_t buf_cap = val_len * 2 + 64;
+                char *buf = malloc(buf_cap);
+                if (!buf) continue;
+                size_t buf_len = 0;
+                const char *p = val;
+                regmatch_t match;
+                int replaced = 0;
+                while (regexec(&st->compiled, p, 1, &match, 0) == 0 && match.rm_so >= 0) {
+                    replaced = 1;
+                    size_t prefix = (size_t)match.rm_so;
+                    size_t match_len = (size_t)(match.rm_eo - match.rm_so);
+                    /* Expand replacement: & refers to whole match */
+                    size_t rep_need = 0;
+                    for (const char *rp = st->replacement; *rp; rp++) {
+                        if (*rp == '&') rep_need += match_len;
+                        else rep_need++;
+                    }
+                    size_t need = buf_len + prefix + rep_need + 1;
+                    if (need > buf_cap) {
+                        buf_cap = need * 2;
+                        char *nb = realloc(buf, buf_cap);
+                        if (!nb) { free(buf); buf = NULL; break; }
+                        buf = nb;
+                    }
+                    memcpy(buf + buf_len, p, prefix);
+                    buf_len += prefix;
+                    for (const char *rp = st->replacement; *rp; rp++) {
+                        if (*rp == '&') {
+                            memcpy(buf + buf_len, p + match.rm_so, match_len);
+                            buf_len += match_len;
+                        } else {
+                            buf[buf_len++] = *rp;
+                        }
+                    }
+                    p += match.rm_eo;
+                    if (match_len == 0) {
+                        /* Zero-length match: copy one char to avoid infinite loop */
+                        if (*p) {
+                            if (buf_len + 2 > buf_cap) {
+                                buf_cap = (buf_len + 2) * 2;
+                                char *nb = realloc(buf, buf_cap);
+                                if (!nb) { free(buf); buf = NULL; break; }
+                                buf = nb;
+                            }
+                            buf[buf_len++] = *p++;
+                        } else break;
+                    }
+                }
+                if (buf && replaced) {
+                    /* Copy remaining */
+                    size_t rest = strlen(p);
+                    if (buf_len + rest + 1 > buf_cap) {
+                        buf_cap = buf_len + rest + 1;
+                        char *nb = realloc(buf, buf_cap);
+                        if (!nb) { free(buf); continue; }
+                        buf = nb;
+                    }
+                    memcpy(buf + buf_len, p, rest);
+                    buf_len += rest;
+                    buf[buf_len] = '\0';
+                    tf_batch_set_string(ob, r, ci, buf);
+                }
+                free(buf);
+            }
+        } else {
+            /* Substring mode */
+            size_t pat_len = strlen(st->pattern);
+            size_t rep_len = strlen(st->replacement);
+            if (pat_len > 0) {
+                for (size_t r = 0; r < ob->n_rows; r++) {
+                    if (tf_batch_is_null(ob, r, ci)) continue;
+                    const char *val = tf_batch_get_string(ob, r, ci);
+                    /* Count occurrences */
+                    size_t count = 0;
+                    const char *p = val;
+                    while ((p = strstr(p, st->pattern)) != NULL) { count++; p += pat_len; }
+                    if (count == 0) continue;
+
+                    size_t new_len = strlen(val) + count * (rep_len - pat_len);
+                    char *buf = malloc(new_len + 1);
+                    if (!buf) continue;
+                    char *dst = buf;
+                    p = val;
+                    const char *found;
+                    while ((found = strstr(p, st->pattern)) != NULL) {
+                        size_t prefix = found - p;
+                        memcpy(dst, p, prefix);
+                        dst += prefix;
+                        memcpy(dst, st->replacement, rep_len);
+                        dst += rep_len;
+                        p = found + pat_len;
+                    }
+                    strcpy(dst, p);
+                    tf_batch_set_string(ob, r, ci, buf);
+                    free(buf);
+                }
+            }
+        }
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static int replace_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side; *out = NULL; return TF_OK;
+}
+
+static void replace_destroy(tf_step *self) {
+    replace_state *st = self->state;
+    if (st) {
+        if (st->use_regex) regfree(&st->compiled);
+        free(st->column);
+        free(st->pattern);
+        free(st->replacement);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_replace_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *col_j = cJSON_GetObjectItemCaseSensitive(args, "column");
+    cJSON *pat_j = cJSON_GetObjectItemCaseSensitive(args, "pattern");
+    cJSON *rep_j = cJSON_GetObjectItemCaseSensitive(args, "replacement");
+    if (!cJSON_IsString(col_j) || !cJSON_IsString(pat_j) || !cJSON_IsString(rep_j))
+        return NULL;
+
+    replace_state *st = calloc(1, sizeof(replace_state));
+    if (!st) return NULL;
+    st->column = strdup(col_j->valuestring);
+    st->pattern = strdup(pat_j->valuestring);
+    st->replacement = strdup(rep_j->valuestring);
+
+    cJSON *regex_j = cJSON_GetObjectItemCaseSensitive(args, "regex");
+    st->use_regex = (cJSON_IsBool(regex_j) && cJSON_IsTrue(regex_j)) ? 1 : 0;
+
+    if (st->use_regex) {
+        int rc = regcomp(&st->compiled, st->pattern, REG_EXTENDED);
+        if (rc != 0) {
+            free(st->column); free(st->pattern); free(st->replacement); free(st);
+            return NULL;
+        }
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) {
+        if (st->use_regex) regfree(&st->compiled);
+        free(st->column); free(st->pattern); free(st->replacement); free(st);
+        return NULL;
+    }
+    step->process = replace_process;
+    step->flush = replace_flush;
+    step->destroy = replace_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_sample.c

@@ -0,0 +1,101 @@
+/*
+ * op_sample.c — Reservoir sampling (Algorithm R). Bounded memory.
+ *
+ * Config: {"n": 100}
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+typedef struct {
+    size_t    n;
+    tf_batch *buf;
+    size_t    seen;       /* total rows seen */
+    int       has_schema;
+    unsigned  seed;
+} sample_state;
+
+static int sample_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    (void)side;
+    sample_state *st = self->state;
+    *out = NULL;
+
+    if (!st->has_schema) {
+        st->buf = tf_batch_create(in->n_cols, st->n);
+        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->has_schema = 1;
+    }
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        if (st->seen < st->n) {
+            /* Fill reservoir */
+            tf_batch_copy_row(st->buf, st->seen, in, r);
+            st->buf->n_rows = st->seen + 1;
+        } else {
+            /* Replace with probability n/seen */
+            size_t j = (size_t)(rand_r(&st->seed) % (st->seen + 1));
+            if (j < st->n) {
+                tf_batch_copy_row(st->buf, j, in, r);
+            }
+        }
+        st->seen++;
+    }
+
+    return TF_OK;
+}
+
+static int sample_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)side;
+    sample_state *st = self->state;
+    *out = NULL;
+
+    if (!st->buf || st->buf->n_rows == 0) return TF_OK;
+
+    /* Copy buffer to output */
+    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]);
+    for (size_t i = 0; i < n; i++) {
+        tf_batch_copy_row(ob, i, st->buf, i);
+        ob->n_rows = i + 1;
+    }
+
+    *out = ob;
+    return TF_OK;
+}
+
+static void sample_destroy(tf_step *self) {
+    sample_state *st = self->state;
+    if (st) {
+        if (st->buf) tf_batch_free(st->buf);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_sample_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;
+
+    sample_state *st = calloc(1, sizeof(sample_state));
+    if (!st) return NULL;
+    st->n = (size_t)n_json->valueint;
+    st->seed = (unsigned)time(NULL);
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { free(st); return NULL; }
+    step->process = sample_process;
+    step->flush = sample_flush;
+    step->destroy = sample_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_select.c

@@ -0,0 +1,140 @@
+/*
+ * op_select.c — Select and reorder columns.
+ *
+ * Config: {"columns": ["name", "age"]}
+ * Creates output batch with only the specified columns in the given order.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+typedef struct {
+    char  **col_names;
+    size_t  n_cols;
+} select_state;
+
+static int select_process(tf_step *self, tf_batch *in, tf_batch **out,
+                          tf_side_channels *side) {
+    select_state *st = self->state;
+    *out = NULL;
+
+    /* Resolve column indices */
+    int *indices = malloc(st->n_cols * sizeof(int));
+    if (!indices) return TF_ERROR;
+
+    for (size_t i = 0; i < st->n_cols; i++) {
+        indices[i] = tf_batch_col_index(in, st->col_names[i]);
+        if (indices[i] < 0 && side && side->errors) {
+            char buf[128];
+            snprintf(buf, sizeof(buf),
+                     "{\"op\":\"select\",\"error\":\"column '%s' not found\"}\n",
+                     st->col_names[i]);
+            tf_buffer_write_str(side->errors, buf);
+        }
+    }
+
+    /* Create output batch */
+    tf_batch *ob = tf_batch_create(st->n_cols, in->n_rows);
+    if (!ob) { free(indices); return TF_ERROR; }
+
+    for (size_t i = 0; i < st->n_cols; i++) {
+        if (indices[i] >= 0) {
+            tf_batch_set_schema(ob, i, st->col_names[i], in->col_types[indices[i]]);
+        } else {
+            tf_batch_set_schema(ob, i, st->col_names[i], TF_TYPE_NULL);
+        }
+    }
+
+    /* Copy rows */
+    for (size_t r = 0; r < in->n_rows; r++) {
+        tf_batch_ensure_capacity(ob, r + 1);
+        for (size_t i = 0; i < st->n_cols; i++) {
+            int ci = indices[i];
+            if (ci < 0 || tf_batch_is_null(in, r, ci)) {
+                tf_batch_set_null(ob, r, i);
+                continue;
+            }
+            switch (in->col_types[ci]) {
+                case TF_TYPE_BOOL:
+                    tf_batch_set_bool(ob, r, i, tf_batch_get_bool(in, r, ci));
+                    break;
+                case TF_TYPE_INT64:
+                    tf_batch_set_int64(ob, r, i, tf_batch_get_int64(in, r, ci));
+                    break;
+                case TF_TYPE_FLOAT64:
+                    tf_batch_set_float64(ob, r, i, tf_batch_get_float64(in, r, ci));
+                    break;
+                case TF_TYPE_STRING:
+                    tf_batch_set_string(ob, r, i, tf_batch_get_string(in, r, ci));
+                    break;
+                case TF_TYPE_DATE:
+                    tf_batch_set_date(ob, r, i, tf_batch_get_date(in, r, ci));
+                    break;
+                case TF_TYPE_TIMESTAMP:
+                    tf_batch_set_timestamp(ob, r, i, tf_batch_get_timestamp(in, r, ci));
+                    break;
+                default:
+                    tf_batch_set_null(ob, r, i);
+                    break;
+            }
+        }
+        ob->n_rows = r + 1;
+    }
+
+    free(indices);
+    *out = ob;
+    return TF_OK;
+}
+
+static int select_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void select_destroy(tf_step *self) {
+    select_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_cols; i++) free(st->col_names[i]);
+        free(st->col_names);
+        free(st);
+    }
+    free(self);
+}
+
+tf_step *tf_select_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *cols = cJSON_GetObjectItemCaseSensitive(args, "columns");
+    if (!cJSON_IsArray(cols)) return NULL;
+
+    int n = cJSON_GetArraySize(cols);
+    if (n <= 0) return NULL;
+
+    select_state *st = calloc(1, sizeof(select_state));
+    if (!st) return NULL;
+    st->n_cols = (size_t)n;
+    st->col_names = malloc(n * sizeof(char *));
+    if (!st->col_names) { free(st); return NULL; }
+
+    for (int i = 0; i < n; i++) {
+        cJSON *item = cJSON_GetArrayItem(cols, i);
+        if (!cJSON_IsString(item)) {
+            for (int j = 0; j < i; j++) free(st->col_names[j]);
+            free(st->col_names);
+            free(st);
+            return NULL;
+        }
+        st->col_names[i] = strdup(item->valuestring);
+    }
+
+    tf_step *step = malloc(sizeof(tf_step));
+    if (!step) { select_destroy(&(tf_step){.state = st}); return NULL; }
+    step->process = select_process;
+    step->flush = select_flush;
+    step->destroy = select_destroy;
+    step->state = st;
+    return step;
+}