activerecord-refined 0.8.0 → 0.9.0

data/examples/windows.rb

@@ -1,14 +1,16 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# frozen_string_literal: true
 
-require 'active_record'
-require 'activerecord-refined'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+require "active_record"
+require "activerecord-refined"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 ActiveRecord::Migration.verbose = false
 
 class Setup < ActiveRecord::Migration[8.1]
   def up
-    create_table(:sales) {|t| t.string :region; t.string :day; t.integer :amount }
+    create_table(:sales) { |t| t.string :region; t.string :day; t.integer :amount }
   end
 end
 Setup.new.up
@@ -16,11 +18,11 @@ Setup.new.up
 class Sale < ActiveRecord::Base
 end
 
-Sale.create!(region: 'east', day: '2026-01-01', amount: 100)
-Sale.create!(region: 'east', day: '2026-01-02', amount: 40)
-Sale.create!(region: 'east', day: '2026-01-03', amount: 60)
-Sale.create!(region: 'west', day: '2026-01-01', amount: 20)
-Sale.create!(region: 'west', day: '2026-01-02', amount: 90)
+Sale.create!(region: "east", day: "2026-01-01", amount: 100)
+Sale.create!(region: "east", day: "2026-01-02", amount: 40)
+Sale.create!(region: "east", day: "2026-01-03", amount: 60)
+Sale.create!(region: "west", day: "2026-01-01", amount: 20)
+Sale.create!(region: "west", day: "2026-01-02", amount: 90)
 
 def show(title, relation, rows = nil)
   puts "--- #{title} ---"
@@ -32,18 +34,18 @@ end
 # 1. A window on an aggregate.  over turns an aggregate into a window
 #    function: the rows stay, and the aggregate is worked out over the window
 #    beside each one.  Without partition or order the window is every row.
-show('the total beside every row',
+show("the total beside every row",
   Sale.select { [:region, :amount, sum(:amount).over.as(:total)] },
   Sale.select { [:region, :amount, sum(:amount).over.as(:total)] }.
-    map {|s| [s.region, s.amount, s.total] })
+    map { |s| [s.region, s.amount, s.total] })
 
 # partition divides the rows into groups the window is worked out within.
 totals = -> {
   Sale.select { [:region, :amount, sum(:amount).over.partition(:region).as(:region_total)] }
 }
-show('a total per region, still row by row',
+show("a total per region, still row by row",
   totals.call,
-  totals.call.map {|s| [s.region, s.amount, s.region_total] })
+  totals.call.map { |s| [s.region, s.amount, s.region_total] })
 
 # 2. Frames.  With an order, the window can be cut down to a range of rows
 #    around the current one.  A Range of integers is what says which: 0 is the
@@ -55,9 +57,9 @@ running = -> {
      sum(:amount).over.partition(:region).order(:day).rows(..0).as(:running)]
   }
 }
-show('a running total within each region',
+show("a running total within each region",
   running.call,
-  running.call.map {|s| [s.region, s.day, s.amount, s.running] })
+  running.call.map { |s| [s.region, s.day, s.amount, s.running] })
 
 # 3. The functions that say nothing without a window.  row_number, rank and
 #    dense_rank number the rows of each partition; lag and lead reach the row
@@ -70,14 +72,14 @@ ranked = -> {
      lag(:amount).over.partition(:region).order(:day).as(:previous)]
   }
 }
-show('the place within the region, and the day before',
+show("the place within the region, and the day before",
   ranked.call,
-  ranked.call.map {|s| [s.region, s.amount, s.place, s.previous] })
+  ranked.call.map { |s| [s.region, s.amount, s.place, s.previous] })
 
 begin
   Sale.select { row_number }
 rescue ArgumentError => e
-  puts '--- a window function needs a window ---'
+  puts "--- a window function needs a window ---"
   puts "  #{e.message}"
   puts
 end
@@ -90,7 +92,7 @@ numbered = Sale.select {
 }
 # The subquery is named after the model's own table because Active Record goes
 # on qualifying columns with that name, so where has to find it there.
-show('the biggest sale of each region',
+show("the biggest sale of each region",
   Sale.from(numbered, :sales).where { :place == 1 },
   Sale.from(numbered, :sales).where { :place == 1 }.
-    map {|s| [s.region, s.day, s.amount] })
+    map { |s| [s.region, s.day, s.amount] })

data/examples/writes.rb

