activerecord-refined 0.8.0 → 0.9.0

data/examples/json.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(:documents) {|t| t.string :name; t.json :meta }
+    create_table(:documents) { |t| t.string :name; t.json :meta }
   end
 end
 Setup.new.up
@@ -16,12 +18,12 @@ Setup.new.up
 class Document < ActiveRecord::Base
 end
 
-Document.create!(name: 'guide',
-  meta: {'author' => {'name' => 'alice', 'country' => 'JP'},
-         'tags' => %w[ruby sql], 'views' => 120, 'draft' => false})
-Document.create!(name: 'notes',
-  meta: {'author' => {'name' => 'bob'}, 'tags' => ['ruby'], 'views' => 8})
-Document.create!(name: 'empty', meta: {})
+Document.create!(name: "guide",
+  meta: { "author" => { "name" => "alice", "country" => "JP" },
+         "tags" => %w[ruby sql], "views" => 120, "draft" => false })
+Document.create!(name: "notes",
+  meta: { "author" => { "name" => "bob" }, "tags" => ["ruby"], "views" => 8 })
+Document.create!(name: "empty", meta: {})
 
 def show(title, relation, rows = nil)
   puts "--- #{title} ---"
@@ -33,32 +35,32 @@ end
 # 1. Reading.  dig_text takes the path Hash#dig takes: a string or symbol
 #    steps into an object, an integer into an array.  What comes back is the
 #    value rather than the JSON around it, which is what a comparison wants.
-show('dig_text reads a value out of the document',
+show("dig_text reads a value out of the document",
   Document.select { [:name, :meta.dig_text(:author, :name).as(:author)] },
   Document.select { [:name, :meta.dig_text(:author, :name).as(:author)] }.
-    map {|d| [d.name, d.author] })
+    map { |d| [d.name, d.author] })
 
-show('an integer steps into an array',
+show("an integer steps into an array",
   Document.select { [:name, :meta.dig_text(:tags, 0).as(:first_tag)] },
   Document.select { [:name, :meta.dig_text(:tags, 0).as(:first_tag)] }.
-    map {|d| [d.name, d.first_tag] })
+    map { |d| [d.name, d.first_tag] })
 
 # A dug value is an expression like any other, so it compares and orders.
-show('dig_text in a condition',
-  Document.where { :meta.dig_text(:author, :country) == 'JP' },
-  Document.where { :meta.dig_text(:author, :country) == 'JP' }.pluck(:name))
+show("dig_text in a condition",
+  Document.where { :meta.dig_text(:author, :country) == "JP" },
+  Document.where { :meta.dig_text(:author, :country) == "JP" }.pluck(:name))
 
 # A dug value is text, so a number goes through a cast.  Comparing it with
 # one instead is refused rather than left to the adapters, which answer that
 # three ways: true here, an error on PostgreSQL, true on MySQL.
-show('a number wants a cast',
-  Document.where { cast(:meta.dig_text(:views), 'integer') > 100 },
-  Document.where { cast(:meta.dig_text(:views), 'integer') > 100 }.pluck(:name))
+show("a number wants a cast",
+  Document.where { cast(:meta.dig_text(:views), "integer") > 100 },
+  Document.where { cast(:meta.dig_text(:views), "integer") > 100 }.pluck(:name))
 
 begin
   Document.where { :meta.dig_text(:views) > 100 }
 rescue ArgumentError => e
-  puts '--- and without one it says so ---'
+  puts "--- and without one it says so ---"
   puts "  #{e.message}"
   puts
 end
@@ -66,45 +68,45 @@ end
 # dig keeps the JSON, for a part of the document to be dug into further
 # or asked the JSON questions.  The quotes around the string are the sign of
 # it -- and the reason a Ruby value is refused on this side too.
-show('dig keeps the JSON',
+show("dig keeps the JSON",
   Document.select { [:name, :meta.dig(:author).as(:author)] },
   Document.select { [:name, :meta.dig(:author).as(:author)] }.
-    map {|d| [d.name, d.author] })
+    map { |d| [d.name, d.author] })
 
 # 2. Asking whether a key is there at all, which is not the same as asking
 #    whether its value is null -- and is spelled key? for the reason Ruby's
 #    Hash spells it that way.
