ActiveRecord Custom Types

In developing bracket-lab, I needed a 1-indexed bit field of 63 bits, stored as an unsigned 63-bit value in an int64 column. ActiveRecord’s custom types made this clean.

A 1-indexed bit field means the 64th bit is significant but not as a two’s complement sign bit. Languages like Rust have nice unsigned integer types, but that’s not an option here. The data itself fits in u63 (positive i64) space, so my solution is to right-shift before storing to the DB and left-shift when reading.

First, define the type at app/types. This folder is not auto-generated with rails new but is autoloaded at boot.

app/types/shifted_bitwise_type.rbruby

class ShiftedBitwiseType < ActiveRecord::Type::BigInteger
  MAX_INT64 = 0x7FFFFFFFFFFFFFFF

  # DB → Ruby (reading)
  def deserialize(value)
    return 0 if value.nil?
    Integer(value) << 1
  end

  # Ruby → DB (writing + WHERE clauses)
  def serialize(value)
    return nil if value.nil?
    (Integer(value) >> 1) & MAX_INT64
  end

  # User input → Ruby (attribute assignment)
  def cast(value)
    return 0 if value.nil?
    Integer(value)
  end
end

View on GitHub

Add an initializer to register the type with ActiveRecord.

config/initializers/types.rbruby

Rails.application.config.to_prepare do
  ActiveRecord::Type.register(:shifted_bitwise, ShiftedBitwiseType)
end

View on GitHub

Then, declare the type on any model attribute that uses it. For example, Tournament has :game_decisions and :game_mask that are both stored as int64.

db/schema.rbruby

  create_table "tournaments", force: :cascade do |t|
    # ...
    t.bigint "game_decisions", default: 0, null: false
    t.bigint "game_mask", default: 0, null: false
    # ...
  end

View on GitHub

app/models/tournament.rbruby

class Tournament < ApplicationRecord
  attribute :game_decisions, :shifted_bitwise
  attribute :game_mask, :shifted_bitwise
  # ...
end

View on GitHub

Now everything just works. The code uses the attributes as 1-indexed bit fields and AR takes care of casting and serialization. This works for all ActiveRecord operations like find_or_create_by.

Note: if you need the raw DB value, you can access it with read_attribute_before_type_cast, which is useful when you need bitwise logic executed in the DB engine.

app/models/outcome_ranking.rbruby

def prune(tournament = nil)
  tournament ||= Tournament.field_64

  # Read raw DB values (right-shifted) bypassing the type cast bitshift
  tournament_mask = tournament.read_attribute_before_type_cast(:game_mask)
  tournament_decisions = tournament.read_attribute_before_type_cast(:game_decisions)

  OutcomeRanking.where(
    "game_decisions & :mask != :decisions & :mask",
    mask: tournament_mask, decisions: tournament_decisions
  ).delete_all
end

View on GitHub