@@ -1,9 +1,11 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# frozen_string_literal: true
 
-require 'active_record'
-require 'activerecord-refined'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+require "active_record"
+require "activerecord-refined"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
 ActiveRecord::Migration.verbose = false
 
 class Setup < ActiveRecord::Migration[8.1]
@@ -22,22 +24,22 @@ Setup.new.up
 class Page < ActiveRecord::Base
 end
 
-Page.create!(path: '/index', hits: 10, bonus: 1, title: 'home')
-Page.create!(path: '/about', hits: 3,  bonus: 0, title: 'about us')
-Page.create!(path: '/faq',   hits: 0,  bonus: 5, title: 'faq')
+Page.create!(path: "/index", hits: 10, bonus: 1, title: "home")
+Page.create!(path: "/about", hits: 3,  bonus: 0, title: "about us")
+Page.create!(path: "/faq",   hits: 0,  bonus: 5, title: "faq")
 
 # These statements run rather than being built, so unlike the other examples
 # the SQL is taken from the notification Active Record sends for each one.
 def write(title)
   statements = []
-  subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |*, payload|
+  subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
     statements << payload[:sql] unless %w[SCHEMA TRANSACTION].include?(payload[:name])
   end
   yield
   ActiveSupport::Notifications.unsubscribe(subscriber)
   puts "--- #{title} ---"
-  statements.each {|sql| puts sql }
-  Page.order(:path).each {|p| puts "  #{p.path} hits=#{p.hits} title=#{p.title}" }
+  statements.each { |sql| puts sql }
+  Page.order(:path).each { |p| puts "  #{p.path} hits=#{p.hits} title=#{p.title}" }
   puts
 end
 
@@ -45,17 +47,17 @@ end
 #    :hits) would set the column to the symbol itself -- and the block reads a
 #    symbol as the column it names, which is what lets the new value be worked
 #    out from the old.
-write('hits made from the old hits') do
-  Page.where { :hits > 0 }.update_all { {hits: :hits + :bonus} }
+write("hits made from the old hits") do
+  Page.where { :hits > 0 }.update_all { { hits: :hits + :bonus } }
 end
 
-write('a function over the column') do
-  Page.update_all { {title: upper(:title)} }
+write("a function over the column") do
+  Page.update_all { { title: upper(:title) } }
 end
 
 # An expression as involved as any other block builds.
-write('CASE in an update') do
-  Page.update_all { {hits: case_when { :hits > 10 }.then(10).else(:hits)} }
+write("CASE in an update") do
+  Page.update_all { { hits: case_when { :hits > 10 }.then(10).else(:hits) } }
 end
 
 # 2. upsert_all.  The block is the part that decides what happens to a row
@@ -63,22 +65,22 @@ end
 #    inserted.  PostgreSQL and SQLite name it that; MySQL says VALUES(column),
 #    and the block comes out as whichever the adapter reads.
 incoming = [
-  {path: '/index', hits: 100, bonus: 0, title: 'HOME'},
-  {path: '/new',   hits: 7,   bonus: 0, title: 'NEW'},
+  { path: "/index", hits: 100, bonus: 0, title: "HOME" },
+  { path: "/new",   hits: 7,   bonus: 0, title: "NEW" },
 ]
-write('the old value and the new one added together') do
-  Page.upsert_all(incoming, unique_by: :path) { {hits: :hits + excluded(:hits)} }
+write("the old value and the new one added together") do
+  Page.upsert_all(incoming, unique_by: :path) { { hits: :hits + excluded(:hits) } }
 end
 
 # Without a block, upsert_all overwrites -- that is Active Record's own
 # behaviour, and the block is what makes the old value reachable.
-write('and without a block it is a plain overwrite') do
-  Page.upsert_all([{path: '/index', hits: 1, bonus: 0, title: 'HOME'}],
+write("and without a block it is a plain overwrite") do
+  Page.upsert_all([{ path: "/index", hits: 1, bonus: 0, title: "HOME" }],
                   unique_by: :path)
 end
 
 # insert_all has no block: Active Record type-casts each value into the VALUES
 # list, so an expression there would become nothing rather than SQL.
-write('insert_all takes literals') do
-  Page.insert_all([{path: '/legal', hits: 0, bonus: 0, title: 'legal'}])
+write("insert_all takes literals") do
+  Page.insert_all([{ path: "/legal", hits: 0, bonus: 0, title: "legal" }])
 end