extralite 2.15 → 3.0.0

data/ext/extralite/common.c

@@ -151,7 +151,7 @@ static inline void column_names_setup(struct column_names *names, int count) {
 }
 
 static inline void column_names_set(struct column_names *names, int idx, VALUE value) {
-  if (names->count <= MAX_EMBEDDED_COLUMN_NAMES) 
+  if (names->count <= MAX_EMBEDDED_COLUMN_NAMES)
     names->names[idx] = value;
   else
     rb_ary_push(names->array, value);
@@ -331,7 +331,7 @@ void *stmt_iterate_step(void *ptr) {
 inline enum gvl_mode stepwise_gvl_mode(query_ctx *ctx) {
   // a negative or zero threshold means the GVL is always held during iteration.
   if (ctx->gvl_release_threshold <= 0) return GVL_HOLD;
-  
+
   if (!sqlite3_stmt_busy(ctx->stmt)) return GVL_RELEASE;
 
   // if positive, the GVL is normally held, and release every <threshold> steps.
@@ -366,6 +366,218 @@ VALUE cleanup_stmt(query_ctx *ctx) {
   return Qnil;
 }
 
+static inline void add_transform_container_obj(VALUE row, struct transform_node *col, VALUE obj) {
+  if (col->flags & TRANSFORM_F_ARRAY) {
+    VALUE array = rb_hash_aref(row, col->name);
+    if (NIL_P(array)) {
+      array = rb_ary_new();
+      rb_hash_aset(row, col->name, array);
+      RB_GC_GUARD(array);
+    }
+    rb_ary_push(array, obj);
+  }
+  else
+    rb_hash_aset(row, col->name, obj);
+}
+
+static VALUE run_transform(VALUE identity_storage, struct transform_node *node, sqlite3_stmt *stmt);
+
+static inline VALUE json_parse(VALUE json) {
+  if (NIL_P(mJSON)) {
+    rb_require("json");
+    mJSON = rb_const_get(rb_cObject, rb_intern_const("JSON"));
+  }
+  return rb_funcall(mJSON, ID_parse, 1, json);
+}
+
+static inline VALUE get_transform_column_value(struct transform_node *col, sqlite3_stmt *stmt) {
+  int native_type = sqlite3_column_type(stmt, col->idx);
+  switch (col->type) {
+    case TRANSFORM_T_AUTO:
+      if (native_type == SQLITE_NULL) return Qnil;
+      return get_column_value(stmt, col->idx, native_type);
+    case TRANSFORM_T_INTEGER:
+      if (native_type == SQLITE_NULL) return Qnil;
+      return get_column_value(stmt, col->idx, SQLITE_INTEGER);
+    case TRANSFORM_T_FLOAT:
+      if (native_type == SQLITE_NULL) return Qnil;
+      return get_column_value(stmt, col->idx, SQLITE_FLOAT);
+    case TRANSFORM_T_TEXT:
+      if (native_type == SQLITE_NULL) return Qnil;
+      return get_column_value(stmt, col->idx, SQLITE_TEXT);
+    case TRANSFORM_T_BOOL:
+      if (native_type == SQLITE_NULL) return Qnil;
+      int64_t v = sqlite3_column_int64(stmt, col->idx);
+      return v ? Qtrue : Qfalse;
+    case TRANSFORM_T_JSON:
+      if (native_type == SQLITE_NULL) return Qnil;
+      VALUE json = get_column_value(stmt, col->idx, SQLITE_TEXT);
+      return json_parse(json);
+      RB_GC_GUARD(json);
+    case TRANSFORM_T_PROC:
+      VALUE val = get_column_value(stmt, col->idx, native_type);
+      return rb_funcall(col->conversion_proc, ID_call, 1, val);
+      RB_GC_GUARD(val);
+    default:
+      rb_raise(cError, "Invalid column value");
+  }
+}
+
+VALUE run_transform_with_identity(
+  VALUE identity_storage, struct transform_node *node, sqlite3_stmt *stmt
+) {
+  VALUE row = Qnil;
+  VALUE identity_map = Qnil;
+
+  VALUE identity_value = get_transform_column_value(node->identity_node, stmt);
+  //   get_column_value(
+  //   stmt, node->identity_idx, sqlite3_column_type(stmt, node->identity_idx)
+  // );
+  VALUE identity_map_key = ULONG2NUM((uint64_t)node);
+  identity_map = rb_hash_aref(identity_storage, identity_map_key);
+
+  if (NIL_P(identity_map)) {
+    identity_map = rb_hash_new();
+    rb_hash_aset(identity_storage, identity_map_key, identity_map);
+  }
+  row = rb_hash_aref(identity_map, identity_value);
+  if (!NIL_P(row)) {
+    struct transform_node *col = node->subnodes_head;
+    while (col) {
+      if (col->type == TRANSFORM_T_RELATION) {
+        VALUE obj = run_transform(identity_storage, col, stmt);
+        if (!NIL_P(obj)) add_transform_container_obj(row, col, obj);
+      }
+      col = col->next;
+    }
+    return (node->flags & TRANSFORM_F_NAME) ? row : Qnil;
+  }
+  else {
+    // not found in identity map
+    row = rb_hash_new();
+    struct transform_node *col = node->subnodes_head;
+    while (col) {
+      if (col == node->identity_node) {
+        rb_hash_aset(row, col->name, identity_value);
+        rb_hash_aset(identity_map, identity_value, row);
+      }
+      else if (col->type == TRANSFORM_T_RELATION) {
+        VALUE obj = run_transform(identity_storage, col, stmt);
+        if (!NIL_P(obj)) add_transform_container_obj(row, col, obj);
+      }
+      else {
+        VALUE value = get_transform_column_value(col, stmt);
+        rb_hash_aset(row, col->name, value);
+        RB_GC_GUARD(value);
+      }
+      col = col->next;
+    }
+    return row;
+  }
+
+  RB_GC_GUARD(identity_map);
+  RB_GC_GUARD(row);
+}
+
+VALUE run_transform_no_identity(
+  VALUE identity_storage, struct transform_node *node, sqlite3_stmt *stmt
+) {
+  VALUE row = rb_hash_new();
+  struct transform_node *col = node->subnodes_head;
+  while (col) {
+    if (col->type == TRANSFORM_T_RELATION) {
+      VALUE obj = run_transform(identity_storage, col, stmt);
+      if (!NIL_P(obj)) add_transform_container_obj(row, col, obj);
+    }
+    else {
+      VALUE value = get_transform_column_value(col, stmt);
+      rb_hash_aset(row, col->name, value);
+      RB_GC_GUARD(value);
+    }
+    col = col->next;
+  }
+  return row;
+  RB_GC_GUARD(row);
+}
+
+static inline VALUE run_transform(
+  VALUE identity_storage, struct transform_node *node, sqlite3_stmt *stmt
+) {
+  // fprintf(stdout, "transform_container: %p flags: %02x identity_idx: %d\n", node, node->flags, node->identity_idx);
+  // if (node->flags & TRANSFORM_F_NAME) INSPECT("  name", node->name);
+  if (node->identity_node) {
+    return run_transform_with_identity(identity_storage, node, stmt);
+  }
+  else {
+    return run_transform_no_identity(identity_storage, node, stmt);
+  }
+}
+
+VALUE safe_query_transform(query_ctx *ctx) {
+  VALUE array = rb_ary_new();
+  VALUE identity_storage = rb_hash_new();
+  VALUE row = Qnil;
+  // int column_count = sqlite3_column_count(ctx->stmt);
+  struct transform_node *transform_root = get_transform_root(ctx->transform);
+
+  int row_count = 0;
+  while (stmt_iterate(ctx)) {
+    row_count++;
+    row = run_transform(identity_storage, transform_root, ctx->stmt);
+    if (!NIL_P(row)) {
+      rb_ary_push(array, row);
+      if (ctx->max_rows != ALL_ROWS && row_count >= ctx->max_rows)
+        goto done;
+    }
+  }
+
+done:
+  switch (ctx->row_mode) {
+    case ROW_YIELD:
+      rb_ary_each(array);
+      return ctx->self;
+    case ROW_MULTI:
+      return array;
+    case ROW_SINGLE:
+      return rb_ary_entry(array, 0);
+  }
+
+  return Qnil;
+  RB_GC_GUARD(identity_storage);
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(array);
+}
+
+VALUE safe_query_single_row_transform(query_ctx *ctx) {
+  VALUE array = rb_ary_new();
+  VALUE identity_storage = rb_hash_new();
+  VALUE row = Qnil;
+  // int column_count = sqlite3_column_count(ctx->stmt);
+  struct transform_node *transform_root = get_transform_root(ctx->transform);
+
+  int row_count = 0;
+  while (stmt_iterate(ctx)) {
+    row_count++;
+    row = run_transform(identity_storage, transform_root, ctx->stmt);
+    if (!NIL_P(row)) { rb_ary_push(array, row); }
+  }
+
+  row = rb_ary_entry(array, 0);
+  switch (ctx->row_mode) {
+    case ROW_YIELD:
+      rb_yield(row);
+      return ctx->self;
+    case ROW_MULTI:
+    case ROW_SINGLE:
+      return row;
+  }
+
+  return Qnil;
+  RB_GC_GUARD(identity_storage);
+  RB_GC_GUARD(row);
+  RB_GC_GUARD(array);
+}
+
 VALUE safe_query_splat(query_ctx *ctx);
 
 VALUE safe_query_hash(query_ctx *ctx) {
@@ -374,12 +586,12 @@ VALUE safe_query_hash(query_ctx *ctx) {
   int column_count = sqlite3_column_count(ctx->stmt);
   struct column_names names = get_column_names(ctx->stmt, column_count);
   int row_count = 0;
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   while (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
     if (do_transform)
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+      row = INVOKE_PROC(ctx->transform, 1, &row);
     row_count++;
     switch (ctx->row_mode) {
       case ROW_YIELD:
@@ -416,7 +628,7 @@ VALUE safe_query_hash(query_ctx *ctx) {
 #define ARGV_GET_ROW(ctx, column_count, argv_values, row, do_transform, return_rows) \
   row_to_splat_values(ctx->stmt, column_count, argv_values); \
   if (do_transform) \
-    row = INVOKE_PROC(ctx->transform_proc, column_count, argv_values); \
+    row = INVOKE_PROC(ctx->transform, column_count, argv_values); \
   else if (return_rows) \
     row = column_count == 1 ? argv_values[0] : rb_ary_new_from_values(column_count, argv_values);
 
@@ -428,7 +640,7 @@ VALUE safe_query_splat(query_ctx *ctx) {
   if (column_count > MAX_ARGV_COLUMNS)
     rb_raise(cError, "Conversion is supported only up to %d columns", MAX_ARGV_COLUMNS);
 
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
   int return_rows = (ctx->row_mode != ROW_YIELD);
 
   int row_count = 0;
@@ -463,12 +675,12 @@ VALUE safe_query_array(query_ctx *ctx) {
   VALUE row = Qnil;
   int column_count = sqlite3_column_count(ctx->stmt);
   int row_count = 0;
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   while (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+      row = INVOKE_PROC(ctx->transform, 1, &row);
     row_count++;
     switch (ctx->row_mode) {
       case ROW_YIELD:
@@ -496,8 +708,8 @@ VALUE safe_query_single_row_hash(query_ctx *ctx) {
 
   if (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
-    if (!NIL_P(ctx->transform_proc))
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+    if (!NIL_P(ctx->transform))
+      row = INVOKE_PROC(ctx->transform, 1, &row);
   }
 
   RB_GC_GUARD(row);
@@ -511,7 +723,7 @@ VALUE safe_query_single_row_splat(query_ctx *ctx) {
   int column_count = sqlite3_column_count(ctx->stmt);
   if (column_count > MAX_ARGV_COLUMNS)
     rb_raise(cError, "Conversion is supported only up to %d columns", MAX_ARGV_COLUMNS);
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   if (stmt_iterate(ctx)) {
     ARGV_GET_ROW(ctx, column_count, argv_values, row, do_transform, 1);
@@ -525,12 +737,12 @@ VALUE safe_query_single_row_splat(query_ctx *ctx) {
 VALUE safe_query_single_row_array(query_ctx *ctx) {
   int column_count = sqlite3_column_count(ctx->stmt);
   VALUE row = Qnil;
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   if (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+      row = INVOKE_PROC(ctx->transform, 1, &row);
   }
 
   RB_GC_GUARD(row);
@@ -549,12 +761,12 @@ static inline VALUE batch_iterate_hash(query_ctx *ctx) {
   VALUE row = Qnil;
   int column_count = sqlite3_column_count(ctx->stmt);
   struct column_names names = get_column_names(ctx->stmt, column_count);
-  const int do_transform = !NIL_P(ctx->transform_proc);
+  const int do_transform = !NIL_P(ctx->transform);
 
   while (stmt_iterate(ctx)) {
     row = row_to_hash(ctx->stmt, column_count, &names);
     if (do_transform)
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+      row = INVOKE_PROC(ctx->transform, 1, &row);
     rb_ary_push(rows, row);
   }
 
@@ -568,12 +780,12 @@ static inline VALUE batch_iterate_array(query_ctx *ctx) {
   VALUE rows = rb_ary_new();
   VALUE row = Qnil;
   int column_count = sqlite3_column_count(ctx->stmt);
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   while (stmt_iterate(ctx)) {
     row = row_to_array(ctx->stmt, column_count);
     if (do_transform)
-      row = INVOKE_PROC(ctx->transform_proc, 1, &row);
+      row = INVOKE_PROC(ctx->transform, 1, &row);
     rb_ary_push(rows, row);
   }
 
@@ -589,7 +801,7 @@ static inline VALUE batch_iterate_splat(query_ctx *ctx) {
   int column_count = sqlite3_column_count(ctx->stmt);
   if (column_count > MAX_ARGV_COLUMNS)
     rb_raise(cError, "Conversion is supported only up to %d columns", MAX_ARGV_COLUMNS);
-  int do_transform = !NIL_P(ctx->transform_proc);
+  int do_transform = !NIL_P(ctx->transform);
 
   while (stmt_iterate(ctx)) {
     ARGV_GET_ROW(ctx, column_count, argv_values, row, do_transform, 1);
@@ -753,13 +965,13 @@ static inline VALUE batch_run_proc(query_ctx *ctx, enum batch_mode batch_mode) {
 static inline VALUE batch_run(query_ctx *ctx, enum batch_mode batch_mode) {
   if (TYPE(ctx->params) == T_ARRAY)
     return batch_run_array(ctx, batch_mode);
-  
+
   if (rb_respond_to(ctx->params, ID_each))
     return batch_run_each(ctx, batch_mode);
-  
+
   if (rb_respond_to(ctx->params, ID_call))
     return batch_run_proc(ctx, batch_mode);
-  
+
   rb_raise(cParameterError, "Invalid parameter source supplied to #batch_execute");
 }
 
@@ -777,7 +989,7 @@ VALUE safe_batch_query(query_ctx *ctx) {
       return batch_run(ctx, BATCH_QUERY_ARRAY);
     default:
       rb_raise(cError, "Invalid query mode (safe_batch_query)");
-  }  
+  }
 }
 
 VALUE safe_batch_query_array(query_ctx *ctx) {