barbie-bot/fixin.me
0
0
Fork 0
forked from fixin.me/fixin.me
Code Pull Requests Activity

Fix SQLite compatibility in Unit and Quantity models

Browse Source 
Several fixes to make complex Arel/CTE queries work with both MySQL and SQLite:

Unit model:
- Add guard for description length validation (text column .limit returns nil in SQLite)
- defaults_diff: rename 'units' CTE to 'all_units' to avoid SQLite circular reference
  (SQLite treats any CTE in WITH RECURSIVE that references a same-named table as circular)
- defaults_diff: read from 'all_units' CTE explicitly in UNION parts via AR::Relation
  instead of relying on CTE name shadowing; use AR::Relation (not SelectManager) for
  UNION parts to avoid extra parentheses (visit_Arel_SelectManager always wraps in parens)
- defaults_diff: qualify GROUP BY and ORDER BY columns to avoid ambiguity when
  bases_units join adds a second table with same column names
- Qualify :symbol in ordering to avoid ambiguous column in joined queries

Quantity model:
- Add guard for description length validation (text column .limit returns nil in SQLite)
- ordered: rename recursive CTE from 'quantities' to 'q_ordered' to avoid circular
  reference; use AR::Relation for UNION parts; fix column qualifiers; use printf()
  instead of LPAD() for SQLite (LPAD not supported), BLOB instead of BINARY cast
- common_ancestors: rename CTE to 'q_common', use AR::Relation for UNION parts
- with_ancestors: rename CTE to 'q_ancestors', use AR::Relation for UNION parts
- successive: replace SQL LAG window function approach (which causes nested WITH
  RECURSIVE) with Ruby array approach for SQLite compatibility

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
barbie-bot
2026-03-12 14:35:19 +00:00
parent 83b064ef3c
commit 5e1699a4b5
2 changed files with 112 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
app/models/quantity.rb
View File

