tranfi 0.1.2 → 0.2.1

package/csrc/op_schema_infer.c

@@ -0,0 +1,252 @@
+/*
+ * op_schema_infer.c -- Bounded schema inference report.
+ *
+ * schema infer [rows=N] samples decoded batches without retaining rows and
+ * emits one schema-report row per input column at finish(). It reports the
+ * decoded runtime types rather than changing parser behavior.
+ */
+
+#include "internal.h"
+#include "cJSON.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+
+#define SCHEMA_INFER_DEFAULT_ROWS 10000u
+
+typedef struct {
+    char *name;
+    size_t missing;
+    size_t counts[6]; /* bool, int, float, string, date, timestamp */
+} schema_infer_col;
+
+typedef struct {
+    size_t rows_limit;
+    size_t rows_seen;
+    size_t rows_sampled;
+    int initialized;
+    int schema_changed;
+    schema_infer_col *cols;
+    size_t n_cols;
+} schema_infer_state;
+
+static int schema_infer_type_index(tf_type type) {
+    switch (type) {
+        case TF_TYPE_BOOL: return 0;
+        case TF_TYPE_INT64: return 1;
+        case TF_TYPE_FLOAT64: return 2;
+        case TF_TYPE_STRING: return 3;
+        case TF_TYPE_DATE: return 4;
+        case TF_TYPE_TIMESTAMP: return 5;
+        default: return -1;
+    }
+}
+
+static void append_token(char *buf, size_t buf_size, int *first, const char *token) {
+    if (!buf || buf_size == 0 || !token || !token[0]) return;
+    size_t used = strlen(buf);
+    if (used >= buf_size - 1) return;
+    snprintf(buf + used, buf_size - used, "%s%s", *first ? "" : ",", token);
+    *first = 0;
+}
+
+static void append_count(char *buf, size_t buf_size, int *first,
+                         const char *name, size_t count) {
+    if (count == 0 || !buf || buf_size == 0 || !name) return;
+    size_t used = strlen(buf);
+    if (used >= buf_size - 1) return;
+    snprintf(buf + used, buf_size - used, "%s%s:%zu", *first ? "" : ";", name, count);
+    *first = 0;
+}
+
+static int schema_infer_init(schema_infer_state *st, const tf_batch *in) {
+    if (st->initialized) return TF_OK;
+    size_t n_cols = in ? in->n_cols : 0;
+    if (n_cols == 0) {
+        st->initialized = 1;
+        return TF_OK;
+    }
+
+    schema_infer_col *cols = calloc(n_cols, sizeof(schema_infer_col));
+    if (!cols) return TF_ERROR;
+    for (size_t c = 0; c < n_cols; c++) {
+        const char *name = in->col_names[c] ? in->col_names[c] : "";
+        cols[c].name = strdup(name);
+        if (!cols[c].name) {
+            for (size_t i = 0; i < c; i++) free(cols[i].name);
+            free(cols);
+            return TF_ERROR;
+        }
+    }
+
+    st->cols = cols;
+    st->n_cols = n_cols;
+    st->initialized = 1;
+    return TF_OK;
+}
+
+static int schema_infer_process(tf_step *self, tf_batch *in, tf_batch **out,
+                                tf_side_channels *side) {
+    (void)side;
+    schema_infer_state *st = self->state;
+    *out = NULL;
+    if (schema_infer_init(st, in) != TF_OK) return TF_ERROR;
+    if (!in) return TF_OK;
+    if (st->initialized && in->n_cols != st->n_cols) st->schema_changed = 1;
+
+    for (size_t r = 0; r < in->n_rows; r++) {
+        st->rows_seen++;
+        if (st->rows_sampled >= st->rows_limit) continue;
+        st->rows_sampled++;
+        size_t n = in->n_cols < st->n_cols ? in->n_cols : st->n_cols;
+        for (size_t c = 0; c < n; c++) {
+            schema_infer_col *col = &st->cols[c];
+            if (tf_batch_is_null(in, r, c)) {
+                col->missing++;
+                continue;
+            }
+            int idx = schema_infer_type_index(in->col_types[c]);
+            if (idx >= 0) col->counts[idx]++;
+        }
+    }
+    return TF_OK;
+}
+
+static const char *schema_infer_inferred_type(const schema_infer_col *col,
+                                              const char **warning_token) {
+    size_t non_missing = 0;
+    size_t nonzero = 0;
+    int last = -1;
+    *warning_token = NULL;
+    for (int i = 0; i < 6; i++) {
+        non_missing += col->counts[i];
+        if (col->counts[i] > 0) { nonzero++; last = i; }
+    }
+    if (non_missing == 0) {
+        *warning_token = "no_non_null_sample";
+        return "unknown";
+    }
+    if (nonzero == 1) {
+        static const char *names[] = {"bool", "int", "float", "string", "date", "timestamp"};
+        return names[last];
+    }
+    if (col->counts[1] > 0 && col->counts[2] > 0 && nonzero == 2) {
+        *warning_token = "mixed_numeric";
+        return "float";
+    }
+    *warning_token = "mixed_types";
+    return "string";
+}
+
+static int schema_infer_set_output_schema(tf_batch *out) {
+    return tf_batch_set_schema(out, 0, "column", TF_TYPE_STRING) == TF_OK &&
+           tf_batch_set_schema(out, 1, "type", TF_TYPE_STRING) == TF_OK &&
+           tf_batch_set_schema(out, 2, "nullable", TF_TYPE_BOOL) == TF_OK &&
+           tf_batch_set_schema(out, 3, "non_null", TF_TYPE_BOOL) == TF_OK &&
+           tf_batch_set_schema(out, 4, "rows_seen", TF_TYPE_INT64) == TF_OK &&
+           tf_batch_set_schema(out, 5, "rows_sampled", TF_TYPE_INT64) == TF_OK &&
+           tf_batch_set_schema(out, 6, "missing", TF_TYPE_INT64) == TF_OK &&
+           tf_batch_set_schema(out, 7, "non_missing", TF_TYPE_INT64) == TF_OK &&
+           tf_batch_set_schema(out, 8, "observed_types", TF_TYPE_STRING) == TF_OK &&
+           tf_batch_set_schema(out, 9, "warning", TF_TYPE_STRING) == TF_OK ? TF_OK : TF_ERROR;
+}
+
+static int schema_infer_flush(tf_step *self, tf_batch **out,
+                              tf_side_channels *side) {
+    (void)side;
+    schema_infer_state *st = self->state;
+    *out = NULL;
+    if (!st->initialized || st->n_cols == 0) return TF_OK;
+
+    tf_batch *ob = tf_batch_create(10, st->n_cols ? st->n_cols : 1);
+    if (!ob) return TF_ERROR;
+    int rc = TF_ERROR;
+#define SCHEMA_INFER_WRITE(expr) do { if ((expr) != TF_OK) goto done; } while (0)
+
+    SCHEMA_INFER_WRITE(schema_infer_set_output_schema(ob));
+
+    static const char *type_names[] = {"bool", "int", "float", "string", "date", "timestamp"};
+    for (size_t c = 0; c < st->n_cols; c++) {
+        schema_infer_col *col = &st->cols[c];
+        size_t non_missing = 0;
+        char observed[256] = {0};
+        char warning[192] = {0};
+        int first_obs = 1;
+        int first_warn = 1;
+        for (int i = 0; i < 6; i++) {
+            non_missing += col->counts[i];
+            append_count(observed, sizeof(observed), &first_obs, type_names[i], col->counts[i]);
+        }
+        append_count(observed, sizeof(observed), &first_obs, "null", col->missing);
+        if (observed[0] == '\0') snprintf(observed, sizeof(observed), "none");
+
+        const char *type_warning = NULL;
+        const char *inferred = schema_infer_inferred_type(col, &type_warning);
+        if (type_warning) append_token(warning, sizeof(warning), &first_warn, type_warning);
+        if (st->rows_seen > st->rows_sampled) append_token(warning, sizeof(warning), &first_warn, "sample_limited");
+        if (st->schema_changed) append_token(warning, sizeof(warning), &first_warn, "schema_changed");
+        if (st->rows_sampled == 0) append_token(warning, sizeof(warning), &first_warn, "no_rows_sampled");
+
+        SCHEMA_INFER_WRITE(tf_batch_set_string(ob, c, 0, col->name ? col->name : ""));
+        SCHEMA_INFER_WRITE(tf_batch_set_string(ob, c, 1, inferred));
+        SCHEMA_INFER_WRITE(tf_batch_set_bool(ob, c, 2, col->missing > 0));
+        SCHEMA_INFER_WRITE(tf_batch_set_bool(ob, c, 3, col->missing == 0 && st->rows_sampled > 0));
+        SCHEMA_INFER_WRITE(tf_batch_set_int64(ob, c, 4, (int64_t)st->rows_seen));
+        SCHEMA_INFER_WRITE(tf_batch_set_int64(ob, c, 5, (int64_t)st->rows_sampled));
+        SCHEMA_INFER_WRITE(tf_batch_set_int64(ob, c, 6, (int64_t)col->missing));
+        SCHEMA_INFER_WRITE(tf_batch_set_int64(ob, c, 7, (int64_t)non_missing));
+        SCHEMA_INFER_WRITE(tf_batch_set_string(ob, c, 8, observed));
+        SCHEMA_INFER_WRITE(tf_batch_set_string(ob, c, 9, warning));
+        SCHEMA_INFER_WRITE(tf_batch_expose_row(ob, c));
+    }
+
+    *out = ob;
+    ob = NULL;
+    rc = TF_OK;
+
+done:
+    if (ob) tf_batch_free(ob);
+#undef SCHEMA_INFER_WRITE
+    return rc;
+}
+
+static void schema_infer_destroy(tf_step *self) {
+    if (!self) return;
+    schema_infer_state *st = self->state;
+    if (st) {
+        for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i].name);
+        free(st->cols);
+        free(st);
+    }
+    free(self);
+}
+
+static int parse_rows_arg(const cJSON *args, size_t *rows) {
+    *rows = SCHEMA_INFER_DEFAULT_ROWS;
+    if (!args) return TF_OK;
+    int has_rows = tf_json_get_size_arg(args, "rows",
+                                        1, TF_MAX_COUNT_ARG,
+                                        rows, "schema-infer");
+    if (has_rows < 0) {
+        return TF_ERROR;
+    }
+    if (has_rows == 0) *rows = SCHEMA_INFER_DEFAULT_ROWS;
+    return TF_OK;
+}
+
+tf_step *tf_schema_infer_create(const cJSON *args) {
+    schema_infer_state *st = calloc(1, sizeof(schema_infer_state));
+    if (!st) return NULL;
+    if (parse_rows_arg(args, &st->rows_limit) != TF_OK) {
+        free(st);
+        return NULL;
+    }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { free(st); return NULL; }
+    step->process = schema_infer_process;
+    step->flush = schema_infer_flush;
+    step->destroy = schema_infer_destroy;
+    step->state = st;
+    return step;
+}

