mongory 0.8.0-x86_64-linux → 0.8.2-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4acb7e520b6b975f392b3b1e97d5a6300f288f623e5f8c53d75b9561d0519b1
-  data.tar.gz: 47ced57b77a9b68208c948fdcb0348a1da58972b1795ca64c3893b586e864113
+  metadata.gz: 62fa18e529cd104d255956668e3acb8421d5d8a943d9c8505a6fec1213bed592
+  data.tar.gz: 75aefb02081fcd48af41b6d8f6cdb9c22cc066821a92b02e227ef3818c50b547
 SHA512:
-  metadata.gz: 16796ae6a17cea54814d0a20da9d4322432b1c0983d726a124a2f1555e527572d81930b38436e3dc6f833dc696554d2c1495e0a0a407fb3e4d3b5bf187dcee60
-  data.tar.gz: 2d379d2759e579050da26bfbf50887f0146800a48c1c750dbe04726fd5bb887e20d80834c54ad6f3ef05d5d5895e0a93e00a501ea5191827d3923a84eff7e518
+  metadata.gz: d1d092f65c6afcd16ec537795d08f03b60d66bce217281e9d854d42657de024b3230c93f5115e3552f60c51389dfec3b14f61657ebc03eb08effacffe108b66f
+  data.tar.gz: c9426e11587601a802b57a054665d9d43a7e393d00b397aa17c2d6e77598a21f8d9a2ee52941e11b00f6aeb2f656b6620da7b6eb14cf94acd0c5813e54f3b614

data/CHANGELOG.md

@@ -1,4 +1,39 @@
 # Changelog
+
+## [0.8.2] - 2026-11-14
+
+### Fixes
+- **Key & Array Index Matching (`QueryMatcher` & `CMatcher`)**:
+  - Normalize `Integer` condition keys to `String` in `KeyConverter` (consistent with `Symbol` keys), preventing `TypeError` in `CMatcher` and `NoMethodError` in `FieldMatcher`.
+  - Enforce strict integer index format (`\A(?:0|-?[1-9]\d*)\z`) when matching against arrays so keys with leading zeros (e.g., `"01"`, `"-0"`) or multiline strings are treated as document field keys rather than array indices.
+  - Treat valid numeric keys on `Array` records strictly as array indices in both `FieldMatcher` and `mongory-core`.
+- **C Extension (`mongory_ext`)**:
+  - Fix GC use-after-free crash when `$regex` condition is given as a `String` pattern by registering the compiled `Regexp` in the matcher's GC `mark_list`.
+  - Fix NULL pointer dereference crash when calling `CMatcher#disable_trace` or `CMatcher#print_trace` before `enable_trace`.
+  - Fix memory pool type mismatch and out-of-bounds `owner` read in `CMatcher#trace` and uninitialized `owner` pointer in `CMatcher#enable_trace`.
+  - Prevent memory leaks when `CMatcher.new`, `trace`, `enable_trace`, or `disable_trace` raises `Mongory::TypeError`.
+  - Coerce non-string/non-symbol hash keys in `DataConverter`-converted condition values and register them in `mark_list`.
+- **Core (`mongory-core` submodule)**:
+  - Fix off-by-one capacity growth condition in `mongory_array` and `mongory_table`.
+  - Propagate `extern_ctx` in `mongory_matcher_field_new` so nested custom matchers receive the Ruby matcher context.
+  - Sync trace state across `literal_matcher`'s `delegate_matcher` and `array_record_matcher`.
+  - Return `mongory_value_compare_fail` when comparing `NaN` float/double values instead of treating `NaN` as equal.
+
+## [0.8.1] - 2025-08-30
+
+### Fixes
+- Use `require_relative` instead of `require` for internal file loading.
+
+### Docs & Chores
+- Deprecate `QueryBuilder#fast` and update YARD documentation and README.
+
+## [0.8.0] - 2025-08-30
+
+### Features
+- Add trace mode support to `QueryBuilder` and `CQueryBuilder`, printing trace output and resetting trace pool on each match.
+- Expose `CMatcher.trace_result_colorful=` configuration option.
+- Support cross-platform precompiled native gems for Linux (`x86_64`, `aarch64`, musl/glibc), macOS (`x86_64-darwin`, `arm64-darwin`), and Windows (`x64-mingw32`, `x64-mingw-ucrt`).
+
 ## [0.7.1] - 2025-08-17
 ### Fixes
 - Linter error

data/README.md

