tranfi 0.1.2 → 0.2.1

package/csrc/op_rename.c

@@ -17,6 +17,7 @@ typedef struct {
 } 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];
@@ -28,6 +29,7 @@ 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);
@@ -35,42 +37,23 @@ static int rename_process(tf_step *self, tf_batch *in, tf_batch **out,
 
     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]);
+        if (tf_batch_set_schema(ob, i, new_name, in->col_types[i]) != TF_OK) {
+            tf_batch_free(ob);
+            return TF_ERROR;
+        }
     }
 
-    /* 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;
+    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;
@@ -83,17 +66,19 @@ static int rename_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
     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);
+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);
 }
 
@@ -108,8 +93,8 @@ tf_step *tf_rename_create(const cJSON *args) {
     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 *));
+    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);
@@ -120,14 +105,20 @@ tf_step *tf_rename_create(const cJSON *args) {
     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);
+        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 = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) {
-        rename_destroy(&(tf_step){.state = st});
+        rename_state_free(st);
         return NULL;
     }
     step->process = rename_process;

package/csrc/op_replace.c

@@ -17,132 +17,259 @@ typedef struct {
     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) {
-    (void)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;
-    for (size_t c = 0; c < in->n_cols; c++)
-        tf_batch_set_schema(ob, c, in->col_names[c], in->col_types[c]);
+    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++) {
-        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;
+        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;
                         }
                     }
-                    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;
+                    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;
                     }
-                    memcpy(buf + buf_len, p, rest);
-                    buf_len += rest;
-                    buf[buf_len] = '\0';
-                    tf_batch_set_string(ob, r, ci, buf);
                 }
+            }
+        }
+        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;
             }
-        } 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);
-                }
+            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;
 }
@@ -151,15 +278,18 @@ 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) {
-    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);
-    }
+    if (self) replace_state_free(self->state);
     free(self);
 }
 
@@ -173,25 +303,47 @@ tf_step *tf_replace_create(const cJSON *args) {
 
     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) {
-            free(st->column); free(st->pattern); free(st->replacement); free(st);
+            replace_state_free(st);
             return NULL;
         }
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
+    tf_step *step = calloc(1, sizeof(tf_step));
     if (!step) {
-        if (st->use_regex) regfree(&st->compiled);
-        free(st->column); free(st->pattern); free(st->replacement); free(st);
+        replace_state_free(st);
         return NULL;
     }
     step->process = replace_process;