-show('key? asks whether the key is there',
+show("key? asks whether the key is there",
   Document.where { :meta.key?(:draft) },
   Document.where { :meta.key?(:draft) }.pluck(:name))
 
 # key? takes the one key Hash#key? takes; a path is what dig is for.
-show('and ! is its negation',
+show("and ! is its negation",
   Document.where { !:meta.key?(:draft) },
   Document.where { !:meta.key?(:draft) }.pluck(:name))
 
 # 3. Writing.  bury sets what dig reads, at the path given: JSON_SET on SQLite
 #    and MySQL, jsonb_set on PostgreSQL.
-show('the expression bury builds',
-  Document.select { [:name, :meta.bury(:author, :country, 'US').as(:updated)] })
+show("the expression bury builds",
+  Document.select { [:name, :meta.bury(:author, :country, "US").as(:updated)] })
 
 # It is an expression, so it is what update_all sets the column to.
-Document.where { :name == 'notes' }.update_all { {meta: :meta.bury(:author, :country, 'US')} }
-puts '--- what the update left behind ---'
+Document.where { :name == "notes" }.update_all { { meta: :meta.bury(:author, :country, "US") } }
+puts "--- what the update left behind ---"
 puts "  #{Document.find_by(name: 'notes').meta.inspect}"
 puts
 
 # A whole object or array goes in at once.
-Document.where { :name == 'empty' }.update_all { {meta: :meta.bury(:author, {'name' => 'carol'})} }
-puts '--- a whole object at once ---'
+Document.where { :name == "empty" }.update_all { { meta: :meta.bury(:author, { "name" => "carol" }) } }
+puts "--- a whole object at once ---"
 puts "  #{Document.find_by(name: 'empty').meta.inspect}"
 puts
 
 # The path is what makes the SQL, so it cannot be empty.
 begin
-  Document.select { :meta.bury('US') }
+  Document.select { :meta.bury("US") }
 rescue ArgumentError => e
-  puts '--- bury needs a path ---'
+  puts "--- bury needs a path ---"
   puts "  #{e.message}"
   puts
 end
@@ -112,11 +114,48 @@ end
 # 4. Taking keys out again, as Hash#except does: keys of the document rather
 #    than a path, however many of them, and a key that is not there is no
 #    error.  The document comes back changed, so it chains with bury.
-show('the expression except builds',
+show("the expression except builds",
   Document.select { [:name, :meta.except(:views, :draft).as(:trimmed)] })
 
-Document.where { :name == 'guide' }.
-  update_all { {meta: :meta.bury(:author, :country, 'JP').except(:tags, :views)} }
-puts '--- buried and excepted in one statement ---'
+Document.where { :name == "guide" }.
+  update_all { { meta: :meta.bury(:author, :country, "JP").except(:tags, :views) } }
+puts "--- buried and excepted in one statement ---"
 puts "  #{Document.find_by(name: 'guide').meta.inspect}"
 puts
+
+# 5. Gathering rows into one JSON document.  json_arrayagg collects a value
+#    from each row into an array, json_objectagg a key and a value into an
+#    object; SQLite spells them json_group_array and json_group_object.
+show("json_arrayagg collects the names",
+  Document.select { json_arrayagg(:name).as(:names) },
+  Document.select { json_arrayagg(:name).as(:names) }.take.names)
+
+# A dug value goes in as JSON, so a document nests rather than landing as
+# the string that spells it.
+show("json_objectagg pairs each name with its author",
+  Document.select { json_objectagg(:name, :meta.dig(:author)).as(:authors) },
+  Document.select { json_objectagg(:name, :meta.dig(:author)).as(:authors) }.take.authors)
+
+# 6. Building a document in the row.  json_array takes values, json_object
+#    a Ruby hash whose values are expressions -- the keys are Ruby's, so a
+#    bare symbol stays free to mean a column on the value side.
+show("json_object builds a document from columns",
+  Document.select { json_object(name: :name, author: :meta.dig(:author, :name)).as(:summary) },
+  Document.select { json_object(name: :name, author: :meta.dig(:author, :name)).as(:summary) }.
+    map(&:summary))
+
+# Built and gathered: one document per row, collected into one per query.
+show("json_arrayagg collects built documents",
+  Document.select { json_arrayagg(json_object(name: :name)).as(:docs) },
+  Document.select { json_arrayagg(json_object(name: :name)).as(:docs) }.take.docs)
+
+# 7. The keys of the document, as Hash#keys gives them: a JSON array.
+#    Where the document is not an object -- a value, an array, a missing
+#    key -- the answer is NULL on every adapter.
+show("keys lists what the document holds",
+  Document.select { [:name, :meta.keys.as(:fields)] },
+  Document.select { [:name, :meta.keys.as(:fields)] }.map { |d| [d.name, d.fields] })
+
+show("keys of a part, through dig",
+  Document.select { [:name, :meta.dig(:author).keys.as(:fields)] },
+  Document.select { [:name, :meta.dig(:author).keys.as(:fields)] }.map { |d| [d.name, d.fields] })

data/examples/postgresql.rb

@@ -1,8 +1,10 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+# frozen_string_literal: true
 
-require 'active_record'
-require 'activerecord-refined'
-require 'etc'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "active_record"
+require "activerecord-refined"
+require "etc"
 
 # What is here is what SQLite cannot run, so unlike the other examples this
 # one needs a server.  Most of it is PostgreSQL's alone; ANY and ALL, JSON
@@ -11,11 +13,11 @@ require 'etc'
 # and DB_PASSWORD.
 begin
   ActiveRecord::Base.establish_connection(
-    adapter: 'postgresql',
-    host: ENV.fetch('DB_HOST', '127.0.0.1'),
-    username: ENV.fetch('DB_USERNAME') { Etc.getlogin },
-    password: ENV['DB_PASSWORD'],
-    database: ENV.fetch('DB_NAME', 'postgres'))
+    adapter: "postgresql",
+    host: ENV.fetch("DB_HOST", "127.0.0.1"),
+    username: ENV.fetch("DB_USERNAME") { Etc.getlogin },
+    password: ENV["DB_PASSWORD"],
+    database: ENV.fetch("DB_NAME", "postgres"))
   ActiveRecord::Base.lease_connection
 rescue StandardError => e
   abort "needs a PostgreSQL server: #{e.message}"
@@ -25,7 +27,7 @@ ActiveRecord::Migration.verbose = false
 
 class Setup < ActiveRecord::Migration[8.1]
   def up
-    create_table(:writers, force: true) {|t| t.string :name; t.string :country }
+    create_table(:writers, force: true) { |t| t.string :name; t.string :country }
     create_table(:articles, force: true) do |t|
       t.string :title
       t.string :tags, array: true, default: []
@@ -48,17 +50,17 @@ end
 
 Article.delete_all
 Writer.delete_all
-alice = Writer.create!(name: 'alice', country: 'JP')
-bob   = Writer.create!(name: 'bob',   country: 'JP')
-carol = Writer.create!(name: 'carol', country: 'US')
-Article.create!(title: 'Refinements',   tags: %w[ruby lang],   scores: [5, 4],
-                writer: alice, likes: 120, flags: 5, meta: {'draft' => false, 'lang' => 'ja'})
-Article.create!(title: 'Rails 8',       tags: %w[ruby rails],  scores: [5],
-                writer: alice, likes: 80,  flags: 1, meta: {'draft' => false})
-Article.create!(title: 'Postgres CTEs', tags: %w[sql db],      scores: [3],
-                writer: bob,   likes: 30,  flags: 3, meta: {'draft' => true})
-Article.create!(title: '100% pure',     tags: ['100%', 'a,b'], scores: [],
-                writer: carol, likes: 5,   flags: 4, meta: {'draft' => true, 'lang' => 'ja'})
+alice = Writer.create!(name: "alice", country: "JP")
+bob   = Writer.create!(name: "bob",   country: "JP")
+carol = Writer.create!(name: "carol", country: "US")
+Article.create!(title: "Refinements",   tags: %w[ruby lang],   scores: [5, 4],
+                writer: alice, likes: 120, flags: 5, meta: { "draft" => false, "lang" => "ja" })
+Article.create!(title: "Rails 8",       tags: %w[ruby rails],  scores: [5],
+                writer: alice, likes: 80,  flags: 1, meta: { "draft" => false })
+Article.create!(title: "Postgres CTEs", tags: %w[sql db],      scores: [3],
+                writer: bob,   likes: 30,  flags: 3, meta: { "draft" => true })
+Article.create!(title: "100% pure",     tags: ["100%", "a,b"], scores: [],
+                writer: carol, likes: 5,   flags: 4, meta: { "draft" => true, "lang" => "ja" })
 
 def show(title, relation, rows = nil)
   puts "--- #{title} ---"
@@ -70,15 +72,15 @@ end
 # 1. Array columns.  Each name carries the meaning of its Ruby namesake:
 #    member? is Enumerable's element test, superset? and subset? are Set's
 #    containment, and intersect? is Array's "any element in common".
-show('member? tests one element',
-  Article.where { :tags.member?('ruby') },
-  Article.where { :tags.member?('ruby') }.pluck(:title))
+show("member? tests one element",
+  Article.where { :tags.member?("ruby") },
+  Article.where { :tags.member?("ruby") }.pluck(:title))
 
-show('superset? requires every element',
+show("superset? requires every element",
   Article.where { :tags.superset?(%w[ruby rails]) },
   Article.where { :tags.superset?(%w[ruby rails]) }.pluck(:title))
 
-show('subset? and intersect?',
+show("subset? and intersect?",
   Article.where { :tags.intersect?(%w[sql lang]) },
   [
     Article.where { :tags.subset?(%w[ruby lang extra]) }.pluck(:title),
@@ -87,46 +89,46 @@ show('subset? and intersect?',
 
 # The element is serialized into an array literal, so commas, quotes and %
 # are matched literally rather than parsed or treated as wildcards.
-show('elements are matched literally',
-  Article.where { :tags.member?('a,b') },
-  Article.where { :tags.member?('a,b') }.pluck(:title))
+show("elements are matched literally",
+  Article.where { :tags.member?("a,b") },
+  Article.where { :tags.member?("a,b") }.pluck(:title))
 
 # member? works on any element type; the literal is coerced to the column's.
-show('a numeric array',
+show("a numeric array",
   Article.where { :scores.member?(4) },
   Article.where { :scores.member?(4) }.pluck(:title))
 
 # 2. Regular expressions.  =~ and !~ become ~ and !~ here, REGEXP on MySQL.
 #    SQLite has no regexp operator, which is why this example is not one of
 #    the portable ones.
-show('=~ matches a regular expression',
-  Article.where { :title =~ '^R' },
-  Article.where { :title =~ '^R' }.pluck(:title))
+show("=~ matches a regular expression",
+  Article.where { :title =~ "^R" },
+  Article.where { :title =~ "^R" }.pluck(:title))
 
-show('a Regexp literal works too, and !~ negates',
+show("a Regexp literal works too, and !~ negates",
   Article.where { :title !~ /s$/ },
   Article.where { :title !~ /s$/ }.pluck(:title))
 
 # 3. Case.  like? is case-sensitive LIKE everywhere, including here, where
 #    Arel would otherwise reach for ILIKE.  ilike? is the one that asks for
 #    it, and casecmp? is case-insensitive equality.
-show('like? stays case-sensitive; ilike? does not',
-  Article.where { :title.ilike?('r%') },
+show("like? stays case-sensitive; ilike? does not",
+  Article.where { :title.ilike?("r%") },
   [
-    Article.where { :title.like?('r%') }.pluck(:title),
-    Article.where { :title.ilike?('r%') }.pluck(:title),
+    Article.where { :title.like?("r%") }.pluck(:title),
+    Article.where { :title.ilike?("r%") }.pluck(:title),
   ])
 
 # 4. NULL as a value.  PostgreSQL spells this IS [NOT] DISTINCT FROM.
-show('null-safe comparison',
-  Article.where { :title.not_distinct_from?('Rails 8') },
-  Article.where { :title.not_distinct_from?('Rails 8') }.pluck(:title))
+show("null-safe comparison",
+  Article.where { :title.not_distinct_from?("Rails 8") },
+  Article.where { :title.not_distinct_from?("Rails 8") }.pluck(:title))
 
 # 5. Keeping one row per group.  DISTINCT ON is PostgreSQL's: the first row of
 #    each group the order brings up, which is why the order has to start with
 #    what the distinct is on.  Arel refuses to write it for the others, so the
 #    portable shape is a row_number window in a subquery.
-show('the most liked article of each writer',
+show("the most liked article of each writer",
   Article.distinct_on { :writer_id }.order { [:writer_id, :likes.desc] },
   Article.distinct_on { :writer_id }.order { [:writer_id, :likes.desc] }.
     pluck(:title))
@@ -139,11 +141,13 @@ sets = Article.
   joins(:writers) { :writers[:id] == :articles[:writer_id] }.
   group { grouping_sets([:writers[:country]], [:articles[:writer_id]], []) }.
   select { [:writers[:country], :articles[:writer_id], sum(:likes).as(:likes)] }
-show('by country, by writer, and both together',
+show("by country, by writer, and both together",
   sets,
-  sets.map {|a| [a.country, a.writer_id, a.likes] })
+  sets.map { |a| [a.country, a.writer_id, a.likes] })
 
-show('rollup is the nested case of the same thing',
+# rollup runs on MySQL and MariaDB too, as their WITH ROLLUP; the other two
+# groupings are PostgreSQL's alone.
+show("rollup is the nested case of the same thing",
   Article.group { rollup(:writer_id, :flags) }.select { [:writer_id, :flags, count(:*).as(:n)] })
 
 # 7. Lateral joins.  A lateral join lets the relation joined see the row being
@@ -155,14 +159,14 @@ top = Article.select { :title }.
   order { :likes.desc }.limit(1)
 lateral = Writer.left_outer_joins(top.lateral, as: :top).
   select { [:name, :top[:title].as(:top_article)] }
-show('the top article beside each writer',
+show("the top article beside each writer",
   lateral,
-  lateral.map {|w| [w.name, w.top_article] })
+  lateral.map { |w| [w.name, w.top_article] })
 
 # 8. ANY and ALL, which quantify a comparison over a subquery where a scalar
 #    subquery would have to return the one row.  MySQL has them too; SQLite
 #    has neither, and says so rather than leaving its parser to.
-show('more liked than some article of alice, and than all of them',
+show("more liked than some article of alice, and than all of them",
   Article.where { :likes > any(Article.where { :writer_id == alice.id }.select(:likes)) },
   [
     Article.where { :likes > any(Article.where { :writer_id == alice.id }.select(:likes)) }.
@@ -174,15 +178,22 @@ show('more liked than some article of alice, and than all of them',
 # 9. JSON containment and the bit aggregates, which PostgreSQL and MySQL have
 #    and SQLite does not.  contains? asks whether the document holds the one
 #    given, which is @> here and JSON_CONTAINS on MySQL.
-show('containment asks about a whole document',
+show("containment asks about a whole document",
   Article.where { :meta.contains?(draft: true) },
   Article.where { :meta.contains?(draft: true) }.pluck(:title))
 
-show('the bits every article has, and the bits any of them has',
+# A JSON comparison belongs to the JSON types -- jsonb here, MySQL's JSON
+# too: numbers compare as numbers, documents structurally.  SQLite and
+# MariaDB have only the text of each and raise.
+show("a dug value compares with a Ruby one directly",
+  Article.where { :meta.dig(:draft) == true },
+  Article.where { :meta.dig(:draft) == true }.pluck(:title))
+
+show("the bits every article has, and the bits any of them has",
   Article.select { [bit_and(:flags).as(:common), bit_or(:flags).as(:any)] },
   Article.select { [bit_and(:flags).as(:common), bit_or(:flags).as(:any)] }.
-    map {|a| [a.common, a.any] })
+    map { |a| [a.common, a.any] })
 
-show('and how many bits are set in each',
+show("and how many bits are set in each",
   Article.select { [:title, bit_count(:flags).as(:bits)] },
-  Article.select { [:title, bit_count(:flags).as(:bits)] }.map {|a| [a.title, a.bits] })
+  Article.select { [:title, bit_count(:flags).as(:bits)] }.map { |a| [a.title, a.bits] })

data/examples/predicates.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]
@@ -21,11 +23,11 @@ Setup.new.up
 class Account < ActiveRecord::Base
 end
 
-Account.create!(login: 'alice',     country: 'JP', age: 60, verified: true)
-Account.create!(login: 'bob',       country: 'JP', age: 50, verified: false)
-Account.create!(login: 'carol',     country: 'US', age: 45, verified: true)
-Account.create!(login: '100%_pure', country: nil,  age: 30)
-Account.create!(login: '1002000',   country: 'US', age: 25, verified: false)
+Account.create!(login: "alice",     country: "JP", age: 60, verified: true)
+Account.create!(login: "bob",       country: "JP", age: 50, verified: false)
+Account.create!(login: "carol",     country: "US", age: 45, verified: true)
+Account.create!(login: "100%_pure", country: nil,  age: 30)
+Account.create!(login: "1002000",   country: "US", age: 25, verified: false)
 
 def show(title, relation, rows)
   puts "--- #{title} ---"
@@ -36,38 +38,38 @@ end
 
 # 1. Ranges and sets.  in? is one name for "belongs to this set": a Range
 #    becomes BETWEEN, an endless Range a bare comparison, a list an IN.
-show('in? with a Range becomes BETWEEN',
+show("in? with a Range becomes BETWEEN",
   Account.where { :age.in?(40..55) },
   Account.where { :age.in?(40..55) }.pluck(:login))
 
-show('endless range and IN',
+show("endless range and IN",
   Account.where { :age.in?(50..) | :country.in?(%w[US]) },
   Account.where { :age.in?(50..) | :country.in?(%w[US]) }.pluck(:login))
 
 # 2. NULL.  = NULL is never true in SQL, so == nil raises and the test is
 #    spelled null?.  not_distinct_from? is the null-safe equality, which is
 #    what to reach for when the value may or may not be nil.
-show('null? and its negation',
+show("null? and its negation",
   Account.where { :country.null? },
   Account.where { :country.null? }.pluck(:login))
 
 wanted = nil
-show('not_distinct_from? matches NULL to nil',
+show("not_distinct_from? matches NULL to nil",
   Account.where { :country.not_distinct_from?(wanted) },
   Account.where { :country.not_distinct_from?(wanted) }.pluck(:login))
 
 # Unlike !=, distinct_from? keeps the NULL row.
-show('distinct_from? keeps NULLs, != drops them',
-  Account.where { :country.distinct_from?('JP') },
+show("distinct_from? keeps NULLs, != drops them",
+  Account.where { :country.distinct_from?("JP") },
   [
-    Account.where { :country.distinct_from?('JP') }.pluck(:login),
-    Account.where { :country != 'JP' }.pluck(:login),
+    Account.where { :country.distinct_from?("JP") }.pluck(:login),
+    Account.where { :country != "JP" }.pluck(:login),
   ])
 
 # A boolean column has true? and false?, which become IS TRUE and IS FALSE,
 # and the negation of each.  All four are spelled and answered the same way by
 # every adapter, NULL included.
-show('the four truth tests',
+show("the four truth tests",
   Account.where { :verified.false? },
   [
     Account.where { :verified.true? }.pluck(:login),
@@ -79,7 +81,7 @@ show('the four truth tests',
 # They answer for a NULL row where a comparison against the literal does not,
 # so it is negating them that tells the two apart: not_true? has the
 # unverified accounts and the one never asked, !(== true) only the former.
-show('not_true? keeps the NULLs that != TRUE drops',
+show("not_true? keeps the NULLs that != TRUE drops",
   Account.where { :verified.not_true? },
   [
     Account.where { :verified.not_true? }.pluck(:login),
@@ -89,32 +91,32 @@ show('not_true? keeps the NULLs that != TRUE drops',
 # 3. Text.  like? takes a pattern; start_with?, end_with? and include? take
 #    literals, so % and _ in them are escaped rather than matched as
 #    wildcards.  Note the last row matches only the literal-minded one.
-show('like? takes a pattern',
-  Account.where { :login.like?('%rol') },
-  Account.where { :login.like?('%rol') }.pluck(:login))
+show("like? takes a pattern",
+  Account.where { :login.like?("%rol") },
+  Account.where { :login.like?("%rol") }.pluck(:login))
 
-show('start_with? takes any number of literals, like String#start_with?',
-  Account.where { :login.start_with?('al', 'bo') },
-  Account.where { :login.start_with?('al', 'bo') }.pluck(:login))
+show("start_with? takes any number of literals, like String#start_with?",
+  Account.where { :login.start_with?("al", "bo") },
+  Account.where { :login.start_with?("al", "bo") }.pluck(:login))
 
 # The % in the argument is escaped, so only the account whose login really
 # contains "100%" matches; the same pattern spelled with like? treats it as a
 # wildcard and catches 1002000 as well.
-show('include? escapes wildcards; like? does not',
-  Account.where { :login.include?('100%') },
+show("include? escapes wildcards; like? does not",
+  Account.where { :login.include?("100%") },
   [
-    Account.where { :login.include?('100%') }.pluck(:login),
-    Account.where { :login.like?('%100%%') }.pluck(:login),
+    Account.where { :login.include?("100%") }.pluck(:login),
+    Account.where { :login.like?("%100%%") }.pluck(:login),
   ])
 
 # casecmp? folds both sides rather than trusting the collation, so it means
 # the same thing on every adapter.
-show('casecmp? is case-insensitive equality',
-  Account.where { :login.casecmp?('AlIcE') },
-  Account.where { :login.casecmp?('AlIcE') }.pluck(:login))
+show("casecmp? is case-insensitive equality",
+  Account.where { :login.casecmp?("AlIcE") },
+  Account.where { :login.casecmp?("AlIcE") }.pluck(:login))
 
 # 4. Combining.  & | ! build the tree; Ruby's precedence puts & and | above
 #    the comparison operators, hence the parentheses around each comparison.
-show('compound conditions',
+show("compound conditions",
   Account.where { (:age >= 40) & (:country.in?(%w[JP US]) | :country.null?) },
   Account.where { (:age >= 40) & (:country.in?(%w[JP US]) | :country.null?) }.pluck(:login))

data/examples/subqueries.rb

@@ -1,15 +1,17 @@
-$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(:authors) {|t| t.string :name }
-    create_table(:posts)   {|t| t.string :title; t.integer :author_id; t.integer :likes; t.boolean :published }
+    create_table(:authors) { |t| t.string :name }
+    create_table(:posts)   { |t| t.string :title; t.integer :author_id; t.integer :likes; t.boolean :published }
   end
 end
 Setup.new.up
@@ -24,44 +26,44 @@ class Post < ActiveRecord::Base
   def self.published = where { :published == true }
 end
 
-alice  = Author.create!(name: 'alice')
-bob  = Author.create!(name: 'bob')
-quiet = Author.create!(name: 'quiet')
+alice = Author.create!(name: "alice")
+bob = Author.create!(name: "bob")
+Author.create!(name: "quiet")
 
-Post.create!(title: 'refinements', author_id: alice.id, likes: 100, published: true)
-Post.create!(title: 'parser',      author_id: alice.id, likes: 40,  published: true)
-Post.create!(title: 'draft',       author_id: bob.id, likes: 5,   published: false)
+Post.create!(title: "refinements", author_id: alice.id, likes: 100, published: true)
+Post.create!(title: "parser",      author_id: alice.id, likes: 40,  published: true)
+Post.create!(title: "draft",       author_id: bob.id, likes: 5,   published: false)
 
 def show(title, relation)
   puts "--- #{title} ---"
   puts relation.to_sql
-  puts relation.pluck(relation.model.table_name == 'authors' ? :name : :title).inspect
+  puts relation.pluck(relation.model.table_name == "authors" ? :name : :title).inspect
   puts
 end
 
 # 1. in? takes a relation as a subquery.  With an explicit select list the
 #    subquery selects that column; without one it selects the primary key,
 #    the same way Active Record's own where(id: relation) does.
-show('in? with a subquery',
+show("in? with a subquery",
   Author.where { :id.in?(Post.published.select(:author_id)) })
 
 # 2. exists? asks whether the subquery returns a row.  Correlate it with the
 #    outer table through qualified columns; the inner where block is the same
 #    DSL as the outer one.
-show('exists?',
+show("exists?",
   Author.where { exists?(Post.published.where { :posts[:author_id] == :authors[:id] }) })
 
-show('!exists? finds what has nothing to show',
+show("!exists? finds what has nothing to show",
   Author.where { !exists?(Post.where { :posts[:author_id] == :authors[:id] }) })
 
 # 3. A relation on the right of a comparison is a scalar subquery.  It has to
 #    yield a single value, so unlike in? there is no default select list and
 #    one is required.
-show('a scalar subquery on the right of a comparison',
+show("a scalar subquery on the right of a comparison",
   Post.where { :likes >= Post.select { avg(:likes) } })
 
 # The three compose like any other predicate.
-show('combined with the rest of the vocabulary',
+show("combined with the rest of the vocabulary",
   Author.
     where { exists?(Post.where { :posts[:author_id] == :authors[:id] }) }.
     where { !:id.in?(Post.where { :published == false }.select(:author_id)) })