@@ -110,6 +110,18 @@ records = [
 result = records.mongory
   .where(:age.gte => 18)
   .or({ :name => /J/ }, { :name.eq => 'Bob' })
+  .to_a
+
+# Or input condition via json string from front-end
+result = records.mongory
+  .where(JSON.parse('{
+    "age": {"$gt": 18},
+    "$or": [
+      {"name": {"$regex": "J"}},
+      {"name": "Bob"}
+    ]
+  }'))
+  .to_a
 
 # Using limit to restrict results
 # Note: limit executes immediately and affects subsequent conditions

data/docs/advanced_usage.md

@@ -25,6 +25,16 @@ users.mongory
 posts.mongory
   .where(:tags.elem_match => { :name => 'ruby', :priority.gt => 5 })
   .where(:comments.every => { :approved => true })
+
+# Since Matcher provide `to_proc` method, you could treat Matcher as a block
+matcher = Mongory::QueryMatcher.new({
+  :tags.elem_match => { :name => 'ruby', :priority.gt => 5 },
+  :comments.every => { :approved => true }
+})
+
+# Will filter
+posts_1.select!(&matcher)
+posts_2.select!(&matcher)
 ```
 
 ## Integration with ActiveRecord

data/ext/mongory_ext/mongory-core/src/foundations/array.c

@@ -146,8 +146,8 @@ static inline mongory_value *mongory_array_get(mongory_array *self, size_t index
  */
 static inline bool mongory_array_set(mongory_array *self, size_t index, mongory_value *value) {
   mongory_array_private *internal = (mongory_array_private *)self;
-  // Ensure capacity for the given index (index + 1 elements).
-  if (!mongory_array_grow_if_needed(self, index + 1)) {
+  // Ensure capacity for the given 0-based index.
+  if (!mongory_array_grow_if_needed(self, index)) {
     return false;
   }
 
@@ -163,17 +163,10 @@ static inline bool mongory_array_set(mongory_array *self, size_t index, mongory_
   return true;
 }
 
-/**
- * @brief Creates and initializes a new mongory_array.
- *
- * Allocates memory for the array structure itself and its initial item storage
- * using the provided memory pool. Assigns function pointers for array
- * operations.
- *
- * @param pool The memory pool to use for allocations.
- * @return Pointer to the new mongory_array, or NULL on allocation failure.
- */
-mongory_array *mongory_array_new(mongory_memory_pool *pool) {
+mongory_array *mongory_array_new_with_capacity(mongory_memory_pool *pool, size_t capacity) {
+  if (capacity == 0) {
+    capacity = MONGORY_ARRAY_INIT_SIZE;
+  }
   // First, allocate the private structure that holds all array metadata.
   mongory_array_private *internal = MG_ALLOC_PTR(pool, mongory_array_private);
   if (!internal) {
@@ -182,7 +175,7 @@ mongory_array *mongory_array_new(mongory_memory_pool *pool) {
   }
 
   // Then, allocate the initial block of memory for the array items.
-  mongory_value **items = MG_ALLOC_ARY(pool, mongory_value*, MONGORY_ARRAY_INIT_SIZE);
+  mongory_value **items = MG_ALLOC_ARY(pool, mongory_value*, capacity);
   if (!items) {
     // If this fails, the 'internal' struct allocated above will be cleaned up
     // by the pool, assuming it's a tracing pool.
@@ -200,11 +193,25 @@ mongory_array *mongory_array_new(mongory_memory_pool *pool) {
 
   // Initialize the private part of the array structure.
   internal->items = items;
-  internal->capacity = MONGORY_ARRAY_INIT_SIZE;
+  internal->capacity = capacity;
 
   return &internal->base; // Return pointer to the public structure.
 }
 
+/**
+ * @brief Creates and initializes a new mongory_array.
+ *
+ * Allocates memory for the array structure itself and its initial item storage
+ * using the provided memory pool. Assigns function pointers for array
+ * operations.
+ *
+ * @param pool The memory pool to use for allocations.
+ * @return Pointer to the new mongory_array, or NULL on allocation failure.
+ */
+mongory_array *mongory_array_new(mongory_memory_pool *pool) {
+  return mongory_array_new_with_capacity(pool, MONGORY_ARRAY_INIT_SIZE);
+}
+
 /**
  * @brief Creates a new mongory_array instance with a nested array.
  *

data/ext/mongory_ext/mongory-core/src/foundations/array_private.h

@@ -6,6 +6,7 @@
 #include <stdbool.h>
 
 bool mongory_array_resize(mongory_array *self, size_t size); // resize array
+mongory_array *mongory_array_new_with_capacity(mongory_memory_pool *pool, size_t capacity);
 
 typedef struct mongory_array_private {
   mongory_array base;    // public array

data/ext/mongory_ext/mongory-core/src/foundations/string_buffer.c

@@ -16,8 +16,6 @@ mongory_string_buffer *mongory_string_buffer_new(mongory_memory_pool *pool) {
   return buffer;
 }
 
-void mongory_string_buffer_free(mongory_string_buffer *buffer) { buffer->pool->free(buffer->pool->ctx); }
-
 static inline void mongory_string_buffer_grow(mongory_string_buffer *buffer, size_t additional_size) {
   bool trigger_grow = false;
   while (buffer->size + additional_size + 1 > buffer->capacity) {

data/ext/mongory_ext/mongory-core/src/foundations/string_buffer.h

@@ -40,10 +40,4 @@ char *mongory_string_buffer_cstr(mongory_string_buffer *buffer);
  */
 void mongory_string_buffer_clear(mongory_string_buffer *buffer);
 
-/**
- * @brief Frees the buffer.
- * @param buffer The buffer to free.
- */
-void mongory_string_buffer_free(mongory_string_buffer *buffer);
-
 #endif

data/ext/mongory_ext/mongory-core/src/foundations/table.c

@@ -178,11 +178,12 @@ static inline bool mongory_table_rehash(mongory_table *self) {
   // might copy elements if count is not zero. We are managing elements manually.
   internal->array->count = 0;
 
-  if (!mongory_array_resize(internal->array, new_capacity)) {
+  if (!mongory_array_resize(internal->array, new_capacity) ||
+      !internal->array->set(internal->array, new_capacity - 1, NULL)) {
     // Error: Rehashing failed because the underlying array could not be resized.
     // The table remains functional but may have a suboptimal load factor.
     self->pool->error = &MONGORY_ALLOC_ERROR;
-    internal->array->count = self->count; // Try to restore roughly
+    internal->array->count = original_capacity; // Restore previous bucket count
     return false;
   }
   // After resize, internal->array (and old_array_private_view) points to the
@@ -416,14 +417,12 @@ mongory_table *mongory_table_new(mongory_memory_pool *pool) {
     return NULL; // Must have a valid pool.
 
   size_t init_capacity = MONGORY_TABLE_INIT_SIZE;
-  mongory_array *bucket_array = mongory_array_new(pool);
-
-  // Initialize the bucket array. We resize it to the initial capacity and
-  // then set the last element to NULL. The `mongory_array_set` function
-  // will automatically fill all intermediate slots with NULL if the index is
-  // out of bounds, which perfectly initializes our bucket array.
-  bool array_init_success = bucket_array && mongory_array_resize(bucket_array, init_capacity) &&
-                            bucket_array->set(bucket_array, init_capacity - 1, NULL);
+  mongory_array *bucket_array = mongory_array_new_with_capacity(pool, init_capacity);
+
+  // Initialize the bucket array by setting the last element to NULL.
+  // The `mongory_array_set` function will automatically fill all intermediate
+  // slots with NULL without triggering a resize.
+  bool array_init_success = bucket_array && bucket_array->set(bucket_array, init_capacity - 1, NULL);
 
   if (!array_init_success) {
     // If array initialization fails, we cannot proceed.

data/ext/mongory_ext/mongory-core/src/foundations/utils.c

@@ -25,30 +25,40 @@
  *         `false` otherwise. `errno` may be set by `strtol`.
  */
 bool mongory_try_parse_int(const char *key, int *out) {
-  if (key == NULL || *key == '\0') {
+  if (key == NULL) {
     return false; // Invalid input string.
   }
-  if (out == NULL) {
-    return false; // Output pointer must be valid.
+
+  // Strictly match "0" or "-?[1-9][0-9]*" (no leading whitespace, '+', "-0", or leading zeros like "01").
+  if (key[0] == '0') {
+    if (key[1] != '\0') {
+      return false; // Disallow leading zeros like "00" or "01".
+    }
+    if (out != NULL) {
+      *out = 0;
+    }
+    return true;
+  }
+
+  const char *p = (key[0] == '-') ? key + 1 : key;
+  if (*p < '1') {
+    return false; // Disallow "", "-", "-0", "-01", leading whitespace, or '+'.
   }
 
   char *endptr = NULL;
   errno = 0;                           // Clear errno before calling strtol.
   long val = strtol(key, &endptr, 10); // Base 10 conversion.
 
-  // Check for parsing errors reported by strtol.
-  if (endptr == key) {
-    return false; // No digits were found.
-  }
   if (*endptr != '\0') {
     return false; // Additional characters after the number.
   }
-  if (errno == ERANGE || val < INT_MIN || val > INT_MAX) {
-    // Value out of range for int. ERANGE is set by strtol for overflow/underflow.
-    return false;
+  if (val < INT_MIN || val > INT_MAX) {
+    return false; // Value out of range for int.
   }
 
-  *out = (int)val; // Successfully parsed and within int range.
+  if (out != NULL) {
+    *out = (int)val; // Successfully parsed and within int range.
+  }
   return true;
 }
 

data/ext/mongory_ext/mongory-core/src/foundations/utils.h

@@ -13,8 +13,8 @@
  * range (`INT_MIN`, `INT_MAX`).
  *
  * @param key The null-terminated string to parse. Must not be NULL or empty.
- * @param out A pointer to an integer where the parsed value will be stored if
- * successful. Must not be NULL.
+ * @param out Optional pointer to an integer where the parsed value will be
+ * stored if successful. May be NULL if only validation is needed.
  * @return bool True if the string was successfully parsed as an integer and is
  * within `int` range, false otherwise. `errno` might be set by `strtol` on
  * failure (e.g. `ERANGE`).

data/ext/mongory_ext/mongory-core/src/foundations/value.c

@@ -154,6 +154,9 @@ static inline int mongory_value_int_compare(mongory_value *a, mongory_value *b)
     // Compare int (a) as double with double (b).
     double a_as_double = (double)a->data.i;
     double b_value = b->data.d;
+    if (b_value != b_value) {
+      return mongory_value_compare_fail; // NaN is not comparable.
+    }
     return (a_as_double > b_value) - (a_as_double < b_value);
   }
   if (b->type == MONGORY_TYPE_INT) {
@@ -179,14 +182,19 @@ mongory_value *mongory_value_wrap_i(mongory_memory_pool *pool, int64_t i_val) {
 
 /** Compares MONGORY_TYPE_DOUBLE with DOUBLE or INT. */
 static inline int mongory_value_double_compare(mongory_value *a, mongory_value *b) {
+  double a_value = a->data.d;
+  if (a_value != a_value) {
+    return mongory_value_compare_fail; // NaN is not comparable.
+  }
   if (b->type == MONGORY_TYPE_DOUBLE) {
-    double a_value = a->data.d;
     double b_value = b->data.d;
+    if (b_value != b_value) {
+      return mongory_value_compare_fail; // NaN is not comparable.
+    }
     return (a_value > b_value) - (a_value < b_value);
   }
   if (b->type == MONGORY_TYPE_INT) {
     // Compare double (a) with int (b) as double.
-    double a_value = a->data.d;
     double b_as_double = (double)b->data.i;
     return (a_value > b_as_double) - (a_value < b_as_double);
   }

data/ext/mongory_ext/mongory-core/src/matchers/base_matcher.h

@@ -97,4 +97,6 @@ mongory_matcher *mongory_matcher_always_true_new(mongory_memory_pool *pool, mong
  */
 mongory_matcher *mongory_matcher_always_false_new(mongory_memory_pool *pool, mongory_value *condition, void *extern_ctx);
 
+void mongory_matcher_enable_trace_at(mongory_matcher *matcher, mongory_array *trace_stack, int level);
+
 #endif /* MONGORY_MATCHER_BASE_H */

data/ext/mongory_ext/mongory-core/src/matchers/existance_matcher.c

@@ -95,7 +95,7 @@ static inline bool mongory_matcher_present_match(mongory_matcher *matcher, mongo
     return !condition_expects_presence;
   }
 
-  bool actual_value_is_present;
+  bool actual_value_is_present = false;
   switch (value->type) {
   case MONGORY_TYPE_ARRAY:
     actual_value_is_present = (value->data.a != NULL && value->data.a->count > 0);
@@ -103,9 +103,22 @@ static inline bool mongory_matcher_present_match(mongory_matcher *matcher, mongo
   case MONGORY_TYPE_TABLE:
     actual_value_is_present = (value->data.t != NULL && value->data.t->count > 0);
     break;
-  case MONGORY_TYPE_STRING:
-    actual_value_is_present = (value->data.s != NULL && *(value->data.s) != '\0');
+  case MONGORY_TYPE_STRING: {
+    // If the string is NULL, it is not "present".
+    // If the strint is "  " or more than one space, it is not "present".
+    char *s = value->data.s;
+    if (s != NULL && *s != '\0') {
+      char *p = s;
+      while (*p != '\0') {
+        if (*p != ' ') {
+          actual_value_is_present = true;
+          break;
+        }
+        p++;
+      }
+    }
     break;
+  }
   case MONGORY_TYPE_NULL:
     actual_value_is_present = false; // An explicit BSON-style Null is not "present".
     break;

data/ext/mongory_ext/mongory-core/src/matchers/literal_matcher.c

@@ -62,6 +62,9 @@ static inline bool mongory_matcher_literal_match(mongory_matcher *matcher, mongo
       // Lazily create the array_record_matcher if needed.
       // The condition for array_record_new is the original condition of the literal matcher.
       literal->array_record_matcher = mongory_matcher_array_record_new(literal->base.pool, literal->base.condition, literal->base.extern_ctx);
+      if (literal->array_record_matcher && literal->base.trace_stack) {
+        mongory_matcher_enable_trace_at(literal->array_record_matcher, literal->base.trace_stack, literal->base.trace_level + 1);
+      }
     }
     // If right child exists (or was successfully created), use it.
     return literal->array_record_matcher ? literal->array_record_matcher->match(literal->array_record_matcher, value) : false;
@@ -207,6 +210,7 @@ mongory_matcher *mongory_matcher_field_new(mongory_memory_pool *pool, char *fiel
   field_m->literal.base.name = mongory_string_cpy(pool, "Field");
   field_m->literal.base.explain = mongory_matcher_field_explain;
   field_m->literal.base.traverse = mongory_matcher_literal_traverse;
+  field_m->literal.base.extern_ctx = extern_ctx;
   // The 'left' child of the composite is the actual matcher for the field's value,
   // determined by the type of 'condition_for_field'.
   field_m->literal.delegate_matcher = mongory_matcher_literal_delegate(pool, condition_for_field, extern_ctx);

data/ext/mongory_ext/mongory-core/src/matchers/matcher.c

@@ -147,13 +147,38 @@ static bool mongory_matcher_enable_trace_cb(mongory_matcher *matcher, mongory_ma
   matcher->trace_stack = (mongory_array *)ctx->acc;
   matcher->trace_level = ctx->level;
   matcher->match = mongory_matcher_traced_match;
+  if (matcher->traverse == mongory_matcher_literal_traverse) {
+    mongory_literal_matcher *literal = (mongory_literal_matcher *)matcher;
+    if (literal->array_record_matcher && literal->delegate_matcher) {
+      mongory_matcher_traverse_context delegate_ctx = {
+          .pool = ctx->pool,
+          .level = ctx->level + 1,
+          .count = 0,
+          .total = 1,
+          .acc = ctx->acc,
+          .callback = ctx->callback,
+      };
+      literal->delegate_matcher->traverse(literal->delegate_matcher, &delegate_ctx);
+    }
+  }
   return true;
 }
 
 static bool mongory_matcher_disable_trace_cb(mongory_matcher *matcher, mongory_matcher_traverse_context *ctx) {
-  (void)ctx;
   matcher->match = matcher->original_match;
   matcher->trace_stack = NULL;
+  if (matcher->traverse == mongory_matcher_literal_traverse) {
+    mongory_literal_matcher *literal = (mongory_literal_matcher *)matcher;
+    if (literal->array_record_matcher && literal->delegate_matcher) {
+      mongory_matcher_traverse_context delegate_ctx = {
+          .level = ctx->level + 1,
+          .count = 0,
+          .total = 1,
+          .callback = ctx->callback,
+      };
+      literal->delegate_matcher->traverse(literal->delegate_matcher, &delegate_ctx);
+    }
+  }
   return true;
 }
 
@@ -192,15 +217,17 @@ static mongory_array *mongory_matcher_traces_sort(mongory_array *self, int level
   return sorted_array;
 }
 
-void mongory_matcher_enable_trace(mongory_matcher *matcher, mongory_memory_pool *temp_pool) {
-  MONGORY_VALIDATE_PTR(temp_pool, matcher) && MONGORY_VALIDATE_PTR(temp_pool, matcher->traverse);
-  if (temp_pool->error != NULL) {
+void mongory_matcher_enable_trace_at(mongory_matcher *matcher, mongory_array *trace_stack, int level) {
+  if (!matcher || !trace_stack) {
+    return;
+  }
+  MONGORY_VALIDATE_PTR(trace_stack->pool, matcher->traverse);
+  if (trace_stack->pool->error != NULL) {
     return;
   }
-  mongory_array *trace_stack = mongory_array_new(temp_pool);
   mongory_matcher_traverse_context ctx = {
-      .pool = temp_pool,
-      .level = 0,
+      .pool = trace_stack->pool,
+      .level = level,
       .count = 0,
       .total = 0,
       .acc = (void *)trace_stack,
@@ -209,6 +236,15 @@ void mongory_matcher_enable_trace(mongory_matcher *matcher, mongory_memory_pool
   matcher->traverse(matcher, &ctx);
 }
 
+void mongory_matcher_enable_trace(mongory_matcher *matcher, mongory_memory_pool *temp_pool) {
+  MONGORY_VALIDATE_PTR(temp_pool, matcher) && MONGORY_VALIDATE_PTR(temp_pool, matcher->traverse);
+  if (temp_pool->error != NULL) {
+    return;
+  }
+  mongory_array *trace_stack = mongory_array_new(temp_pool);
+  mongory_matcher_enable_trace_at(matcher, trace_stack, 0);
+}
+
 void mongory_matcher_disable_trace(mongory_matcher *matcher) {
   MONGORY_VALIDATE_PTR(matcher->pool, matcher) && MONGORY_VALIDATE_PTR(matcher->pool, matcher->traverse);
   if (matcher->pool->error != NULL) {

data/ext/mongory_ext/mongory_ext.c

@@ -108,11 +108,14 @@ static VALUE rb_mongory_matcher_new(int argc, VALUE *argv, VALUE class) {
   rb_mongory_matcher_parse_argv(wrapper, argc, argv);
 
   mongory_matcher *matcher = mongory_matcher_new(matcher_pool_base, wrapper->condition, wrapper->ctx);
-  if (rb_mongory_error_handling(matcher_pool_base, "Failed to create matcher")) {
+  if (matcher_pool_base->error) {
+    char err_msg[256];
+    snprintf(err_msg, sizeof(err_msg), "%s",
+             matcher_pool_base->error->message ? matcher_pool_base->error->message : "Unknown error");
     matcher_pool_base->free(matcher_pool_base);
     scratch_pool_base->free(scratch_pool_base);
     xfree(wrapper);
-    return Qnil;
+    rb_raise(eMongoryTypeError, "Failed to create matcher: %s", err_msg);
   }
 
   wrapper->matcher = matcher;
@@ -182,16 +185,21 @@ static VALUE rb_mongory_matcher_explain(VALUE self) {
 static VALUE rb_mongory_matcher_trace(VALUE self, VALUE data) {
   rb_mongory_matcher_t *wrapper;
   TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
-  mongory_memory_pool *trace_pool = mongory_memory_pool_new();
-  mongory_value *data_value = rb_to_mongory_value_shallow(trace_pool, data);
-
-  if (rb_mongory_error_handling(trace_pool, "Trace failed")) {
-    trace_pool->free(trace_pool);
-    return Qnil;
+  rb_mongory_memory_pool_t *trace_pool = rb_mongory_memory_pool_new();
+  trace_pool->owner = wrapper;
+  mongory_memory_pool *trace_pool_base = &trace_pool->base;
+  mongory_value *data_value = rb_to_mongory_value_shallow(trace_pool_base, data);
+
+  if (trace_pool_base->error) {
+    char err_msg[256];
+    snprintf(err_msg, sizeof(err_msg), "%s",
+             trace_pool_base->error->message ? trace_pool_base->error->message : "Unknown error");
+    trace_pool_base->free(trace_pool_base);
+    rb_raise(eMongoryTypeError, "Trace failed: %s", err_msg);
   }
 
   bool matched = mongory_matcher_trace(wrapper->matcher, data_value);
-  trace_pool->free(trace_pool);
+  trace_pool_base->free(trace_pool_base);
 
   return matched ? Qtrue : Qfalse;
 }
@@ -200,14 +208,23 @@ static VALUE rb_mongory_matcher_trace(VALUE self, VALUE data) {
 static VALUE rb_mongory_matcher_enable_trace(VALUE self) {
   rb_mongory_matcher_t *wrapper;
   TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
-  mongory_memory_pool *trace_pool = rb_mongory_memory_pool_new();
-  mongory_matcher_enable_trace(wrapper->matcher, trace_pool);
-
-  if (rb_mongory_error_handling(trace_pool, "Enable trace failed")) {
-    trace_pool->free(trace_pool);
-    return Qnil;
+  if (wrapper->trace_pool) {
+    wrapper->trace_pool->free(wrapper->trace_pool);
+    wrapper->trace_pool = NULL;
   }
-  wrapper->trace_pool = trace_pool;
+  rb_mongory_memory_pool_t *trace_pool = rb_mongory_memory_pool_new();
+  trace_pool->owner = wrapper;
+  mongory_memory_pool *trace_pool_base = &trace_pool->base;
+  mongory_matcher_enable_trace(wrapper->matcher, trace_pool_base);
+
+  if (trace_pool_base->error) {
+    char err_msg[256];
+    snprintf(err_msg, sizeof(err_msg), "%s",
+             trace_pool_base->error->message ? trace_pool_base->error->message : "Unknown error");
+    trace_pool_base->free(trace_pool_base);
+    rb_raise(eMongoryTypeError, "Enable trace failed: %s", err_msg);
+  }
+  wrapper->trace_pool = trace_pool_base;
 
   return Qnil;
 }
@@ -218,9 +235,17 @@ static VALUE rb_mongory_matcher_disable_trace(VALUE self) {
   TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
   mongory_memory_pool *trace_pool = wrapper->trace_pool;
   mongory_matcher_disable_trace(wrapper->matcher);
-  rb_mongory_error_handling(trace_pool, "Disable trace failed");
-  trace_pool->free(trace_pool);
-  wrapper->trace_pool = NULL;
+  if (trace_pool) {
+    wrapper->trace_pool = NULL;
+    if (trace_pool->error) {
+      char err_msg[256];
+      snprintf(err_msg, sizeof(err_msg), "%s",
+               trace_pool->error->message ? trace_pool->error->message : "Unknown error");
+      trace_pool->free(trace_pool);
+      rb_raise(eMongoryTypeError, "Disable trace failed: %s", err_msg);
+    }
+    trace_pool->free(trace_pool);
+  }
 
   return Qnil;
 }
@@ -229,6 +254,9 @@ static VALUE rb_mongory_matcher_disable_trace(VALUE self) {
 static VALUE rb_mongory_matcher_print_trace(VALUE self) {
   rb_mongory_matcher_t *wrapper;
   TypedData_Get_Struct(self, rb_mongory_matcher_t, &rb_mongory_matcher_type, wrapper);
+  if (!wrapper->trace_pool) {
+    return Qnil;
+  }
   mongory_matcher_print_trace(wrapper->matcher);
   rb_mongory_error_handling(wrapper->trace_pool, "Print trace failed");
 
@@ -266,6 +294,7 @@ static rb_mongory_memory_pool_t *rb_mongory_memory_pool_new() {
   rb_mongory_memory_pool_t *pool = malloc(sizeof(rb_mongory_memory_pool_t));
   mongory_memory_pool *base = mongory_memory_pool_new();
   memcpy(&pool->base, base, sizeof(mongory_memory_pool));
+  pool->owner = NULL;
   free(base);
 
   return pool;
@@ -407,12 +436,16 @@ static int hash_foreach_deep_convert_cb(VALUE key, VALUE val, VALUE ptr) {
     key_str = (char *)rb_id2name(SYM2ID(key));
     store_map = owner->symbol_map;
   } else {
+    if (!RB_TYPE_P(key, T_STRING)) {
+      key = rb_obj_as_string(key);
+    }
     key_str = StringValueCStr(key);
     store_map = owner->string_map;
   }
   mongory_value *store = mongory_value_wrap_u(ctx->pool, NULL);
   store->origin = (void *)key;
   store_map->set(store_map, key_str, store);
+  owner->mark_list->push(owner->mark_list, store);
   mongory_value *cval = rb_to_mongory_value_deep(ctx->pool, val);
   ctx->table->set(ctx->table, key_str, cval);
   return ST_CONTINUE;
@@ -591,6 +624,10 @@ static bool rb_mongory_regex_match_adapter(mongory_memory_pool *pool, mongory_va
     mongory_value *temp_value = mongory_value_wrap_regex(pool, (void *)rb_re);
     memcpy(pattern, temp_value, sizeof(mongory_value));
     pattern->origin = (void *)rb_re;
+    rb_mongory_memory_pool_t *rb_pool = (rb_mongory_memory_pool_t *)pool;
+    if (rb_pool->owner) {
+      rb_pool->owner->mark_list->push(rb_pool->owner->mark_list, pattern);
+    }
   } else {
     return false;
   }
@@ -678,6 +715,7 @@ void Init_mongory_ext(void) {
   // Define modules and classes
   mMongory = rb_define_module("Mongory");
   cMongoryMatcher = rb_define_class_under(mMongory, "CMatcher", rb_cObject);
+  rb_undef_alloc_func(cMongoryMatcher);
   mMongoryMatchers = rb_define_module_under(mMongory, "Matchers");
   VALUE mMongoryUtils = rb_define_module_under(mMongory, "Utils");
   cMongoryMatcherContext = rb_define_class_under(mMongoryUtils, "Context", rb_cObject);

data/lib/mongory/c_matcher.rb

@@ -10,9 +10,13 @@ module Mongory
   #   collection.mongory.c.where(condition).to_a
   class CMatcher
     # @!method self.new(condition)
-    #   @param condition [Object] the condition
+    #   @param condition [Hash] the condition
     #   @return [Mongory::CMatcher] a new matcher
     #   @note This method is implemented in the C extension
+    # @!method self.trace_result_colorful=(colorful)
+    #   @param colorful [Boolean] whether to enable colorful trace result
+    #   @return [void]
+    #   @note This method is implemented in the C extension
     #
     #   @!method match?(record)
     #     @param record [Object] the record to match against
@@ -20,7 +24,7 @@ module Mongory
     #     @note This method is implemented in the C extension
     #   @!method explain
     #     @return [void]
-    #     @note This method will print metcher tree structure
+    #     @note This method will print matcher tree structure
     #     @note This method is implemented in the C extension
     #   @!method trace
     #     @return [Boolean] true if the record matches the condition, false otherwise
@@ -39,15 +43,11 @@ module Mongory
     #     @note This method will print trace result
     #     @note This method is implemented in the C extension
     #   @!method condition
-    #     @return [Object] the condition
+    #     @return [Hash] the condition
     #     @note This method is implemented in the C extension
     #   @!method context
     #     @return [Utils::Context] the context
     #     @note This method is implemented in the C extension
-    #   @!method trace_result_colorful=
-    #     @param colorful [Boolean] whether to enable colorful trace result
-    #     @return [Boolean]
-    #     @note This method is implemented in the C extension
 
     # @return [Proc] a Proc that performs the matching operation
     def to_proc

data/lib/mongory/converters/key_converter.rb

@@ -42,7 +42,7 @@ module Mongory
         case target
         when String
           convert_string_key(target, other)
-        when Symbol
+        when Symbol, Integer
           convert_string_key(target.to_s, other)
         when QueryOperator
           # Handle special case for QueryOperator

data/lib/mongory/matchers/array_record_matcher.rb

@@ -74,7 +74,7 @@ module Mongory
         h_elem_match = {}
         @condition.each_pair do |key, value|
           case key
-          when Integer, /^-?\d+$/
+          when Integer, FieldMatcher::INTEGER_INDEX_REGEX
             h_parsed[key.to_i] = value
           when '$elemMatch'
             h_elem_match.merge!(value)

data/lib/mongory/matchers/field_matcher.rb

@@ -33,6 +33,8 @@ module Mongory
         ::Symbol
       ].freeze
 
+      INTEGER_INDEX_REGEX = /\A(?:0|-?[1-9]\d*)\z/.freeze
+
       # Initializes a new field matcher.
       #
       # @param field [String, Symbol] the field to match against
@@ -84,6 +86,7 @@ module Mongory
       def raw_proc
         super_proc = super
         field = @field
+        str_field, sym_field, int_field = parse_field_keys(field)
         need_convert = @context.need_convert
         data_converter = Mongory.data_converter
 
@@ -91,11 +94,11 @@ module Mongory
           sub_record =
             case record
             when Hash
-              record.fetch(field) do
-                record.fetch(field.to_sym, KEY_NOT_FOUND)
+              record.fetch(str_field) do
+                record.fetch(sym_field, KEY_NOT_FOUND)
               end
             when Array
-              record.fetch(field, KEY_NOT_FOUND)
+              int_field ? record.fetch(int_field, KEY_NOT_FOUND) : KEY_NOT_FOUND
             when KEY_NOT_FOUND, *CLASSES_NOT_ALLOW_TO_DIG
               next false
             else
@@ -124,6 +127,16 @@ module Mongory
 
       private
 
+      def parse_field_keys(field)
+        str_field = field.to_s
+        int_field = if field.is_a?(Integer)
+                      field
+                    elsif field.is_a?(String) && INTEGER_INDEX_REGEX.match?(field)
+                      field.to_i
+                    end
+        [str_field, str_field.to_sym, int_field]
+      end
+
       # Returns a single-line summary of the field matcher including the field and condition.
       #
       # @return [String] a formatted title for tree display

data/lib/mongory/query_builder.rb

@@ -55,10 +55,16 @@ module Mongory
     # Iterates through all records that match the current matcher.
     # Uses a compiled Proc for faster matching.
     #
+    # @deprecated
+    # Since C extension has implemented, the fast mode is no longer needed. Use C extension instead.
+    #
+    # This method is deprecated and will be removed in future versions.
+    #
     # @yieldparam record [Object] each matching record
     # @return [Enumerator] if no block given
     # @return [void] if block given
     def fast
+      warn('Deprecated: Since C extension has implemented, the fast mode is no longer needed. Use C extension instead.')
       return to_enum(:fast) unless block_given?
 
       @context.need_convert = false

data/lib/mongory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mongory
-  VERSION = '0.8.0'
+  VERSION = '0.8.2'
 end

data/lib/mongory.rb

@@ -118,7 +118,7 @@ end
 
 begin
   abi = RUBY_VERSION.split('.').first(2).join('.')
-  require "core/#{abi}/mongory_ext"
+  require_relative "core/#{abi}/mongory_ext"
   require_relative 'mongory/c_query_builder'
   require_relative 'mongory/c_matcher'
 rescue LoadError => e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongory
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: x86_64-linux
 authors:
 - koten0224
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-30 00:00:00.000000000 Z
+date: 2026-11-14 00:00:00.000000000 Z
 dependencies: []
 description: A Mongo-like in-memory query DSL for Ruby
 email:
@@ -84,6 +84,7 @@ files:
 - lib/core/3.2/mongory_ext.so
 - lib/core/3.3/mongory_ext.so
 - lib/core/3.4/mongory_ext.so
+- lib/core/4.0/mongory_ext.so
 - lib/generators/mongory/install/install_generator.rb
 - lib/generators/mongory/install/templates/initializer.rb.erb
 - lib/generators/mongory/matcher/matcher_generator.rb