Add BLOB support with test for binary data

Add Vector#assign_string_element_len to properly handle BLOB data
containing null bytes. The existing assign_string_element uses
StringValueCStr which stops at null bytes, making it unsuitable
for binary data.

Changes:
- Add Vector#assign_string_element_len using StringValuePtr + RSTRING_LEN
- Update DataChunk#set_value to use _len variant for BLOB type
- Add comprehensive BLOB test with null bytes
- Update CHANGELOG.md

Test covers:
- Binary data with leading null bytes (\x00\x01\x02\x03)
- Binary data with embedded null bytes (binary\x00data)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: suketa

CHANGELOG.md

@@ -6,6 +6,7 @@ All notable changes to this project will be documented in this file.
 - add DuckDB::DataChunk#set_value method for high-level value writing with automatic type conversion.
 - add DuckDB::MemoryHelper write methods for all numeric types (boolean, tinyint, smallint, utinyint, usmallint, uinteger, ubigint, float).
 - add DuckDB::Vector#set_validity method to mark rows as NULL or valid.
+- add DuckDB::Vector#assign_string_element_len method for BLOB data with null bytes.
 - add DuckDB::Vector#logical_type method to get the column type of a vector.
 - add DuckDB::TableFunction class (Phase 1: Core container).
 - add DuckDB::TableFunction#initialize for standard Ruby allocation pattern.

ext/duckdb/vector.c

@@ -8,6 +8,7 @@ static size_t memsize(const void *p);
 static VALUE rbduckdb_vector_get_data(VALUE self);
 static VALUE rbduckdb_vector_get_validity(VALUE self);
 static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALUE str);
+static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str);
 static VALUE rbduckdb_vector_logical_type(VALUE self);
 static VALUE rbduckdb_vector_set_validity(VALUE self, VALUE index, VALUE valid);
 
@@ -104,6 +105,32 @@ static VALUE rbduckdb_vector_assign_string_element(VALUE self, VALUE index, VALU
     return self;
 }
 
+/*
+ * call-seq:
+ *   vector.assign_string_element_len(index, str) -> self
+ *
+ * Assigns a string/blob value at the specified index with explicit length.
+ * Supports strings containing null bytes (for BLOB columns).
+ *
+ *   vector.assign_string_element_len(0, "\x00\x01\x02\x03")
+ */
+static VALUE rbduckdb_vector_assign_string_element_len(VALUE self, VALUE index, VALUE str) {
+    rubyDuckDBVector *ctx;
+    idx_t idx;
+    const char *string_val;
+    idx_t str_len;
+
+    TypedData_Get_Struct(self, rubyDuckDBVector, &vector_data_type, ctx);
+
+    idx = NUM2ULL(index);
+    string_val = StringValuePtr(str);
+    str_len = RSTRING_LEN(str);
+
+    duckdb_vector_assign_string_element_len(ctx->vector, idx, string_val, str_len);
+
+    return self;
+}
+
 /*
  * call-seq:
  *   vector.logical_type -> DuckDB::LogicalType
@@ -168,6 +195,7 @@ void rbduckdb_init_duckdb_vector(void) {
     rb_define_method(cDuckDBVector, "get_data", rbduckdb_vector_get_data, 0);
     rb_define_method(cDuckDBVector, "get_validity", rbduckdb_vector_get_validity, 0);
     rb_define_method(cDuckDBVector, "assign_string_element", rbduckdb_vector_assign_string_element, 2);
+    rb_define_method(cDuckDBVector, "assign_string_element_len", rbduckdb_vector_assign_string_element_len, 2);
     rb_define_method(cDuckDBVector, "logical_type", rbduckdb_vector_logical_type, 0);
     rb_define_method(cDuckDBVector, "set_validity", rbduckdb_vector_set_validity, 2);
 }

lib/duckdb/data_chunk.rb

@@ -90,8 +90,10 @@ def set_value(col_idx, row_idx, value)
       when :double
         data = vector.get_data
         MemoryHelper.write_double(data, row_idx, value)
-      when :varchar, :blob
+      when :varchar
         vector.assign_string_element(row_idx, value.to_s)
+      when :blob
+        vector.assign_string_element_len(row_idx, value.to_s)
       else
         raise ArgumentError, "Unsupported type for DataChunk#set_value: #{type_id}"
       end

test/duckdb_test/data_chunk_test.rb

@@ -267,7 +267,43 @@ def test_data_chunk_set_value_null # rubocop:disable Metrics/AbcSize, Metrics/Me
       assert_equal 100, rows[2].first
     end
 
-    # Test 10: DataChunk#set_value with multiple columns
+    # Test 10: DataChunk#set_value with BLOB
+    def test_data_chunk_set_value_blob # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @conn.execute('SET threads=1')
+
+      done = false
+      table_function = DuckDB::TableFunction.new
+      table_function.name = 'test_set_value_blob'
+
+      table_function.bind do |bind_info|
+        bind_info.add_result_column('data', DuckDB::LogicalType::BLOB)
+      end
+
+      table_function.init { |_init_info| done = false }
+
+      table_function.execute do |_func_info, output|
+        if done
+          output.size = 0
+        else
+          blob1 = "\x00\x01\x02\x03".b
+          blob2 = "binary\x00data".b
+          output.set_value(0, 0, blob1)
+          output.set_value(0, 1, blob2)
+          output.size = 2
+          done = true
+        end
+      end
+
+      @conn.register_table_function(table_function)
+      result = @conn.query('SELECT * FROM test_set_value_blob()')
+      rows = result.each.to_a
+
+      assert_equal 2, rows.length
+      assert_equal "\x00\x01\x02\x03".b, rows[0].first
+      assert_equal "binary\x00data".b, rows[1].first
+    end
+
+    # Test 11: DataChunk#set_value with multiple columns
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Minitest/MultipleAssertions
     def test_data_chunk_set_value_multiple_columns
       @conn.execute('SET threads=1')