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