Added support for binary vectors

README.md

@@ -332,6 +332,22 @@ class Item < ApplicationRecord
 end
 ```
 
+### Binary Vectors
+
+Use the `type` option for binary vectors
+
+```ruby
+class Item < ApplicationRecord
+  has_neighbors :embedding, type: :bit
+end
+```
+
+Get the nearest neighbors by Hamming distance
+
+```ruby
+Item.nearest_neighbors(:embedding, "\x05", distance: "hamming").first(5)
+```
+
 ## MariaDB
 
 ### Distance

lib/neighbor/attribute.rb

@@ -19,10 +19,12 @@ def new_cast_type
         if @cast_type.is_a?(ActiveModel::Type::Value)
           case Utils.adapter(@model)
           when :sqlite
-            case @type.to_s
-            when "int8"
+            case @type
+            when :int8
               Type::SqliteInt8Vector.new
-            when "float32", ""
+            when :bit
+              @cast_type
+            when :float32, nil
               Type::SqliteFloat32Vector.new
             else
               raise ArgumentError, "Unsupported type"

lib/neighbor/model.rb

@@ -24,7 +24,7 @@ def self.neighbor_attributes
 
         attribute_names.each do |attribute_name|
           raise Error, "has_neighbors already called for #{attribute_name.inspect}" if neighbor_attributes[attribute_name]
-          @neighbor_attributes[attribute_name] = {dimensions: dimensions, normalize: normalize, type: type}
+          @neighbor_attributes[attribute_name] = {dimensions: dimensions, normalize: normalize, type: type&.to_sym}
         end
 
         if ActiveRecord::VERSION::STRING.to_f >= 7.2
@@ -63,11 +63,12 @@ def self.neighbor_attributes
             column_info = self.class.columns_hash[k.to_s]
             dimensions = v[:dimensions]
             dimensions ||= column_info&.limit unless column_info&.type == :binary
+            type = v[:type] || column_info&.type
 
-            if !Neighbor::Utils.validate_dimensions(value, column_info&.type, dimensions).nil?
+            if !Neighbor::Utils.validate_dimensions(value, type, dimensions).nil?
               errors.add(k, "must have #{dimensions} dimensions")
             end
-            if !Neighbor::Utils.validate_finite(value, column_info&.type)
+            if !Neighbor::Utils.validate_finite(value, type)
               errors.add(k, "must have finite values")
             end
           end
@@ -106,7 +107,8 @@ def self.neighbor_attributes
 
           column_attribute = klass.type_for_attribute(attribute_name)
           vector = column_attribute.cast(vector)
-          Neighbor::Utils.validate(vector, dimensions: dimensions, column_info: column_info)
+          dimensions ||= column_info&.limit unless column_info&.type == :binary
+          Neighbor::Utils.validate(vector, dimensions: dimensions, type: type || column_info&.type)
           vector = Neighbor::Utils.normalize(vector, column_info: column_info) if normalize
 
           query = connection.quote(column_attribute.serialize(vector))
@@ -129,8 +131,11 @@ def self.neighbor_attributes
           order =
             case adapter
             when :sqlite
-              if type.to_s == "int8"
+              case type
+              when :int8
                 "#{operator}(vec_int8(#{quoted_attribute}), vec_int8(#{query}))"
+              when :bit
+                "#{operator}(vec_bit(#{quoted_attribute}), vec_bit(#{query}))"
               else
                 "#{operator}(#{quoted_attribute}, #{query})"
               end

lib/neighbor/utils.rb

@@ -18,13 +18,12 @@ def self.validate_finite(value, type)
       end
     end
 
-    def self.validate(value, dimensions:, column_info:)
-      dimensions ||= column_info&.limit unless column_info&.type == :binary
-      if (message = validate_dimensions(value, column_info&.type, dimensions))
+    def self.validate(value, dimensions:, type:)
+      if (message = validate_dimensions(value, type, dimensions))
         raise Error, message
       end
 
-      if !validate_finite(value, column_info&.type)
+      if !validate_finite(value, type)
         raise Error, "Values must be finite"
       end
     end
@@ -65,6 +64,8 @@ def self.operator(adapter, column_type, distance)
           "vec_distance_cosine"
         when "taxicab"
           "vec_distance_L1"
+        when "hamming"
+          "vec_distance_hamming"
         end
       when :mariadb
         case column_type

test/sqlite_bit_test.rb

@@ -0,0 +1,28 @@
+require_relative "test_helper"
+require_relative "support/sqlite"
+
+class SqliteBitTest < Minitest::Test
+  def setup
+    SqliteItem.delete_all
+  end
+
+  def test_hamming
+    create_bit_items
+    result = SqliteItem.find(1).nearest_neighbors(:binary_embedding, distance: "hamming").first(3)
+    assert_equal [2, 3], result.map(&:id)
+    assert_elements_in_delta [2, 3], result.map(&:neighbor_distance)
+  end
+
+  def test_hamming_scope
+    create_bit_items
+    result = SqliteItem.nearest_neighbors(:binary_embedding, "\x05", distance: "hamming").first(5)
+    assert_equal [2, 3, 1], result.map(&:id)
+    assert_elements_in_delta [0, 1, 2], result.map(&:neighbor_distance)
+  end
+
+  def create_bit_items
+    SqliteItem.create!(id: 1, binary_embedding: "\x00")
+    SqliteItem.create!(id: 2, binary_embedding: "\x05")
+    SqliteItem.create!(id: 3, binary_embedding: "\x07")
+  end
+end

test/support/sqlite.rb

@@ -10,6 +10,7 @@ class SqliteRecord < ActiveRecord::Base
   create_table :items, force: true do |t|
     t.binary :embedding
     t.binary :int8_embedding
+    t.binary :binary_embedding
   end
 
   if ActiveRecord::VERSION::MAJOR >= 8
@@ -44,6 +45,7 @@ class SqliteRecord < ActiveRecord::Base
 class SqliteItem < SqliteRecord
   has_neighbors :embedding, dimensions: 3
   has_neighbors :int8_embedding, dimensions: 3, type: :int8
+  has_neighbors :binary_embedding, type: :bit
   self.table_name = "items"
 end