Automatically reloading model object when fetched via the parent in a CTI relationship

[adam12]

When the model object is queried from the top-level parent in a CTI relationship, the model object isn't complete and is missing attributes from the child's table.

This is usually fine, but one issue I've ran into is that validations fail the first time, but will potentially succeed the second time when you're debugging, depending on what actions you take. This can be incredibly confusing.

ie.

instance = Employee.first # => Executive
instance.save # Fails because parking_space is not present
instance.parking_space # Loads from executive table and is no longer invalid, but it's not clear that is what happened
instance.save # Succeeds but no indication why

This is covered a little bit inside the CTI documentation - you need to call refresh on the instance to fill in the gaps between the parent and child tables. Only downside is you need to remember to do this.

What I'd like to do is eliminate this sharp edge. I tried this naive solution, which works but seems incredibly wasteful:

plugin :after_initialization

def after_initialization
  super

  refresh if id
end

I'm looking for either:

1. Suggestions on improving this naieve implementation.

2. Improvements for the workflow around saving. Is this a bug? Should Sequel backfill before saving? I'm not sure this is even possible but maybe it can be paired with dirty tracking somehow.

[jeremyevans]

The class_table_inheritance plugin skips updates of child tables if there are no columns to save. I assume this is a validation issue and not a saving issue. A before_validation hook to populate missing columns from child tables not originally queried could work (as you mentioned in option 2). A basic approach could be something like:

  missing_columns = columns - @values.keys
  unless missing_columns.empty?
    if row = this.select(*missing_columns).single_record!
      @values = row.merge!(@values)
    end
  end

Performance-wise, such an approach would definitely be preferably to an after_initialization approach.

[adam12]

Thanks for the reply.

The class_table_inheritance plugin skips updates of child tables if there are no columns to save. I assume this is a validation issue and not a saving issue.

You're right.

A before_validation hook to populate missing columns from child tables not originally queried could work

This looks good, and I might end up using it, but after creating a reproduction, I noticed that it's the auto_validations plugin that's causing my issue. WDYT?

DB.create_table(:employees) do
  primary_key :id

  column :name, String, null: false
  column :kind, String, null: false
end

DB.create_table(:executives) do
  foreign_key :id, :employees, primary_key: true

  column :parking_space, String, null: false
end

class Employee < Sequel::Model
  plugin :validation_helpers
  plugin :auto_validations # Without this line, everything works correctly
  plugin :class_table_inheritance, key: :kind,
    model_map: {
      "executive" => :Executive
    }

  def validate
    super

    validates_presence [:name]
  end
end

class Executive < Employee
  def validate
    super

    validates_presence [:parking_space]
  end
end

# Seed database
employee = Executive.create(name: "John User", kind: "executive", parking_space: "1")

# Update first Employee but only change an employee-specific attribute
employee = Employee.first
employee.name = "Joe User"
employee.save_changes

[jeremyevans]

This would happen with any validation operating on the missing columns, it's not specific to auto_validations, though it does affect it.

[adam12]

OK. I might punt on using auto_validations then. Thanks!