chalk_ruby 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd2402b4edf2bce128c0f86f9b81ff089bed5a2cb9564fc5c1b30d4290b2d062
-  data.tar.gz: 38380294054c04a7743adf9b2e2080dcba1d73e9a8cb9f1c1ddca032bbb46883
+  metadata.gz: 8e3e6e01afae6634b4b66b557f658573bf4ffd2b657c082652e45185ec48ec05
+  data.tar.gz: 58222edf6ee281ae1cfbaaeec09b628985cfe96ddce3299054f5318e61a1d036
 SHA512:
-  metadata.gz: 99e17dd176aab3cbec5b2c65f1b1e44364978e5f2451f631c0b0c93832078cf73519c2a04982e3cb31ef69b93209550a9610c20326d3120ff361cdd6cedff754
-  data.tar.gz: 0db6e82923b3aaa2ced3401d5a40988b2a98b79ababf13ec50ab228234ab08ebe7c723015f86a8a1438488c5db3627bced34a4ed3bcff5a82ed1aa23a67950a6
+  metadata.gz: 0e995a01c66b8086fff20b2b7d1304458d2370a73205b87b2c6c2860df0a03e93affda126d20cf8d018ed3fe32f0e612e6ef4b7cdef5d95d1b5b02456994eb5b
+  data.tar.gz: b00008371f1f5f5a2fbd3113a7e2db1cca4e58100ac5ba8385cfad08f065acb1476d645edc5f853ca5d8a67392cd4b3ce3d2aed8b85f979aebd618bedde48a68

data/Dockerfile

@@ -0,0 +1,26 @@
+FROM ubuntu:22.04
+
+ENV BUNDLER_VERSION=2.3.6 \
+    BUNDLE_PATH=/app/vendor/bundle
+
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    sudo \
+    wget \
+    lsb-release \
+    build-essential \
+    bash \
+    jq \
+    curl \
+    libffi-dev \
+    git \
+    libglib2.0-dev \
+    ruby-full
+
+# Install Apache Arrow 18
+RUN wget https://apache.jfrog.io/artifactory/arrow/ubuntu/apache-arrow-apt-source-latest-jammy.deb && \
+    apt-get install -y -V ./apache-arrow-apt-source-latest-jammy.deb && \
+    apt-get update && \
+    apt-get install -y -V libarrow-dev=18.* libarrow-glib-dev=18.* libparquet-dev=18.* libarrow-acero-dev=18.* gir1.2-arrow-1.0=18.*
+
+RUN gem install bundler

data/README.md