package/csrc/op_select.c

@@ -14,76 +14,75 @@
 typedef struct {
     char  **col_names;
     size_t  n_cols;
+    int     use_selector_syntax;
 } select_state;
 
+static int select_write_error(tf_side_channels *side, const char *msg) {
+    if (!side || !side->errors || !msg) return TF_OK;
+    char buf[256];
+    snprintf(buf, sizeof(buf), "{\"op\":\"select\",\"error\":\"%s\"}", msg);
+    return tf_buffer_write_line(side->errors, buf);
+}
+
 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);
+    int *indices = NULL;
+    size_t n_indices = st->n_cols;
+
+    if (st->use_selector_syntax) {
+        char *error = NULL;
+        if (tf_column_selectors_resolve(st->col_names, st->n_cols,
+                                        in->col_names, in->col_types, in->n_cols,
+                                        &indices, &n_indices, &error) != TF_OK) {
+            int err_rc = select_write_error(side, error ? error : "selector resolution failed");
+            free(error);
+            if (err_rc != TF_OK) return TF_ERROR;
+            return TF_ERROR;
+        }
+    } else {
+        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 msg[128];
+                snprintf(msg, sizeof(msg), "column '%s' not found", st->col_names[i]);
+                if (select_write_error(side, msg) != TF_OK) {
+                    free(indices);
+                    return TF_ERROR;
+                }
+            }
         }
     }
 
