tranfi 0.1.2 → 0.2.1

package/csrc/op_unpivot.c

@@ -7,7 +7,6 @@
 
 #include "internal.h"
 #include "cJSON.h"
-#include "date_utils.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@@ -15,8 +14,17 @@
 typedef struct {
     char  **cols;
     size_t  n_cols;
+    size_t  max_output_rows_per_input_row;
+    size_t  max_output_rows_per_batch;
 } unpivot_state;
 
+static int unpivot_set_cap_error(const char *name, size_t limit) {
+    char msg[160];
+    snprintf(msg, sizeof(msg), "unpivot: %s=%zu exceeded", name, limit);
+    tf_set_last_error(msg);
+    return TF_ERROR;
+}
+
 static int unpivot_process(tf_step *self, tf_batch *in, tf_batch **out,
                            tf_side_channels *side) {
     (void)side;
@@ -24,7 +32,7 @@ static int unpivot_process(tf_step *self, tf_batch *in, tf_batch **out,
     *out = NULL;
 
     /* Determine which columns are value columns and which are id columns */
-    int *is_value = calloc(in->n_cols, sizeof(int));
+    int *is_value = tf_callocarray_checked(in->n_cols ? in->n_cols : 1, sizeof(int));
     if (!is_value) return TF_ERROR;
     size_t n_value = 0;
     for (size_t c = 0; c < in->n_cols; c++) {
@@ -40,117 +48,143 @@ static int unpivot_process(tf_step *self, tf_batch *in, tf_batch **out,
     if (n_value == 0) { free(is_value); return TF_OK; }
 
     /* Output: id columns + "variable" + "value" */
-    size_t out_n_cols = n_id + 2;
-    size_t max_rows = in->n_rows * n_value;
+    size_t out_n_cols = 0;
+    if (tf_size_add(n_id, 2, &out_n_cols) != TF_OK) { free(is_value); return TF_ERROR; }
+    if (n_value > st->max_output_rows_per_input_row) {
+        unpivot_set_cap_error("max_output_rows_per_input_row", st->max_output_rows_per_input_row);
+        free(is_value);
+        return TF_ERROR;
+    }
+
+    size_t *id_cols = NULL;
+    if (n_id > 0) {
+        id_cols = tf_callocarray_checked(n_id, sizeof(size_t));
+        if (!id_cols) { free(is_value); return TF_ERROR; }
+    }
+
+    size_t max_rows = 0;
+    if (tf_size_mul(in->n_rows, n_value, &max_rows) != TF_OK ||
+        max_rows > st->max_output_rows_per_batch) {
+        unpivot_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+        free(id_cols);
+        free(is_value);
+        return TF_ERROR;
+    }
     tf_batch *ob = tf_batch_create(out_n_cols, max_rows > 0 ? max_rows : 16);
-    if (!ob) { free(is_value); return TF_ERROR; }
+    if (!ob) { free(id_cols); free(is_value); return TF_ERROR; }
 
     size_t oc = 0;
     for (size_t c = 0; c < in->n_cols; c++) {
-        if (!is_value[c])
-            tf_batch_set_schema(ob, oc++, in->col_names[c], in->col_types[c]);
+        if (!is_value[c]) {
+            id_cols[oc] = c;
+            if (tf_batch_set_schema(ob, oc++, in->col_names[c], in->col_types[c]) != TF_OK) goto fail;
+        }
     }
-    tf_batch_set_schema(ob, oc, "variable", TF_TYPE_STRING);
-    tf_batch_set_schema(ob, oc + 1, "value", TF_TYPE_STRING);
+    if (tf_batch_set_schema(ob, oc, "variable", TF_TYPE_STRING) != TF_OK ||
+        tf_batch_set_schema(ob, oc + 1, "value", TF_TYPE_STRING) != TF_OK) goto fail;
 
     size_t out_row = 0;
     for (size_t r = 0; r < in->n_rows; r++) {
         for (size_t c = 0; c < in->n_cols; c++) {
             if (!is_value[c]) continue;
 
-            tf_batch_ensure_capacity(ob, out_row + 1);
+            if (out_row >= st->max_output_rows_per_batch) {
+                unpivot_set_cap_error("max_output_rows_per_batch", st->max_output_rows_per_batch);
+                goto fail;
+            }
+            size_t need_rows = 0;
+            if (tf_size_add(out_row, 1, &need_rows) != TF_OK ||
+                tf_batch_ensure_capacity(ob, need_rows) != TF_OK) goto fail;
 
             /* Copy id columns */
-            size_t oidx = 0;
-            for (size_t ic = 0; ic < in->n_cols; ic++) {
-                if (is_value[ic]) continue;
-                if (tf_batch_is_null(in, r, ic))
-                    tf_batch_set_null(ob, out_row, oidx);
-                else {
-                    switch (in->col_types[ic]) {
-                        case TF_TYPE_BOOL: tf_batch_set_bool(ob, out_row, oidx, tf_batch_get_bool(in, r, ic)); break;
-                        case TF_TYPE_INT64: tf_batch_set_int64(ob, out_row, oidx, tf_batch_get_int64(in, r, ic)); break;
-                        case TF_TYPE_FLOAT64: tf_batch_set_float64(ob, out_row, oidx, tf_batch_get_float64(in, r, ic)); break;
-                        case TF_TYPE_STRING: tf_batch_set_string(ob, out_row, oidx, tf_batch_get_string(in, r, ic)); break;
-                        case TF_TYPE_DATE: tf_batch_set_date(ob, out_row, oidx, tf_batch_get_date(in, r, ic)); break;
-                        case TF_TYPE_TIMESTAMP: tf_batch_set_timestamp(ob, out_row, oidx, tf_batch_get_timestamp(in, r, ic)); break;
-                        default: tf_batch_set_null(ob, out_row, oidx); break;
-                    }
-                }
-                oidx++;
-            }
+            if (n_id > 0 &&
+                tf_batch_copy_selected_row(ob, out_row, in, r, id_cols, n_id) != TF_OK) goto fail;
 
             /* Set variable name */
-            tf_batch_set_string(ob, out_row, n_id, in->col_names[c]);
-
-            /* Set value (convert to string) */
-            if (tf_batch_is_null(in, r, c)) {
-                tf_batch_set_null(ob, out_row, n_id + 1);
-            } else {
-                char buf[64];
-                switch (in->col_types[c]) {
-                    case TF_TYPE_STRING: tf_batch_set_string(ob, out_row, n_id + 1, tf_batch_get_string(in, r, c)); break;
-                    case TF_TYPE_INT64:
-                        snprintf(buf, sizeof(buf), "%lld", (long long)tf_batch_get_int64(in, r, c));
-                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
-                    case TF_TYPE_FLOAT64:
-                        snprintf(buf, sizeof(buf), "%g", tf_batch_get_float64(in, r, c));
-                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
-                    case TF_TYPE_BOOL:
-                        tf_batch_set_string(ob, out_row, n_id + 1, tf_batch_get_bool(in, r, c) ? "true" : "false"); break;
-                    case TF_TYPE_DATE:
-                        tf_date_format(tf_batch_get_date(in, r, c), buf, sizeof(buf));
-                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
-                    case TF_TYPE_TIMESTAMP:
-                        tf_timestamp_format(tf_batch_get_timestamp(in, r, c), buf, sizeof(buf));
-                        tf_batch_set_string(ob, out_row, n_id + 1, buf); break;
-                    default:
-                        tf_batch_set_null(ob, out_row, n_id + 1); break;
-                }
-            }
+            if (tf_batch_set_string(ob, out_row, n_id, in->col_names[c]) != TF_OK) goto fail;
+
+            if (tf_batch_copy_cell_as_string(ob, out_row, n_id + 1, in, r, c) != TF_OK)
+                goto fail;
 
-            ob->n_rows = ++out_row;
+            if (tf_batch_expose_row(ob, out_row) != TF_OK) goto fail;
+            out_row++;
         }
     }
 
+    free(id_cols);
     free(is_value);
     if (out_row > 0) *out = ob;
     else tf_batch_free(ob);
     return TF_OK;
+
+fail:
+    free(id_cols);
+    free(is_value);
+    tf_batch_free(ob);
+    return TF_ERROR;
 }
 
 static int unpivot_flush(tf_step *self, tf_batch **out, tf_side_channels *side) {
     (void)self; (void)side; *out = NULL; return TF_OK;
 }
 
-static void unpivot_destroy(tf_step *self) {
-    unpivot_state *st = self->state;
+static void unpivot_state_free(unpivot_state *st) {
     if (st) {
-        for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
+        if (st->cols) {
+            for (size_t i = 0; i < st->n_cols; i++) free(st->cols[i]);
+        }
         free(st->cols); free(st);
     }
+}
+
+static void unpivot_destroy(tf_step *self) {
+    unpivot_state_free(self->state);
     free(self);
 }
 
 tf_step *tf_unpivot_create(const cJSON *args) {
     if (!args) return NULL;
     cJSON *columns = cJSON_GetObjectItemCaseSensitive(args, "columns");
-    if (!columns || !cJSON_IsArray(columns)) return NULL;
+    if (!columns || !cJSON_IsArray(columns)) {
+        tf_set_last_error("unpivot: columns must be a non-empty array");
+        return NULL;
+    }
 
     int n = cJSON_GetArraySize(columns);
-    if (n <= 0) return NULL;
+    if (n <= 0) {
+        tf_set_last_error("unpivot: columns must be a non-empty array");
+        return NULL;
+    }
 
     unpivot_state *st = calloc(1, sizeof(unpivot_state));
     if (!st) return NULL;
-    st->cols = calloc(n, sizeof(char *));
-    st->n_cols = n;
+    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;
+
+    size_t parsed_size = 0;
+    int has_size = tf_json_get_size_arg(args, "max_output_rows_per_input_row", 1, TF_MAX_EXPANDING_ROWS_PER_INPUT, &parsed_size, "unpivot");
+    if (has_size < 0) { free(st); return NULL; }
+    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, "unpivot");
+    if (has_size < 0) { free(st); return NULL; }
+    if (has_size > 0) st->max_output_rows_per_batch = parsed_size;
+
+    st->cols = tf_callocarray_checked((size_t)n, sizeof(char *));
+    if (!st->cols) { free(st); return NULL; }
+    st->n_cols = (size_t)n;
     for (int i = 0; i < n; i++) {
         cJSON *item = cJSON_GetArrayItem(columns, i);
-        if (cJSON_IsString(item)) st->cols[i] = strdup(item->valuestring);
+        if (!cJSON_IsString(item) || !item->valuestring || item->valuestring[0] == '\0') {
+            tf_set_last_error("unpivot: column names must be non-empty strings");
+            unpivot_state_free(st);
+            return NULL;
+        }
+        st->cols[i] = strdup(item->valuestring);
+        if (!st->cols[i]) { unpivot_state_free(st); return NULL; }
     }
 
-    tf_step *step = malloc(sizeof(tf_step));
-    if (!step) { unpivot_destroy(&(tf_step){.state = st}); return NULL; }
+    tf_step *step = calloc(1, sizeof(tf_step));
+    if (!step) { unpivot_state_free(st); return NULL; }
     step->process = unpivot_process;
     step->flush = unpivot_flush;
     step->destroy = unpivot_destroy;