Equivalent of Active Record's enum feature

[janko]

I recently found out that in rodauth-rails, I can use the ActiveRecord::Enum feature to create names for the integer status values.

class Account < ActiveRecord::Base
  enum :status, unverified: 1, verified: 2, closed: 3
end

Account.unverified #=> []
Account.verified #=> [#<Account...>]
Account.first.closed? #=> false

rodauth-rails doesn't yet have support for Sequel models (generators + associations), but since I plan to add it eventually, I was wondering whether Sequel had an equivalent plugin (and if not, whether there is interest in having it).

[jeremyevans]

Sequel doesn't currently have an built-in equivalent. If you want to use enums, I recommend doing so at the database level, which Sequel supports on PostgreSQL using the pg_enum extension. There are external Sequel plugins that implement similar functionality, such as https://github.com/planas/sequel_enum. That said, I'm not opposed to shipping such a plugin with Sequel, so please submit a pull request for that if you are interested.

[janko]

Thanks, I'll keep that in mind when I'm adding Sequel model integration to rodauth-rails, and probably send in a pull request your way 🙂

[jeremyevans]

Can you let me know what you think is important in terms of features? Looking at ActiveRecord::Enum documentation, I think it makes sense to implement:

• enum_value! for setting enum value
• enum_value? for checking enum value
• column for converting persisted value to enum value
• column= for converting from enum value to persisted value
• dataset methods for records matching or not matching enum value (by default)
• :prefix and :suffix options

Do we want to convert enum values to strings (and handle enum values passed as strings)? I don't particularly like that idea, but maybe it works better when exposing things to user input.

Do we want to support a class level accessor that returns the mapping of enum keys to values? My thought is that it isn't needed in most cases, and if you do need it, you can create a constant for it:

class Foo
  BARS = {:good=>1, :bad=>2}.freeze
  enum :bar, BARS
end

However, maybe there is a need to offer the reflection method. If we decide to do that, what name should we give the method? I don't like the ActiveRecord approach of pluralizing the column name.

Some things ActiveRecord::Enum does don't make sense in Sequel:

• Use of enum values in dataset methods. Sequel generally does not do this. I'm fairly sure in this case it would change the behavior of existing code.
• Setting of default values. Probably best to use defaults_setter plugin if you want that.
• Use of arrays as enum values. Hashes are better to avoid ambiguity and problems with values being removed.

I gave a shot at a simple implementation, please let me know what you think:

# frozen-string-literal: true

module Sequel
  module Plugins
    # The enum plugin 
    #
    # Usage:
    #
    #   # Make all model subclasses handle enums
    #   Sequel::Model.plugin :enum
    #
    #   # Make the Album class handle enums
    #   Album.plugin :enum
    module Enum
      module ClassMethods
        # 
        def enum(column, values, opts=OPTS)
          raise Sequel::Error, "enum values must be provided as a hash with symbol keys" unless values.is_a?(Hash) && values.all?{|k,| k.is_a?(Symbol)}

          if prefix = opts[:prefix]
            prefix = column if prefix == true
            prefix = "#{prefix}_"
          end

          if suffix = opts[:suffix]
            suffix = column if suffix == true
            suffix = "_#{suffix}"
          end
          
          values = Hash[values].freeze
          inverted = values.invert.freeze

          values.each do |key, value|
            define_method(:"#{prefix}#{key}#{suffix}!") do
              self[column] = value
              nil
            end

            define_method(:"#{prefix}#{key}#{suffix}?") do
              self[column] == value
            end

            define_method(column) do
              v = super()
              inverted.fetch(v, v)
            end

            define_method(:"#{column}=") do |v|
              super(values.fetch(v, v))
            end

            unless opts[:dataset_methods] == false
              dataset_module do
                cond = Sequel[column=>value]
                where :"#{prefix}#{key}#{suffix}", cond
                where :"#{prefix}not_#{key}#{suffix}", ~cond
              end
            end
          end
        end
      end
    end
  end
end

I'd like for the enum plugin to ship in the release next week.

[janko]

Thank you for working on this! ❤️. Yes, this is what I consider to be the core of the feature, I wasn't even aware of the other features you mentioned 🙂

The only thing I noticed in your implementation is that the column getters and setters should probably be defined outside of the loop, as they don't seem to be dependent on values. But in terms of interface and behaviour, everything looks good to me 👍🏻

Do we want to convert enum values to strings (and handle enum values passed as strings)? I don't particularly like that idea, but maybe it works better when exposing things to user input.

Personally, I don't see myself needing this, as I cannot really imagine use cases where I would want to use it with user input. I like that symbols communicate that these values are not actually stored in the database.

Do we want to support a class level accessor that returns the mapping of enum keys to values? My thought is that it isn't needed in most cases, and if you do need it, you can create a constant for it

Yeah, that rationale also makes sense to me 👍🏻

[janko]

Some things ActiveRecord::Enum does don't make sense in Sequel

Yeah, I found Active Record a bit too magical in terms of how deeply the enum is implemented. I guess the goal was to hide the fact that the values are backed by integers as much as possible, but I don't think it's useful for Sequel. And yeah, I like the explicitness of hashes more.

[jeremyevans]

OK, this support has been committed: 473a222

Please give it a shot and let me know if you think we should any changes before next week's release.

[janko]

I played a bit with the new enum plugin, and everything looks good to me 👍🏻 One thing that was important to me was that I'm alerted if I made a typo when setting the enum value, e.g:

Account.create(email: "user@example.com", status: :unverfied) # typo

While I don't get an explicit error telling me that the value isn't in the declared in the enum, I do get the undefined column error, which I think is good enough. I suppose it wouldn't make sense to disallow assigning symbols that aren't enum values, because in theory those could be intentional column name identifiers.

[jeremyevans]

I made a deliberate choice to allow non-enum values to pass through in the accessor, instead of raising. This way the code still works if you provide a non-enum value (like the actual column value), or if the column has a value that isn't in the enum values provided.

I think the auto_validations plugin would catch the typo before the database query is sent, since a symbol shouldn't be an allowed type (symbols represent SQL expressions/identifiers, not values). I haven't checked that, though.

We could definitely add more features in the future, such as a strict mode for either the setter or getter. As long as it doesn't break backwards compatibility with the current version by default.