tranfi 0.0.2 → 0.2.0

package/csrc/op_rename.c

@@ -0,0 +1,129 @@
+/*
+ * 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) {
+    if (!name) return "";
+    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;
+    *out = NULL;
+
+    /* 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]);
+        if (tf_batch_set_schema(ob, i, new_name, in->col_types[i]) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+
+    size_t *cols = tf_mallocarray_checked(in->n_cols ? in->n_cols : 1, sizeof(size_t));
+    if (!cols) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t i = 0; i < in->n_cols; i++) cols[i] = i;
+    int rc = tf_batch_copy_selected_columns(ob, in, cols, in->n_cols);
+    free(cols);
+    if (rc != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    *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_state_free(rename_state *st) {
+    if (!st) return;
+    for (size_t i = 0; i < st->n_mappings; i++) {
+        if (st->old_names) free(st->old_names[i]);
+        if (st->new_names) free(st->new_names[i]);
+    }
+    free(st->old_names);
+    free(st->new_names);
+    free(st);
+}
+
+static void rename_destroy(tf_step *self) {
+    rename_state_free(self ? self->state : NULL);
+    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 = calloc((size_t)n, sizeof(char *));
+    st->new_names = calloc((size_t)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) {
+        const char *old_name = item->string ? item->string : "";
+        const char *new_name = cJSON_IsString(item) ? item->valuestring : old_name;
+        st->old_names[i] = strdup(old_name);
+        st->new_names[i] = strdup(new_name ? new_name : "");
+        if (!st->old_names[i] || !st->new_names[i]) {
+            rename_state_free(st);
+            return NULL;
+        }
+        i++;
+    }
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) {
+        rename_state_free(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,354 @@
+/*
+ * 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;
+    size_t  row_index;
+    size_t  audit_limit;
+    size_t  audit_emitted;
+    int     audit;
+    tf_audit_options audit_opts;
+} replace_state;
+
+static int replace_ensure_buffer(char **buf, size_t *cap, size_t need) {
+    if (!buf || !cap) return TF_ERROR;
+    if (need > 0) {
+        size_t payload_len = need - 1; /* reserve space for the trailing NUL */
+        if (tf_check_byte_limit(payload_len, TF_MAX_CELL_BYTES, "replace", "output cell") != TF_OK) {
+            return TF_ERROR;
+        }
+    }
+    if (need <= *cap) return TF_OK;
+    size_t new_cap = 0;
+    if (tf_size_grow_pow2(*cap, need, 64, &new_cap) != TF_OK) return TF_ERROR;
+    size_t max_cap = 0;
+    if (tf_size_add(TF_MAX_CELL_BYTES, 1, &max_cap) != TF_OK) return TF_ERROR;
+    if (new_cap > max_cap) new_cap = need;
+    char *nb = tf_reallocarray_checked(*buf, new_cap, sizeof(char));
+    if (!nb) return TF_ERROR;
+    *buf = nb;
+    *cap = new_cap;
+    return TF_OK;
+}
+
+static int replace_append_bytes(char **buf, size_t *cap, size_t *len,
+                                const char *src, size_t n) {
+    if (!buf || !cap || !len || (!src && n > 0)) return TF_ERROR;
+    size_t end = 0;
+    size_t need = 0;
+    if (tf_size_add(*len, n, &end) != TF_OK ||
+        tf_size_add(end, 1, &need) != TF_OK) {
+        return TF_ERROR;
+    }
+    if (replace_ensure_buffer(buf, cap, need) != TF_OK) return TF_ERROR;
+    if (n > 0) memcpy(*buf + *len, src, n);
+    *len = end;
+    (*buf)[*len] = '\0';
+    return TF_OK;
+}
+
+static int replace_append_char(char **buf, size_t *cap, size_t *len, char ch) {
+    return replace_append_bytes(buf, cap, len, &ch, 1);
+}
+
+static int emit_replace_audit(replace_state *st, const tf_batch *b, size_t row, size_t col,
+                              size_t row_no, const char *before, const char *after,
+                              tf_side_channels *side) {
+    if (!st->audit || st->audit_emitted >= st->audit_limit || !side || !side->stats) return TF_OK;
+    cJSON *obj = cJSON_CreateObject();
+    if (!obj) return TF_ERROR;
+    int rc = TF_ERROR;
+    if (tf_json_add_string(obj, "type", "audit") != TF_OK ||
+        tf_json_add_string(obj, "op", "replace") != TF_OK ||
+        tf_json_add_string(obj, "event", "value_changed") != TF_OK ||
+        tf_json_add_string(obj, "reason", "replace_match") != TF_OK ||
+        tf_json_add_string(obj, "channel", "audit") != TF_OK) {
+        goto done;
+    }
+    const char *column_name = b->col_names[col] ? b->col_names[col] : "";
+    if (tf_json_add_string(obj, "column", column_name) != TF_OK) goto done;
+    if (tf_json_add_audit_string(obj, "pattern", &st->audit_opts, column_name, st->pattern) != TF_OK ||
+        tf_json_add_audit_string(obj, "replacement", &st->audit_opts, column_name, st->replacement) != TF_OK ||
+        tf_json_add_bool(obj, "regex", st->use_regex ? 1 : 0) != TF_OK ||
+        tf_json_add_number(obj, "row", (double)row_no) != TF_OK) {
+        goto done;
+    }
+    if (tf_json_add_audit_string(obj, "before", &st->audit_opts, column_name, before) != TF_OK ||
+        tf_json_add_audit_string(obj, "after", &st->audit_opts, column_name, after) != TF_OK) {
+        goto done;
+    }
+    cJSON *row_obj = tf_audit_row_to_json(b, row, &st->audit_opts);
+    if (row_obj) {
+        if (tf_json_add_item(obj, "data", row_obj) != TF_OK) goto done;
+    } else if (st->audit_opts.include_row) {
+        goto done;
+    }
+    rc = tf_buffer_write_json_line(side->stats, obj);
+done:
+    cJSON_Delete(obj);
+    if (rc == TF_OK) st->audit_emitted++;
+    return rc;
+}
+
+static int replace_build_regex(replace_state *st, const char *val,
+                               char **out_buf, int *out_replaced) {
+    *out_buf = NULL;
+    *out_replaced = 0;
+    size_t buf_cap = 0;
+    size_t buf_len = 0;
+    char *buf = NULL;
+    const char *p = val;
+    regmatch_t match;
+    while (regexec(&st->compiled, p, 1, &match, 0) == 0 && match.rm_so >= 0) {
+        *out_replaced = 1;
+        size_t prefix = (size_t)match.rm_so;
+        size_t match_len = (size_t)(match.rm_eo - match.rm_so);
+        if (replace_append_bytes(&buf, &buf_cap, &buf_len, p, prefix) != TF_OK) {
+            free(buf);
+            return TF_ERROR;
+        }
+        for (const char *rp = st->replacement; *rp; rp++) {
+            if (*rp == '&') {
+                if (replace_append_bytes(&buf, &buf_cap, &buf_len,
+                                         p + match.rm_so, match_len) != TF_OK) {
+                    free(buf);
+                    return TF_ERROR;
+                }
+            } else if (replace_append_char(&buf, &buf_cap, &buf_len, *rp) != TF_OK) {
+                free(buf);
+                return TF_ERROR;
+            }
+        }
+        p += match.rm_eo;
+        if (match_len == 0) {
+            if (*p) {
+                if (replace_append_char(&buf, &buf_cap, &buf_len, *p++) != TF_OK) {
+                    free(buf);
+                    return TF_ERROR;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+    if (*out_replaced) {
+        if (replace_append_bytes(&buf, &buf_cap, &buf_len, p, strlen(p)) != TF_OK) {
+            free(buf);
+            return TF_ERROR;
+        }
+        *out_buf = buf;
+    }
+    return TF_OK;
+}
+
+static int replace_build_literal(replace_state *st, const char *val,
+                                 char **out_buf, int *out_replaced) {
+    *out_buf = NULL;
+    *out_replaced = 0;
+    size_t pat_len = strlen(st->pattern);
+    if (pat_len == 0 || !strstr(val, st->pattern)) return TF_OK;
+
+    size_t rep_len = strlen(st->replacement);
+    size_t buf_cap = 0;
+    size_t buf_len = 0;
+    char *buf = NULL;
+    const char *p = val;
+    const char *found;
+    while ((found = strstr(p, st->pattern)) != NULL) {
+        size_t prefix = (size_t)(found - p);
+        if (replace_append_bytes(&buf, &buf_cap, &buf_len, p, prefix) != TF_OK ||
+            replace_append_bytes(&buf, &buf_cap, &buf_len, st->replacement, rep_len) != TF_OK) {
+            free(buf);
+            return TF_ERROR;
+        }
+        p = found + pat_len;
+    }
+    if (replace_append_bytes(&buf, &buf_cap, &buf_len, p, strlen(p)) != TF_OK) {
+        free(buf);
+        return TF_ERROR;
+    }
+    *out_replaced = 1;
+    *out_buf = buf;
+    return TF_OK;
+}
+
+static int replace_process(tf_step *self, tf_batch *in, tf_batch **out,
+                           tf_side_channels *side) {
+    replace_state *st = self->state;
+    *out = NULL;
+    size_t row_base = st->row_index;
+
+    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;
+    }
+
+    int ci = tf_batch_col_index(in, st->column);
+    int can_replace = ci >= 0 && in->col_types[ci] == TF_TYPE_STRING;
+    for (size_t r = 0; r < in->n_rows; r++) {
+        char *buf = NULL;
+        char *before_copy = NULL;
+        int replaced = 0;
+        const char *val = NULL;
+        if (tf_batch_copy_row(ob, r, in, r) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (can_replace && !tf_batch_is_null(in, r, (size_t)ci)) {
+            val = tf_batch_get_string(in, r, (size_t)ci);
+            if (val) {
+                int build_rc = st->use_regex
+                    ? replace_build_regex(st, val, &buf, &replaced)
+                    : replace_build_literal(st, val, &buf, &replaced);
+                if (build_rc != TF_OK) {
+                    tf_batch_free(ob);
+                    return TF_ERROR;
+                }
+                if (replaced) {
+                    if (st->audit && st->audit_emitted < st->audit_limit) {
+                        before_copy = strdup(val);
+                        if (!before_copy) {
+                            free(buf);
+                            tf_batch_free(ob);
+                            return TF_ERROR;
+                        }
+                    }
+                    if (tf_batch_set_string(ob, r, (size_t)ci, buf) != TF_OK) {
+                        free(before_copy);
+                        free(buf);
+                        tf_batch_free(ob);
+                        return TF_ERROR;
+                    }
+                }
+            }
+        }
+        if (tf_batch_expose_row(ob, r) != TF_OK) {
+            free(before_copy);
+            free(buf);
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
+        if (replaced) {
+            size_t row_no = 0;
+            if (tf_size_add(row_base, r, &row_no) != TF_OK ||
+                tf_size_add(row_no, 1, &row_no) != TF_OK) {
+                free(before_copy);
+                free(buf);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+            const char *after = tf_batch_get_string(ob, r, (size_t)ci);
+            if (emit_replace_audit(st, ob, r, (size_t)ci, row_no,
+                                   before_copy ? before_copy : val, after, side) != TF_OK) {
+                free(before_copy);
+                free(buf);
+                tf_batch_free(ob);
+                return TF_ERROR;
+            }
+        }
+        free(before_copy);
+        free(buf);
+    }
+
+    if (tf_size_add(st->row_index, in->n_rows, &st->row_index) != TF_OK) {
+        tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    *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_state_free(replace_state *st) {
+    if (!st) return;
+    if (st->use_regex) regfree(&st->compiled);
+    tf_audit_options_free(&st->audit_opts);
+    free(st->column);
+    free(st->pattern);
+    free(st->replacement);
+    free(st);
+}
+
+static void replace_destroy(tf_step *self) {
+    if (self) replace_state_free(self->state);
+    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;
+    tf_audit_options_init(&st->audit_opts, 1);
+    st->column = strdup(col_j->valuestring);
+    st->pattern = strdup(pat_j->valuestring);
+    st->replacement = strdup(rep_j->valuestring);
+    st->audit_limit = 1000;
+    if (!st->column || !st->pattern || !st->replacement) { replace_state_free(st); return NULL; }
+
+    cJSON *regex_j = cJSON_GetObjectItemCaseSensitive(args, "regex");
+    st->use_regex = (cJSON_IsBool(regex_j) && cJSON_IsTrue(regex_j)) ? 1 : 0;
+
+    cJSON *audit_j = cJSON_GetObjectItemCaseSensitive(args, "audit");
+    st->audit = cJSON_IsTrue(audit_j) ? 1 : 0;
+    cJSON *audit_limit_j = cJSON_GetObjectItemCaseSensitive(args, "audit_limit");
+    if (!audit_limit_j) audit_limit_j = cJSON_GetObjectItemCaseSensitive(args, "auditLimit");
+    if (audit_limit_j) {
+        size_t parsed_limit = 0;
+        if (tf_json_get_size_arg_any(args, "audit_limit", "auditLimit",
+                                     1, TF_MAX_AUDIT_RECORDS,
+                                     &parsed_limit, "replace") < 0) {
+            replace_state_free(st);
+            return NULL;
+        }
+        st->audit_limit = parsed_limit;
+    }
+
+    if (tf_audit_options_parse(&st->audit_opts, args, "replace") != TF_OK) {
+        replace_state_free(st);
+        return NULL;
+    }
+
+    if (st->use_regex) {
+        int rc = regcomp(&st->compiled, st->pattern, REG_EXTENDED);
+        if (rc != 0) {
+            replace_state_free(st);
+            return NULL;
+        }
+    }
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) {
+        replace_state_free(st);
+        return NULL;
+    }
+    step->process = replace_process;
+    step->flush = replace_flush;
+    step->destroy = replace_destroy;
+    step->state = st;
+    return step;
+}