@@ -1,29 +1,115 @@
-## ChalkRuby Ruby
+# ChalkRuby - Ruby Client for Chalk
 
 [![Gem Version](https://badge.fury.io/rb/chalk_ruby.svg)](https://badge.fury.io/rb/chalk_ruby)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
-Ruby client for Chalk!
+A Ruby client library for [Chalk](https://chalk.ai/), a feature engineering platform for machine learning and data applications.
 
-https://rubygems.org/gems/chalk_ruby
+## Installation
 
-## Getting Started
+Add this line to your application's Gemfile:
 
-First, install ChalkRuby Ruby API Client via the [RubyGems](https://rubygems.org/) package manager:
+```ruby
+gem 'chalk_ruby'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
 
 ```bash
 gem install chalk_ruby
 ```
 
-Then, create a new client using your client ID and client secret:
+## Quick Start
 
 ```ruby
-client = ChalkRuby::Client.create('my-client-id', 'my-client-secret')
+# Create a client with credentials
+client = ChalkRuby::Client.create(
+  'my-client-id',
+  'my-client-secret',
+  'my-environment-id' # Optional, can also use CHALK_ACTIVE_ENVIRONMENT env var
+)
+
+# Query features
 results = client.query(
   input: { 'user.id': 'my-user-id' },
-  output: %w(user.id user.name user.email)
+  output: %w(user.id user.name user.email),
+  query_name: 'user_profile' # Optional: for tracking and monitoring
 )
+
+# Access feature values
+puts results['user.name']
 ```
 
+## Authentication
+
+Authentication can be provided in multiple ways:
+
+1. Directly in the client constructor:
+   ```ruby
+   client = ChalkRuby::Client.create('my-client-id', 'my-client-secret')
+   ```
+
+2. Using environment variables:
+   ```
+   CHALK_CLIENT_ID=my-client-id
+   CHALK_CLIENT_SECRET=my-client-secret
+   CHALK_ACTIVE_ENVIRONMENT=my-environment # Optional
+   ```
+   ```ruby
+   client = ChalkRuby::Client.create
+   ```
+
+## Advanced Usage
+
+### Query Options
+
+The `query` method supports several options:
+
+```ruby
+client.query(
+  input: { 'user.id': 'my-user-id' },
+  output: %w(user.id user.name user.credit_score),
+  now: Time.now,                      # Optional: time at which to evaluate the query
+  staleness: { 'user.credit_score': '1d' }, # Optional: max staleness for cached features
+  tags: { 'environment': 'production' },    # Optional: tags for resolver selection
+  branch: 'my-feature-branch',        # Optional: route request to a specific branch
+  correlation_id: 'request-123',      # Optional: ID for tracing in logs
+  query_name: 'user_profile',         # Optional: semantic name for the query
+  timeout: 5.0                        # Optional: timeout in seconds
+)
+```
+
+### Configuration
+
+Create a client with custom configuration:
+
+```ruby
+config = ChalkRuby::Config.new(
+  client_id: 'my-client-id',
+  client_secret: 'my-client-secret',
+  environment: 'my-environment',
+  query_server: 'https://custom-query-server.chalk.ai',
+  api_server: 'https://custom-api.chalk.ai',
+  additional_headers: { 'X-Custom-Header': 'value' }
+)
+
+client = ChalkRuby::Client.create_with_config(config)
+```
+
+## Requirements
+
+- Ruby 2.7 or higher
+
+## Version
+
+Current version: `0.2.8`
+
 ## License
 
-The Chalk Ruby API Client is an open-sourced software licensed under the [Apache 2 License](LICENSE.md).
+The Chalk Ruby Client is open-sourced software licensed under the [Apache 2.0 License](LICENSE).

data/lib/chalk_ruby/client.rb

@@ -150,7 +150,8 @@ module ChalkRuby
       explain: nil,
       include_meta: nil,
       store_plan_stages: nil,
-      timeout: nil
+      timeout: nil,
+      planner_options: nil
     )
       query_server_request(
         method: :post,
@@ -168,10 +169,11 @@ module ChalkRuby
           meta: meta,
           explain: explain || false,
           include_meta: include_meta || false,
-          store_plan_stages: store_plan_stages || false
+          store_plan_stages: store_plan_stages || false,
+          planner_options: planner_options || {}
         },
         headers: get_authenticated_engine_headers(branch: branch),
-        timeout:
+        timeout: timeout
       )
     end
 

data/lib/chalk_ruby/grpc_client.rb

@@ -146,6 +146,14 @@ module ChalkRuby
       query_service.ping(Chalk::Engine::V1::PingRequest.new(num: 1))
     end
 
+    def convert_to_proto_values(options_hash)
+      return {} if options_hash.nil?
+
+      options_hash.transform_values do |value|
+        convert_to_protobuf_value(value)
+      end
+    end
+
     def query_bulk(
       input:,
       output:,
@@ -157,7 +165,8 @@ module ChalkRuby
       timeout: nil,
       query_name: nil,
       query_name_version: nil,
-      correlation_id: nil
+      correlation_id: nil,
+      planner_options: nil
       )
       # Convert input to feather format
       inputs_feather = to_feather(input)
@@ -167,7 +176,12 @@ module ChalkRuby
         inputs_feather: inputs_feather,
         outputs: output.map { |o| Chalk::Common::V1::OutputExpr.new(feature_fqn: o) },
         staleness: staleness || {},
-        context: context || Chalk::Common::V1::OnlineQueryContext.new(query_name: query_name, query_name_version: query_name_version, correlation_id: correlation_id),
+        context: context || Chalk::Common::V1::OnlineQueryContext.new(
+          query_name: query_name,
+          query_name_version: query_name_version,
+          correlation_id: correlation_id,
+          options: convert_to_proto_values(planner_options)
+        ),
         response_options: response_options || Chalk::Common::V1::OnlineQueryResponseOptions.new,
         body_type: body_type || :FEATHER_BODY_TYPE_UNSPECIFIED
       )
@@ -181,7 +195,31 @@ module ChalkRuby
       output_data = nil
 
       if (!response.scalars_data.nil?) and response.scalars_data.length > 0
-        output_data = arrow_table_to_array(response.scalars_data)
+        buffer = Arrow::Buffer.new(response.scalars_data)
+
+        # Create a buffer reader
+        buffer_reader = Arrow::BufferInputStream.new(buffer)
+
+        # Create an IPC reader from the buffer reader
+        reader = Arrow::FeatherFileReader.new(buffer_reader)
+
+        # Read the table
+
+
+        output_data = []
+
+        table = reader.read
+
+
+        field_names = table.schema.fields.map(&:name)
+        table.each_record do |r|
+          row = {}
+          field_names.each do |f|
+            row[f] = r[f]
+          end
+
+          output_data << row
+        end
       end
 
       {
@@ -205,13 +243,16 @@ module ChalkRuby
       explain: nil,
       include_meta: nil,
       store_plan_stages: nil,
-      timeout: nil
+      timeout: nil,
+      planner_options: nil
     )
       formatted_inputs = input.transform_values { |value| self.convert_to_protobuf_value(value) }
 
       context = Chalk::Common::V1::OnlineQueryContext.new(
         query_name: query_name,
         query_name_version: query_name_version,
+        correlation_id: correlation_id,
+        options: planner_options || {}
       )
 
       r = Chalk::Common::V1::OnlineQueryRequest.new(
@@ -395,47 +436,6 @@ module ChalkRuby
 
       private
 
-    # Converts Arrow binary data to an array of hashes
-    # @param arrow_data [String] Binary Arrow data (IPC stream format)
-    # @return [Array<Hash>] Array of hashes with column name as keys and Ruby values
-    def arrow_table_to_array(arrow_data)
-      require 'arrow'
-      
-      buffer = Arrow::Buffer.new(arrow_data)
-      buffer_reader = Arrow::BufferInputStream.new(buffer)
-      
-      # Try IPC stream format first (which is what we expect from the query service)
-      begin
-        reader = Arrow::RecordBatchStreamReader.new(buffer_reader)
-        table = reader.read_all
-      rescue => e
-        # Fall back to feather format for backward compatibility
-        # buffer_reader.rewind
-        begin
-          reader = Arrow::FeatherFileReader.new(buffer_reader)
-          table = reader.read
-        rescue => e2
-          raise "Failed to parse Arrow data: #{e.message}, #{e2.message}"
-        end
-      end
-      
-      output_data = []
-      field_names = table.schema.fields.map(&:name)
-      
-      table.each_record do |r|
-        row = {}
-        field_names.each do |f|
-          value = r[f]
-          # Convert GLib::Bytes to Ruby String for binary and large string types
-          value = value.to_s if value.is_a?(GLib::Bytes)
-          row[f] = value
-        end
-        output_data << row
-      end
-      
-      output_data
-    end
-
     def to_feather(input_hash)
       require 'arrow'
 

data/lib/chalk_ruby/version.rb

@@ -1,3 +1,3 @@
 module ChalkRuby
-  VERSION = '0.2.8'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/test/chalk_ruby/integration/client_test.rb

@@ -3,15 +3,27 @@ require 'rspec/autorun'
 require 'chalk_ruby/client'
 require 'chalk_ruby/error'
 
-CLIENT_ID     = 'client-095f628e339a593e12a58559f5f8cd00'
-CLIENT_SECRET = 'secret-55601b885bcc0d558c4abede69480aaac1dba6e1679889fa1d5196ba04f7af89'
+CLIENT_ID     = ''
+CLIENT_SECRET = ''
 
 RSpec.describe 'Online query' do
   it 'should accept valid queries' do
     client   = ChalkRuby::Client.create(CLIENT_ID, CLIENT_SECRET)
     response = client.query(
       input: { 'user.id': 3454 },
-      output: %w(user.id)
+      output: %w(user.id),
+      query_name: "no_planner_options_test",
+    )
+
+    print response
+  end
+  it 'should run with planner options' do
+    client   = ChalkRuby::Client.create(CLIENT_ID, CLIENT_SECRET)
+    response = client.query(
+      input: { 'user.id': 3454 },
+      output: %w(user.id),
+      query_name: "planner_options_test",
+      planner_options: {'defer_non_bus_persist_operators': "1"} # test planner option
     )
 
     print response

data/test/chalk_ruby/integration/grpc_client_test.rb

@@ -1,66 +1,43 @@
-$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
-# require 'rspec'
-# require 'chalk_ruby'
-# require 'chalk_ruby'
-
-require 'date'
-require 'rspec/autorun'
-require 'chalk_ruby/grpc_client'
-require 'chalk_ruby/grpc/auth_interceptor'
-require 'chalk_ruby/error'
-require 'chalk_ruby/protos/chalk/server/v1/auth_pb'
-require 'chalk_ruby/protos/chalk/server/v1/auth_services_pb'
-require 'chalk_ruby/protos/chalk/engine/v1/query_server_services_pb'
-require 'arrow'
-
-
-CLIENT_ID     = 'client-095f628e339a593e12a58559f5f8cd00'
-CLIENT_SECRET = 'secret-55601b885bcc0d558c4abede69480aaac1dba6e1679889fa1d5196ba04f7af89'
-
+require 'rspec'
+require 'chalk_ruby'
 
 RSpec.describe ChalkRuby::GrpcClient do
-  describe '#query' do
+  describe '#query_bulk' do
     let(:client) do
-      ChalkRuby::GrpcClient.new(
-        ChalkRuby::Config.new(
-          query_server: "standard-gke.chalk-develop.gcp.chalk.ai",
-          api_server: "api.staging.chalk.ai:443",
-          client_id: CLIENT_ID,
-          client_secret: CLIENT_SECRET,
-          environment: "tmnmc9beyujew",
-          # api_timeout: 0.6, # seconds
-          # connect_timeout: 0.3, # seconds
-          # query_service_root_ca_path: "/Users/andrew/found_ca.pem" # path to the root ca for chalkai.internal.found.app,
-        )
+      ChalkRuby::GrpcClient.create(
+        ENV.fetch('CHALK_CLIENT_ID'),
+        ENV.fetch('CHALK_CLIENT_SECRET'),
+        ENV.fetch('CHALK_ENVIRONMENT', 'tmnmc9beyujew'),
+        ENV.fetch('CHALK_QUERY_SERVER', 'standard-gke.chalk-develop.gcp.chalk.ai'),
+        ENV.fetch('CHALK_API_SERVER', 'api.staging.chalk.ai:443')
       )
     end
 
-    # it 'can perform queries' do
-    #   response = client.query(
-    #     input: { 'business.id': 1 },
-    #     output: %w(business.id)
-    #   )
-    #
-    #   expect(response).not_to be_nil
-    #
-    #   puts response
-    #   # The response should be a OnlineQueryBulkResponse
-    #   # expect(response).to be_a(Chalk::Common::V1::OnlineQueryBulkResponse)
-    # end
-
     it 'can perform bulk queries' do
       response = client.query_bulk(
         input: { 'user.id': 1 },
-        output: %w(user.id user.socure_score user.full_name)
+        output: %w(user.id user.socure_score),
+        planner_options: {'defer_non_bus_persist_operators': "1"}, # test planner option
+        query_name: "planner_options_test",
+
       )
 
       expect(response).not_to be_nil
-      # The response should be a OnlineQueryBulkResponse
-      # expect(response).to be_a(Chalk::Common::V1::OnlineQueryBulkResponse)
-
-      # puts response.scalars_data
+      # The response should have no errors and user_id of 1
+      expect(response[:errors]).to be_empty
+      expect(response[:data][0]['user.id']).to eq(1)
+    end
+    it 'can perform bulk queries without planner options' do
+      response = client.query_bulk(
+        input: { 'user.id': 1 },
+        output: %w(user.id user.socure_score),
+        query_name: "no_planner_options_test",
+      )
 
-      puts response
+      expect(response).not_to be_nil
+      # The response should have no errors and user_id of 1
+      expect(response[:errors]).to be_empty
+      expect(response[:data][0]['user.id']).to eq(1)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chalk_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Chalk AI, Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
+date: 2025-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -237,6 +237,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- Dockerfile
 - Gemfile
 - LICENSE
 - README.dev.md
@@ -361,7 +362,6 @@ files:
 - sig/chalk_ruby/http/response.rbs
 - sig/chalk_ruby/token.rbs
 - sig/chalk_ruby/versions.rbs
-- test/chalk_ruby/integration/arrow_conversion_test.rb
 - test/chalk_ruby/integration/client_test.rb
 - test/chalk_ruby/integration/grpc_client_test.rb
 - test/chalk_ruby/test_helper.rb
@@ -392,7 +392,6 @@ signing_key:
 specification_version: 4
 summary: A simple Ruby client for Chalk
 test_files:
-- test/chalk_ruby/integration/arrow_conversion_test.rb
 - test/chalk_ruby/integration/client_test.rb
 - test/chalk_ruby/integration/grpc_client_test.rb
 - test/chalk_ruby/test_helper.rb

data/test/chalk_ruby/integration/arrow_conversion_test.rb

@@ -1,286 +0,0 @@
-require 'minitest/autorun'
-require 'chalk_ruby/grpc_client'
-require 'arrow'
-
-class ArrowConversionTest < Minitest::Test
-  def setup
-    @client = create_client
-  end
-
-  def test_arrow_string_conversion
-    assert_type_conversion('test_string', 'string', String)
-  end
-
-  def test_arrow_large_string_conversion
-    test_string = 'test_large_string'
-    # For large string types, we might get a GLib::Bytes object, which can be converted to a string
-    result = assert_type_conversion(test_string, 'large_string', [String, GLib::Bytes])
-    # Check the actual content
-    actual_value = result.is_a?(GLib::Bytes) ? result.to_s : result
-    assert_equal test_string, actual_value
-  end
-
-  def test_arrow_int8_conversion
-    assert_type_conversion(8, 'int8', Integer)
-  end
-
-  def test_arrow_int16_conversion
-    assert_type_conversion(16, 'int16', Integer)
-  end
-
-  def test_arrow_int32_conversion
-    assert_type_conversion(32, 'int32', Integer)
-  end
-
-  def test_arrow_int64_conversion
-    assert_type_conversion(64, 'int64', Integer)
-  end
-
-  def test_arrow_uint8_conversion
-    assert_type_conversion(8, 'uint8', Integer)
-  end
-
-  def test_arrow_uint16_conversion
-    assert_type_conversion(16, 'uint16', Integer)
-  end
-
-  def test_arrow_uint32_conversion
-    assert_type_conversion(32, 'uint32', Integer)
-  end
-
-  def test_arrow_uint64_conversion
-    assert_type_conversion(64, 'uint64', Integer)
-  end
-
-  def test_arrow_float_conversion
-    assert_type_conversion(3.14, 'float', Float)
-  end
-
-  def test_arrow_double_conversion
-    assert_type_conversion(3.14159, 'double', Float)
-  end
-
-  def test_arrow_boolean_conversion
-    assert_type_conversion(true, 'boolean', [TrueClass, FalseClass])
-  end
-
-  def test_arrow_timestamp_conversion
-    # Create timestamp as a Ruby Time object
-    timestamp = Time.now
-    # Pass timestamp seconds since epoch to Arrow
-    arrow_timestamp = timestamp.to_i
-    # Check that it converts back to a Time-like object
-    result = assert_type_conversion(arrow_timestamp, 'timestamp[s]', Time)
-    # Check that the timestamp values are approximately equal
-    assert_in_delta timestamp.to_i, result.to_i, 1
-  end
-
-  def test_arrow_date32_conversion
-    # Date represented as days since epoch
-    today = Date.today
-    days_since_epoch = (today - Date.new(1970, 1, 1)).to_i
-    result = assert_type_conversion(days_since_epoch, 'date32', Date)
-    assert_equal today, result
-  end
-
-  def test_arrow_binary_conversion
-    binary_data = "\x01\x02\x03\x04"
-    # For binary types, we might get a GLib::Bytes object, which can be converted to a string
-    result = assert_type_conversion(binary_data, 'binary', [String, GLib::Bytes])
-    # Check the actual content
-    actual_value = result.is_a?(GLib::Bytes) ? result.to_s : result
-    assert_equal binary_data, actual_value
-  end
-
-  def test_arrow_large_binary_conversion
-    large_binary_data = "\x01\x02\x03\x04" * 10
-    # For binary types, we might get a GLib::Bytes object, which can be converted to a string
-    result = assert_type_conversion(large_binary_data, 'large_binary', [String, GLib::Bytes])
-    # Check the actual content
-    actual_value = result.is_a?(GLib::Bytes) ? result.to_s : result
-    assert_equal large_binary_data, actual_value
-  end
-
-  def test_arrow_list_conversion
-    # Skip this test as it's difficult to create a list array with the current Arrow Ruby API
-    skip "Creating list arrays requires more complex approach with current Arrow Ruby API"
-  end
-
-  def test_arrow_struct_conversion
-    # Skip this test as it's difficult to create a struct array with the current Arrow Ruby API
-    skip "Creating struct arrays requires more complex approach with current Arrow Ruby API"
-  end
-
-  def test_arrow_null_conversion
-    # Test that null values are properly converted to nil
-    schema = Arrow::Schema.new([Arrow::Field.new("test_null", Arrow::Int32DataType.new)])
-    
-    # Create array with a null value
-    builder = Arrow::Int32ArrayBuilder.new
-    builder.append_null
-    array = builder.finish
-    
-    table = Arrow::Table.new(schema, [array])
-    
-    # Serialize to Arrow IPC streaming format
-    buffer = Arrow::ResizableBuffer.new(0)
-    output = Arrow::BufferOutputStream.new(buffer)
-    writer = Arrow::RecordBatchStreamWriter.new(output, table.schema)
-    writer.write_table(table)
-    writer.close
-    output.close
-    arrow_data = buffer.data.to_s
-    
-    result = @client.send(:arrow_table_to_array, arrow_data)
-    
-    assert_instance_of Array, result
-    assert_equal 1, result.length
-    assert_nil result[0]["test_null"]
-  end
-
-  private
-
-  def create_client
-    config = ChalkRuby::Config.new(
-      client_id: 'test',
-      client_secret: 'test',
-      environment: 'test',
-      query_server: 'test'
-    )
-    ChalkRuby::GrpcClient.new(config)
-  end
-
-  def assert_type_conversion(value, arrow_type_name, expected_ruby_type)
-    # Create schema with the specified arrow type
-    data_type = create_arrow_data_type(arrow_type_name)
-    schema = Arrow::Schema.new([Arrow::Field.new("test_field", data_type)])
-    
-    # Create array with the value
-    array = create_arrow_array(data_type, value)
-    
-    # Create table with schema and array
-    table = Arrow::Table.new(schema, [array])
-    
-    # Serialize table to Arrow IPC streaming format
-    buffer = Arrow::ResizableBuffer.new(0)
-    output = Arrow::BufferOutputStream.new(buffer)
-    writer = Arrow::RecordBatchStreamWriter.new(output, table.schema)
-    writer.write_table(table)
-    writer.close
-    output.close
-    arrow_data = buffer.data.to_s
-    
-    # Convert arrow data to array of hashes
-    result = @client.send(:arrow_table_to_array, arrow_data)
-    
-    # Check that the value was properly converted
-    assert_instance_of Array, result
-    assert_equal 1, result.length
-    
-    expected_types = Array(expected_ruby_type)
-    assert expected_types.any? { |type| result[0]["test_field"].is_a?(type) }, 
-           "Expected #{result[0]["test_field"].inspect} to be a #{expected_ruby_type}, but was #{result[0]["test_field"].class}"
-    
-    # Return the converted value for further assertions
-    result[0]["test_field"]
-  end
-
-  def create_arrow_data_type(type_name)
-    case type_name
-    when 'int8' then Arrow::Int8DataType.new
-    when 'int16' then Arrow::Int16DataType.new
-    when 'int32' then Arrow::Int32DataType.new
-    when 'int64' then Arrow::Int64DataType.new
-    when 'uint8' then Arrow::UInt8DataType.new
-    when 'uint16' then Arrow::UInt16DataType.new
-    when 'uint32' then Arrow::UInt32DataType.new
-    when 'uint64' then Arrow::UInt64DataType.new
-    when 'float' then Arrow::FloatDataType.new
-    when 'double' then Arrow::DoubleDataType.new
-    when 'string' then Arrow::StringDataType.new
-    when 'large_string' then Arrow::LargeStringDataType.new
-    when 'binary' then Arrow::BinaryDataType.new
-    when 'large_binary' then Arrow::LargeBinaryDataType.new
-    when 'boolean' then Arrow::BooleanDataType.new
-    when 'timestamp[s]' then Arrow::TimestampDataType.new(:second)
-    when 'date32' then Arrow::Date32DataType.new
-    else
-      raise "Unsupported arrow type: #{type_name}"
-    end
-  end
-
-  def create_arrow_array(data_type, value)
-    case data_type
-    when Arrow::Int8DataType
-      builder = Arrow::Int8ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::Int16DataType
-      builder = Arrow::Int16ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::Int32DataType
-      builder = Arrow::Int32ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::Int64DataType
-      builder = Arrow::Int64ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::UInt8DataType
-      builder = Arrow::UInt8ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::UInt16DataType
-      builder = Arrow::UInt16ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::UInt32DataType
-      builder = Arrow::UInt32ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::UInt64DataType
-      builder = Arrow::UInt64ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::FloatDataType
-      builder = Arrow::FloatArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::DoubleDataType
-      builder = Arrow::DoubleArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::StringDataType
-      builder = Arrow::StringArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::LargeStringDataType
-      builder = Arrow::LargeStringArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::BinaryDataType
-      builder = Arrow::BinaryArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::LargeBinaryDataType
-      builder = Arrow::LargeBinaryArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::BooleanDataType
-      builder = Arrow::BooleanArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    when Arrow::TimestampDataType
-      builder = Arrow::TimestampArrayBuilder.new(data_type)
-      builder.append_value(value)
-      builder.finish
-    when Arrow::Date32DataType
-      builder = Arrow::Date32ArrayBuilder.new
-      builder.append_value(value)
-      builder.finish
-    else
-      raise "Unsupported arrow data type: #{data_type.class}"
-    end
-  end
-end