Add standard Ruby collection methods to Result and Row

- Add Result#empty? for checking empty result sets
- Add Row#dig for safe nested value access (useful for VARIANT/JSON columns)
- Add Row#to_h for explicit hash conversion
- Add Row#key?/has_key? for column existence checks
- Add Row#fetch for access with default values or error handling
- Add unit tests (28 test cases, no Snowflake required)

Addresses missing methods discovered during BigQuery to Snowflake migration.

Author: wpfleger96

CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
+### Added
+- `Result#empty?` - Check if result set has no rows
+- `Row#dig` - Safe nested value access for VARIANT/JSON columns
+- `Row#to_h` - Explicit hash conversion (was implicit via Enumerable)
+- `Row#key?` / `Row#has_key?` - Check if column exists
+- `Row#fetch` - Access column with default value or error handling
 
 ## [1.5.0] - 2025-10-14
 ### Added

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rb_snowflake_client (1.4.0)
+    rb_snowflake_client (1.5.0)
       bigdecimal (>= 3.0)
       concurrent-ruby (>= 1.2)
       connection_pool (>= 2.4)

lib/ruby_snowflake/result.rb

@@ -39,6 +39,10 @@ def size
 
     alias length size
 
+    def empty?
+      size.zero?
+    end
+
     def first
       wrap_row(data.first.first)
     end

lib/ruby_snowflake/row.rb

@@ -77,6 +77,30 @@ def values
       map { |_, v| v }
     end
 
+    def to_h
+      @column_to_index.each_with_object({}) { |(name, _), hash| hash[name] = self[name] }
+    end
+
+    def dig(key, *rest)
+      value = self[key]
+      return value if rest.empty? || value.nil?
+      return nil unless value.respond_to?(:dig)
+      value.dig(*rest)
+    end
+
+    def key?(key)
+      @column_to_index.key?(key.to_s.downcase)
+    end
+    alias has_key? key?
+
+    def fetch(key, *args, &block)
+      raise ArgumentError, "wrong number of arguments (given #{args.size + 1}, expected 1..2)" if args.size > 1
+      return self[key] if key?(key)
+      return args.first if args.any?
+      return yield(key) if block
+      raise KeyError, "key not found: #{key.inspect}"
+    end
+
     def to_s
       to_h.to_s
     end

spec/ruby_snowflake/result_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+RSpec.describe RubySnowflake::Result do
+  describe "#empty?" do
+    context "when result has no rows" do
+      it "returns true" do
+        row_types = [{"name" => "id", "type" => "fixed", "scale" => 0, "precision" => 0}]
+        result = RubySnowflake::Result.new(1, row_types)
+        result[0] = []
+
+        expect(result.empty?).to be true
+      end
+    end
+
+    context "when result has rows" do
+      it "returns false" do
+        row_types = [{"name" => "id", "type" => "fixed", "scale" => 0, "precision" => 0}]
+        result = RubySnowflake::Result.new(1, row_types)
+        result[0] = [["1"]]
+
+        expect(result.empty?).to be false
+      end
+    end
+
+    context "when result has multiple partitions but all empty" do
+      it "returns true" do
+        row_types = [{"name" => "id", "type" => "fixed", "scale" => 0, "precision" => 0}]
+        result = RubySnowflake::Result.new(2, row_types)
+        result[0] = []
+        result[1] = []
+
+        expect(result.empty?).to be true
+      end
+    end
+  end
+end

spec/ruby_snowflake/row_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+RSpec.describe RubySnowflake::Row do
+  let(:row_types) do
+    [
+      {type: :text, scale: 0, precision: 0, name: :name},
+      {type: :fixed, scale: 0, precision: 0, name: :age}
+    ]
+  end
+  let(:column_to_index) { {"name" => 0, "age" => 1} }
+  let(:data) { ["Alice", "30"] }
+  let(:row) { described_class.new(row_types, column_to_index, data) }
+
+  describe "#to_h" do
+    it "converts row to hash with string keys and type conversion" do
+      result = row.to_h
+      expect(result).to eq({"name" => "Alice", "age" => 30})
+      expect(result["age"]).to be_a(Integer)
+    end
+  end
+
+  describe "#dig" do
+    it "accesses values case-insensitively for strings and symbols" do
+      expect(row.dig("name")).to eq("Alice")
+      expect(row.dig(:name)).to eq("Alice")
+      expect(row.dig("NAME")).to eq("Alice")
+    end
+
+    it "returns nil for missing key" do
+      expect(row.dig("missing")).to be_nil
+    end
+
+    it "digs into nested hashes" do
+      nested_row_types = [{type: :text, scale: 0, precision: 0, name: :data}]
+      nested_column_to_index = {"data" => 0}
+      nested_data = [{"user" => {"name" => "Bob", "age" => 25}}]
+      nested_row = described_class.new(nested_row_types, nested_column_to_index, nested_data)
+
+      expect(nested_row.dig("data", "user", "name")).to eq("Bob")
+      expect(nested_row.dig("data", "user", "age")).to eq(25)
+      expect(nested_row.dig("data", "missing", "key")).to be_nil
+    end
+
+    it "digs into nested arrays" do
+      array_row_types = [{type: :text, scale: 0, precision: 0, name: :items}]
+      array_column_to_index = {"items" => 0}
+      array_data = [[{"id" => 1}, {"id" => 2}]]
+      array_row = described_class.new(array_row_types, array_column_to_index, array_data)
+
+      expect(array_row.dig("items", 0, "id")).to eq(1)
+      expect(array_row.dig("items", 1, "id")).to eq(2)
+    end
+  end
+
+  describe "#key?" do
+    it "checks column existence case-insensitively" do
+      expect(row.key?("name")).to be true
+      expect(row.key?(:NAME)).to be true
+      expect(row.key?("missing")).to be false
+    end
+  end
+
+  describe "#fetch" do
+    it "returns value for existing key" do
+      expect(row.fetch("name")).to eq("Alice")
+      expect(row.fetch(:AGE)).to eq(30)
+    end
+
+    it "returns default value for missing key" do
+      expect(row.fetch("missing", "default")).to eq("default")
+      expect(row.fetch(:nonexistent, 0)).to eq(0)
+    end
+
+    it "yields to block for missing key" do
+      expect(row.fetch("missing") { |k| "no #{k}" }).to eq("no missing")
+      expect(row.fetch(:missing) { |k| "key: #{k}" }).to eq("key: missing")
+    end
+
+    it "raises KeyError for missing key without default or block" do
+      expect { row.fetch("missing") }.to raise_error(KeyError, /key not found/)
+      expect { row.fetch(:nonexistent) }.to raise_error(KeyError, /key not found/)
+    end
+
+    it "raises ArgumentError for too many arguments" do
+      expect { row.fetch("name", "default1", "default2") }.to raise_error(ArgumentError, /wrong number of arguments/)
+    end
+  end
+end