-    /* Create output batch */
-    tf_batch *ob = tf_batch_create(st->n_cols, in->n_rows);
+    tf_batch *ob = tf_batch_create(n_indices, 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]]);
+    size_t *selected_cols = malloc(n_indices * sizeof(size_t));
+    if (!selected_cols) { free(indices); tf_batch_free(ob); return TF_ERROR; }
+    for (size_t i = 0; i < n_indices; i++) {
+        int ci = indices[i];
+        if (ci >= 0) {
+            selected_cols[i] = (size_t)ci;
+            if (tf_batch_set_schema(ob, i, in->col_names[(size_t)ci], in->col_types[(size_t)ci]) != TF_OK) {
+                free(selected_cols); free(indices); tf_batch_free(ob); return TF_ERROR;
+            }
         } else {
-            tf_batch_set_schema(ob, i, st->col_names[i], TF_TYPE_NULL);
+            selected_cols[i] = SIZE_MAX;
+            if (tf_batch_set_schema(ob, i, st->col_names[i], TF_TYPE_NULL) != TF_OK) {
+                free(selected_cols); free(indices); tf_batch_free(ob); return TF_ERROR;
+            }
         }
     }
 
-    /* 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;
+    if (tf_batch_copy_selected_columns(ob, in, selected_cols, n_indices) != TF_OK) {
+        free(selected_cols); free(indices); tf_batch_free(ob); return TF_ERROR;
     }
 
+    free(selected_cols);
     free(indices);
     *out = ob;
     return TF_OK;
@@ -95,13 +94,19 @@ static int select_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
     return TF_OK;
 }
 
-static void select_destroy(tf_step *self) {
-    select_state *st = self->state;
+static void select_state_free(select_state *st) {
     if (st) {
-        for (size_t i = 0; i < st->n_cols; i++) free(st->col_names[i]);
+        if (st->col_names) {
+            for (size_t i = 0; i < st->n_cols; i++) free(st->col_names[i]);
+        }
         free(st->col_names);
         free(st);
     }
+}
+
+static void select_destroy(tf_step *self) {
+    if (!self) return;
+    select_state_free(self->state);
     free(self);
 }
 
@@ -116,25 +121,220 @@ tf_step *tf_select_create(const cJSON *args) {
     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; }
+    st->col_names = calloc((size_t)n, sizeof(char *));
+    if (!st->col_names) { select_state_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;
-        }
+        if (!cJSON_IsString(item)) { select_state_free(st); return NULL; }
         st->col_names[i] = strdup(item->valuestring);
+        if (!st->col_names[i]) { select_state_free(st); return NULL; }
+        if (tf_column_selector_has_syntax(item->valuestring)) st->use_selector_syntax = 1;
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
-    if (!step) { select_destroy(&(tf_step){.state = st}); return NULL; }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { select_state_free(st); return NULL; }
     step->process = select_process;
     step->flush = select_flush;
     step->destroy = select_destroy;
     step->state = st;
     return step;
 }
+
+
+typedef struct {
+    char  **move_names;
+    size_t  n_move;
+    char   *before;
+    char   *after;
+} relocate_state;
+
+static int relocate_write_error(tf_side_channels *side, const char *msg, const char *name) {
+    if (!side || !side->errors) return TF_OK;
+    char buf[256];
+    snprintf(buf, sizeof(buf),
+             "{\"op\":\"relocate\",\"error\":\"%s '%s'\"}",
+             msg, name ? name : "");
+    return tf_buffer_write_line(side->errors, buf);
+}
+
+static int relocate_process(tf_step *self, tf_batch *in, tf_batch **out,
+                            tf_side_channels *side) {
+    relocate_state *st = self->state;
+    *out = NULL;
+
+    size_t n_in = in->n_cols;
+    int *move_idx = NULL;
+    size_t n_move = 0;
+    char *selector_error = NULL;
+    if (tf_column_selectors_resolve(st->move_names, st->n_move,
+                                    in->col_names, in->col_types, in->n_cols,
+                                    &move_idx, &n_move, &selector_error) != TF_OK) {
+        int err_rc = relocate_write_error(side, selector_error ? selector_error : "selector resolution failed", "");
+        free(selector_error);
+        if (err_rc != TF_OK) return TF_ERROR;
+        return TF_ERROR;
+    }
+
+    int *is_moving = calloc(n_in ? n_in : 1, sizeof(int));
+    int *order = malloc(n_in ? n_in * sizeof(int) : sizeof(int));
+    if (!is_moving || !order) {
+        free(move_idx); free(is_moving); free(order);
+        return TF_ERROR;
+    }
+
+    for (size_t i = 0; i < n_move; i++) {
+        int ci = move_idx[i];
+        if (ci < 0 || (size_t)ci >= n_in || is_moving[ci]) {
+            int err_rc = relocate_write_error(side, "invalid relocated column", "");
+            free(move_idx); free(is_moving); free(order);
+            if (err_rc != TF_OK) return TF_ERROR;
+            return TF_ERROR;
+        }
+        is_moving[ci] = 1;
+    }
+
+    const char *anchor = st->before ? st->before : st->after;
+    int anchor_idx = -1;
+    if (anchor) {
+        anchor_idx = tf_batch_col_index(in, anchor);
+        if (anchor_idx < 0) {
+            int err_rc = relocate_write_error(side, "anchor column not found", anchor);
+            free(move_idx); free(is_moving); free(order);
+            if (err_rc != TF_OK) return TF_ERROR;
+            return TF_ERROR;
+        }
+        if (is_moving[anchor_idx]) {
+            int err_rc = relocate_write_error(side, "anchor column is being relocated", anchor);
+            free(move_idx); free(is_moving); free(order);
+            if (err_rc != TF_OK) return TF_ERROR;
+            return TF_ERROR;
+        }
+    }
+
+    size_t n_order = 0;
+    if (!anchor) {
+        for (size_t i = 0; i < n_move; i++) order[n_order++] = move_idx[i];
+        for (size_t i = 0; i < n_in; i++) {
+            if (!is_moving[i]) order[n_order++] = (int)i;
+        }
+    } else {
+        for (size_t i = 0; i < n_in; i++) {
+            if (is_moving[i]) continue;
+            if (st->before && (int)i == anchor_idx) {
+                for (size_t j = 0; j < n_move; j++) order[n_order++] = move_idx[j];
+            }
+            order[n_order++] = (int)i;
+            if (st->after && (int)i == anchor_idx) {
+                for (size_t j = 0; j < n_move; j++) order[n_order++] = move_idx[j];
+            }
+        }
+    }
+
+    if (n_order != n_in) {
+        int err_rc = relocate_write_error(side, "internal order size mismatch", "");
+        free(move_idx); free(is_moving); free(order);
+        if (err_rc != TF_OK) return TF_ERROR;
+        return TF_ERROR;
+    }
+
+    tf_batch *ob = tf_batch_create(n_in, in->n_rows);
+    if (!ob) {
+        free(move_idx); free(is_moving); free(order);
+        return TF_ERROR;
+    }
+
+    size_t *selected_cols = malloc(n_in * sizeof(size_t));
+    if (!selected_cols) {
+        free(move_idx); free(is_moving); free(order); tf_batch_free(ob);
+        return TF_ERROR;
+    }
+    for (size_t i = 0; i < n_in; i++) {
+        int ci = order[i];
+        selected_cols[i] = (size_t)ci;
+        if (tf_batch_set_schema(ob, i, in->col_names[(size_t)ci], in->col_types[(size_t)ci]) != TF_OK) {
+            free(selected_cols); free(move_idx); free(is_moving); free(order); tf_batch_free(ob);
+            return TF_ERROR;
+        }
+    }
+
+    if (tf_batch_copy_selected_columns(ob, in, selected_cols, n_in) != TF_OK) {
+        free(selected_cols); free(move_idx); free(is_moving); free(order); tf_batch_free(ob);
+        return TF_ERROR;
+    }
+
+    free(selected_cols);
+    free(move_idx);
+    free(is_moving);
+    free(order);
+    *out = ob;
+    return TF_OK;
+}
+
+static int relocate_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
+    (void)self; (void)side;
+    *out = NULL;
+    return TF_OK;
+}
+
+static void relocate_state_free(relocate_state *st) {
+    if (st) {
+        if (st->move_names) {
+            for (size_t i = 0; i < st->n_move; i++) free(st->move_names[i]);
+        }
+        free(st->move_names);
+        free(st->before);
+        free(st->after);
+        free(st);
+    }
+}
+
+static void relocate_destroy(tf_step *self) {
+    if (!self) return;
+    relocate_state_free(self->state);
+    free(self);
+}
+
+tf_step *tf_relocate_create(const cJSON *args) {
+    if (!args) return NULL;
+    cJSON *cols = cJSON_GetObjectItemCaseSensitive(args, "columns");
+    if (!cJSON_IsArray(cols)) return NULL;
+
+    cJSON *before = cJSON_GetObjectItemCaseSensitive(args, "before");
+    cJSON *after = cJSON_GetObjectItemCaseSensitive(args, "after");
+    if (before && after) return NULL;
+    if (before && !cJSON_IsString(before)) return NULL;
+    if (after && !cJSON_IsString(after)) return NULL;
+
+    int n = cJSON_GetArraySize(cols);
+    if (n <= 0) return NULL;
+
+    relocate_state *st = calloc(1, sizeof(relocate_state));
+    if (!st) return NULL;
+    st->n_move = (size_t)n;
+    st->move_names = calloc((size_t)n, sizeof(char *));
+    if (!st->move_names) { relocate_state_free(st); return NULL; }
+
+    for (int i = 0; i < n; i++) {
+        cJSON *item = cJSON_GetArrayItem(cols, i);
+        if (!cJSON_IsString(item)) { relocate_state_free(st); return NULL; }
+        st->move_names[i] = strdup(item->valuestring);
+        if (!st->move_names[i]) { relocate_state_free(st); return NULL; }
+    }
+    if (before) {
+        st->before = strdup(before->valuestring);
+        if (!st->before) { relocate_state_free(st); return NULL; }
+    }
+    if (after) {
+        st->after = strdup(after->valuestring);
+        if (!st->after) { relocate_state_free(st); return NULL; }
+    }
+
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { relocate_state_free(st); return NULL; }
+    step->process = relocate_process;
+    step->flush = relocate_flush;
+    step->destroy = relocate_destroy;
+    step->state = st;
+    return step;
+}