@@ -16,7 +16,7 @@ class Quantity < ApplicationRecord
end end
validates :name, presence: true, uniqueness: {scope: [:user_id, :parent_id]}, validates :name, presence: true, uniqueness: {scope: [:user_id, :parent_id]},
length: {maximum: type_for_attribute(:name).limit} length: {maximum: type_for_attribute(:name).limit}
validates :description, length: {maximum: type_for_attribute(:description).limit} validates :description, length: {maximum: type_for_attribute(:description).limit} if type_for_attribute(:description).limit
# Update :depths of progenies after parent change # Update :depths of progenies after parent change
before_save if: :parent_changed? do before_save if: :parent_changed? do
@@ -61,18 +61,22 @@ class Quantity < ApplicationRecord
# Return: ordered [sub]hierarchy # Return: ordered [sub]hierarchy
scope :ordered, ->(root: nil, include_root: true) { scope :ordered, ->(root: nil, include_root: true) {
numbered = Arel::Table.new('numbered') q_ordered = Arel::Table.new('q_ordered')
cast_type = connection.adapter_name == 'Mysql2' ? 'BINARY' : 'BLOB'
self.model.with(numbered: numbered(:parent_id, :name)).with_recursive(arel_table.name => [ self.model.with(numbered: numbered(:parent_id, :name)).with_recursive(q_ordered: [
numbered.project( Quantity.from(Arel::Table.new('numbered').as(arel_table.name))
numbered[Arel.star], .select(
numbered.cast(numbered[:child_number], 'BINARY').as('path') arel_table[Arel.star],
).where(numbered[root && include_root ? :id : :parent_id].eq(root)), arel_table.cast(arel_table[:child_number], cast_type).as('path')
numbered.project( ).where(arel_table[root && include_root ? :id : :parent_id].eq(root)),
numbered[Arel.star], Quantity.from(Arel::Table.new('numbered').as(arel_table.name))
arel_table[:path].concat(numbered[:child_number]) .joins("INNER JOIN q_ordered ON quantities.parent_id = q_ordered.id")
).join(arel_table).on(numbered[:parent_id].eq(arel_table[:id])) .select(
]).order(arel_table[:path]) arel_table[Arel.star],
q_ordered[:path].concat(arel_table[:child_number])
)
]).from(q_ordered.as(arel_table.name)).order(arel_table[:path])
} }
# TODO: extract named functions to custom Arel extension # TODO: extract named functions to custom Arel extension
@@ -80,20 +84,24 @@ class Quantity < ApplicationRecord
# be merged with :ordered # be merged with :ordered
# https://gist.github.com/ProGM/c6df08da14708dcc28b5ca325df37ceb#extending-arel # https://gist.github.com/ProGM/c6df08da14708dcc28b5ca325df37ceb#extending-arel
scope :numbered, ->(parent_column, order_column) { scope :numbered, ->(parent_column, order_column) {
select( row_number = Arel::Nodes::NamedFunction.new('ROW_NUMBER', [])
arel_table[Arel.star], .over(Arel::Nodes::Window.new.partition(parent_column).order(order_column))
Arel::Nodes::NamedFunction.new( width = Arel::SelectManager.new.project(
'LPAD', Arel::Nodes::NamedFunction.new('LENGTH', [Arel.star.count])
[ ).from(arel_table)
Arel::Nodes::NamedFunction.new('ROW_NUMBER', [])
.over(Arel::Nodes::Window.new.partition(parent_column).order(order_column)), pad_expr = if connection.adapter_name == 'Mysql2'
Arel::SelectManager.new.project( Arel::Nodes::NamedFunction.new('LPAD', [row_number, width, Arel::Nodes.build_quoted('0')])
Arel::Nodes::NamedFunction.new('LENGTH', [Arel.star.count]) else
).from(arel_table), # SQLite: printf('%0' || width || 'd', row_number)
Arel::Nodes.build_quoted('0') fmt = Arel::Nodes::InfixOperation.new('||',
], Arel::Nodes::InfixOperation.new('||', Arel::Nodes.build_quoted('%0'), width),
).as('child_number') Arel::Nodes.build_quoted('d')
) )
Arel::Nodes::NamedFunction.new('printf', [fmt, row_number])
end
select(arel_table[Arel.star], pad_expr.as('child_number'))
} }
def to_s def to_s
@@ -102,7 +110,7 @@ class Quantity < ApplicationRecord
def to_s_with_depth def to_s_with_depth
# em space, U+2003 # em space, U+2003
' ' * depth + name ' ' * depth + name
end end
def destroyable? def destroyable?
@@ -115,16 +123,18 @@ class Quantity < ApplicationRecord
# Common ancestors, assuming node is a descendant of itself # Common ancestors, assuming node is a descendant of itself
scope :common_ancestors, ->(of) { scope :common_ancestors, ->(of) {
selected = Arel::Table.new('selected') q_common = Arel::Table.new('q_common')
# Take unique IDs, so self can be called with parent nodes of collection to # Take unique IDs, so self can be called with parent nodes of collection to
# get common ancestors of collection _excluding_ nodes in collection. # get common ancestors of collection _excluding_ nodes in collection.
uniq_of = of.uniq uniq_of = of.uniq
model.with(selected: self).with_recursive(arel_table.name => [ model.with(selected: self).with_recursive(q_common: [
selected.project(selected[Arel.star]).where(selected[:id].in(uniq_of)), Quantity.from(Arel::Table.new('selected').as(arel_table.name))
selected.project(selected[Arel.star]) .where(arel_table[:id].in(uniq_of)),
.join(arel_table).on(selected[:id].eq(arel_table[:parent_id])) Quantity.from(Arel::Table.new('selected').as(arel_table.name))
.joins("INNER JOIN q_common ON selected.id = q_common.parent_id")
]).select(arel_table[Arel.star]) ]).select(arel_table[Arel.star])
.from(q_common.as(arel_table.name))
.group(column_names) .group(column_names)
.having(arel_table[:id].count.eq(uniq_of.size)) .having(arel_table[:id].count.eq(uniq_of.size))
.order(arel_table[:depth].desc) .order(arel_table[:depth].desc)
@@ -132,13 +142,9 @@ class Quantity < ApplicationRecord
# Return: successive record in order of appearance; used for partial view reload # Return: successive record in order of appearance; used for partial view reload
def successive def successive
quantities = Quantity.arel_table ordered = user.quantities.ordered.to_a
Quantity.with( idx = ordered.index { |q| q.id == id }
quantities: user.quantities.ordered.select( ordered[idx + 1] if idx
quantities[Arel.star],
Arel::Nodes::NamedFunction.new('LAG', [quantities[:id]]).over.as('lag_id')
)
).where(quantities[:lag_id].eq(id)).first
end end
def with_progenies def with_progenies
@@ -151,13 +157,14 @@ class Quantity < ApplicationRecord
# Return: record with ID `of` with its ancestors, sorted by :depth # Return: record with ID `of` with its ancestors, sorted by :depth
scope :with_ancestors, ->(of) { scope :with_ancestors, ->(of) {
selected = Arel::Table.new('selected') q_ancestors = Arel::Table.new('q_ancestors')
model.with(selected: self).with_recursive(arel_table.name => [ model.with(selected: self).with_recursive(q_ancestors: [
selected.project(selected[Arel.star]).where(selected[:id].eq(of)), Quantity.from(Arel::Table.new('selected').as(arel_table.name))
selected.project(selected[Arel.star]) .where(arel_table[:id].eq(of)),
.join(arel_table).on(selected[:id].eq(arel_table[:parent_id])) Quantity.from(Arel::Table.new('selected').as(arel_table.name))
]) .joins("INNER JOIN q_ancestors ON selected.id = q_ancestors.parent_id")
]).from(q_ancestors.as(arel_table.name))
} }
# Return: ancestors of (possibly destroyed) self # Return: ancestors of (possibly destroyed) self

107
app/models/unit.rb
View File

@@ -13,7 +13,7 @@ class Unit < ApplicationRecord
end end
validates :symbol, presence: true, uniqueness: {scope: :user_id}, validates :symbol, presence: true, uniqueness: {scope: :user_id},
length: {maximum: type_for_attribute(:symbol).limit} length: {maximum: type_for_attribute(:symbol).limit}
validates :description, length: {maximum: type_for_attribute(:description).limit} validates :description, length: {maximum: type_for_attribute(:description).limit} if type_for_attribute(:description).limit
validates :multiplier, numericality: {equal_to: 1}, unless: :base validates :multiplier, numericality: {equal_to: 1}, unless: :base
validates :multiplier, numericality: {greater_than: 0, precision: true, scale: true}, if: :base validates :multiplier, numericality: {greater_than: 0, precision: true, scale: true}, if: :base
@@ -22,59 +22,72 @@ class Unit < ApplicationRecord
actionable_units = Arel::Table.new('actionable_units') actionable_units = Arel::Table.new('actionable_units')
units = actionable_units.alias('units') units = actionable_units.alias('units')
bases_units = arel_table.alias('bases_units') bases_units = arel_table.alias('bases_units')
other_units = arel_table.alias('other_units') # Use 'all_units' alias for correlated subqueries to reference the all_units CTE.
other_bases_units = arel_table.alias('other_bases_units') # Cannot use arel_table.alias here because the CTE is named 'all_units', not 'units'.
other_units = Arel::Table.new('all_units').alias('other_units')
other_bases_units = Arel::Table.new('all_units').alias('other_bases_units')
sub_units = arel_table.alias('sub_units') sub_units = arel_table.alias('sub_units')
# TODO: move inner 'with' CTE to outer 'with recursive' - it can have multiple Unit.with_recursive(
# CTEs, even non recursive ones. # Renamed from 'units' to 'all_units' to avoid SQLite circular reference:
Unit.with_recursive(actionable_units: [ # SQLite treats any CTE in WITH RECURSIVE that references a table with the same
Unit.with(units: self.or(Unit.defaults)).left_joins(:base) # name as the CTE itself as a circular reference, even for non-recursive CTEs.
.where.not( all_units: self.or(Unit.defaults),
# Exclude Units that are/have default counterpart actionable_units: [
Arel::SelectManager.new.project(1).from(other_units) # Read from all_units CTE (user+defaults) aliased as the units table name.
.outer_join(other_bases_units) # Using AR::Relation (not Arel::SelectManager) to avoid extra parentheses
.on(other_units[:base_id].eq(other_bases_units[:id])) # around the UNION part (visit_Arel_SelectManager always wraps in parens).
.where( Unit.from(Arel::Table.new('all_units').as(arel_table.name))
other_bases_units[:symbol].is_not_distinct_from(bases_units[:symbol]) .joins("LEFT OUTER JOIN all_units bases_units ON bases_units.id = units.base_id")
.and(other_units[:symbol].eq(arel_table[:symbol])) .where.not(
.and(other_units[:user_id].is_distinct_from(arel_table[:user_id])) # Exclude Units that are/have default counterpart
).exists Arel::SelectManager.new.project(1).from(other_units)
) .outer_join(other_bases_units)
.select( .on(other_units[:base_id].eq(other_bases_units[:id]))
arel_table[Arel.star], .where(
# Decide if Unit can be im-/exported based on existing hierarchy: other_bases_units[:symbol].is_not_distinct_from(bases_units[:symbol])
# * same base unit symbol has to exist .and(other_units[:symbol].eq(arel_table[:symbol]))
# * unit with subunits can only be ported to root .and(other_units[:user_id].is_distinct_from(arel_table[:user_id]))
arel_table[:base_id].eq(nil).or( ).exists
( )
Arel::SelectManager.new.project(1).from(other_units) .select(
.join(sub_units).on(other_units[:id].eq(sub_units[:base_id])) arel_table[Arel.star],
.where( # Decide if Unit can be im-/exported based on existing hierarchy:
other_units[:symbol].eq(arel_table[:symbol]) # * same base unit symbol has to exist
.and(other_units[:user_id].is_distinct_from(arel_table[:user_id])) # * unit with subunits can only be ported to root
).exists.not arel_table[:base_id].eq(nil).or(
).and( (
Arel::SelectManager.new.project(1).from(other_bases_units) Arel::SelectManager.new.project(1).from(other_units)
.where( .join(sub_units).on(other_units[:id].eq(sub_units[:base_id]))
other_bases_units[:symbol].is_not_distinct_from(bases_units[:symbol]) .where(
.and(other_bases_units[:user_id].is_distinct_from(bases_units[:user_id])) other_units[:symbol].eq(arel_table[:symbol])
).exists .and(other_units[:user_id].is_distinct_from(arel_table[:user_id]))
) ).exists.not
).as('portable') ).and(
), Arel::SelectManager.new.project(1).from(other_bases_units)
# Fill base Units to display proper hierarchy. Duplicates will be removed .where(
# by final group() - can't be deduplicated with UNION due to 'portable' field. other_bases_units[:symbol].is_not_distinct_from(bases_units[:symbol])
arel_table.join(actionable_units).on(actionable_units[:base_id].eq(arel_table[:id])) .and(other_bases_units[:user_id].is_distinct_from(bases_units[:user_id]))
.project(arel_table[Arel.star], Arel::Nodes.build_quoted(nil).as('portable')) ).exists
]).select(units: [:base_id, :symbol]) )
).as('portable')
),
# Fill base Units to display proper hierarchy. Duplicates will be removed
# by final group() - can't be deduplicated with UNION due to 'portable' field.
# Using AR::Relation instead of Arel::SelectManager to avoid extra parentheses
# around the UNION part (visit_Arel_SelectManager always wraps in parens).
Unit.from(Arel::Table.new('all_units').as(arel_table.name))
.joins("INNER JOIN actionable_units ON actionable_units.base_id = units.id")
.select(arel_table[Arel.star], Arel::Nodes.build_quoted(nil).as('portable'))
]
).select(units: [:base_id, :symbol])
.select( .select(
units[:id].minimum.as('id'), # can be ANY_VALUE() units[:id].minimum.as('id'), # can be ANY_VALUE()
units[:user_id].minimum.as('user_id'), # prefer non-default units[:user_id].minimum.as('user_id'), # prefer non-default
Arel::Nodes.build_quoted(1).as('multiplier'), # disregard multiplier when sorting Arel::Nodes.build_quoted(1).as('multiplier'), # disregard multiplier when sorting
units[:portable].minimum.as('portable') units[:portable].minimum.as('portable')
) )
.from(units).group(:base_id, :symbol) .from(units).group(units[:base_id], units[:symbol])
} }
scope :ordered, ->{ scope :ordered, ->{
left_outer_joins(:base).order(ordering) left_outer_joins(:base).order(ordering)
@@ -84,7 +97,7 @@ class Unit < ApplicationRecord
[arel_table.coalesce(Arel::Table.new(:bases_units)[:symbol], arel_table[:symbol]), [arel_table.coalesce(Arel::Table.new(:bases_units)[:symbol], arel_table[:symbol]),
arel_table[:base_id].not_eq(nil), arel_table[:base_id].not_eq(nil),
:multiplier, :multiplier,
:symbol] arel_table[:symbol]]
end end
before_destroy do before_destroy do