activerecord-refined 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3818aa9d45162578a7a0f01eae7b45f943e2a2b1708ec689cd7ba484af9011e
-  data.tar.gz: 27674049c82ce8ba096f6a9416b603b25c97d326cb3ea78e557b43ffe76b25a0
+  metadata.gz: 98f198f59d3bb4b6f4c51a16940d4e7ee44b890aa7e033a327a650b73cb3dfbd
+  data.tar.gz: 5fb7cdd8964b82d6bb14ffdfecf1400ea875f1c5bc12d7fa4645c431caf47d19
 SHA512:
-  metadata.gz: 6a3d6b39152e68a21a21a14abd1092484eb335137a182db8068396ef7fa98ca17bd4bb152b0b028bc3ef2e1de17e8d257dcdb03a57cf093a650f387196e22ee9
-  data.tar.gz: 5e44084905b8c8d22bdde49aad72ceab1b22b1be4e139e8f60237a134a05c258413503595af0f49409ac19923ed296ecbd3f7c075c64b20e6e61f8c2100e5dd3
+  metadata.gz: 5ea7a29d21b31e3bf5f262a54eacb8e4e27590d9031f560d8de635da958cf91e6c5ef0872e77caf7b4e32907d2985f13fcd2ff8492ffbeda0edff1d8b7f658f4
+  data.tar.gz: 4949bb4ce9b0e4cd0f964e7f2759460a72707734a56d746cbf1221f80f9f7a87161c4a494c0226b880d7ad905e6c83933b29254c5ce3e59c41de415339557f56

data/.github/workflows/sandbox.yml

@@ -0,0 +1,158 @@
+name: sandbox
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: sandbox-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: sandbox
+
+    steps:
+      - uses: actions/checkout@v7
+
+      # The host Ruby cannot be 4.1: ruby_wasm's native extension depends on
+      # rb-sys, which does not build against Ruby 4.1's headers.  rbwasm is
+      # only a build tool -- the Ruby it produces is the one that matters.
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '4.0'
+          bundler-cache: false
+          working-directory: sandbox
+
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '24'
+
+      # The Ruby checkout and the build tree have to be cached together.  make
+      # decides by mtime, so restoring objects next to a freshly cloned Ruby
+      # would rebuild everything.
+      #
+      # The build directory is keyed on the gems that have C extensions, so
+      # Gemfile.lock covers it; RUBY_REV is pinned in bin/build-wasm, and the
+      # staged extension comes from ext/ and the sqlite3 gem.
+      #
+      # restore-keys is what keeps this worth caching -- a key change would
+      # otherwise mean a cold 16-minute build rather than two minutes -- but it
+      # also means a bad tree outlives the key that produced it, since the
+      # prefix still matches.  Editing a file in the key does not clear it;
+      # deleting the cache does.  bin/build-wasm rejects a ruby.wasm built from
+      # such a tree, so it fails the run rather than shipping.
+      - name: Restore the WASM build tree
+        uses: actions/cache@v6
+        with:
+          path: sandbox/build
+          key: wasm-${{ runner.os }}-${{ hashFiles('sandbox/Gemfile.lock', 'sandbox/bin/build-wasm', 'sandbox/ext/**') }}
+          restore-keys: wasm-${{ runner.os }}-
+
+      - run: bundle install --jobs 4
+      - run: npm ci
+
+      - name: Build ruby.wasm
+        run: ./bin/build-wasm
+
+      - name: Assemble the Ruby files served to the page
+        run: ./bin/prepare-rb
+
+      # Runs every example through the same WASI shim the page uses.  The
+      # larger stack is needed to compile ActiveRecord's relation.rb; see the
+      # note in sandbox/README.md.
+      - name: Check the examples
+        run: node --stack-size=4000 check-examples.mjs
+
+      # ruby.wasm is 40 MB, which a Cloudflare Pages asset may not be and which
+      # is nearly all of the bandwidth this page uses, so it is served from R2
+      # -- egress there is free -- and only the page itself from Pages.
+      #
+      # The key carries a hash of the binary, so a rebuild lands on a new URL
+      # and nothing has to be purged.  R2 serves what it is given and does not
+      # compress, hence gzip with the encoding recorded on the object: 40 MB
+      # becomes 12 MB on the wire.
+      #
+      # Without the secrets configured the upload is skipped and ruby.wasm
+      # rides along in the Pages artifact as before, which keeps forks working.
+      # Uploaded over R2's S3-compatible API rather than with wrangler, so that
+      # the token can be an Object Read & Write one scoped to this bucket.
+      # Those permissions exist only on the S3 API: wrangler goes through
+      # Cloudflare's REST API, which answers 403 to them and wants Admin Read &
+      # Write -- a token that can create and delete every bucket in the
+      # account, which is not what a public repository's CI should hold.
+      - name: Upload ruby.wasm to R2
+        id: r2
+        if: github.ref == 'refs/heads/master' && vars.R2_PUBLIC_URL != ''
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          AWS_DEFAULT_REGION: auto
+          # R2 sends no checksum headers back, which newer AWS CLIs insist on.
+          AWS_REQUEST_CHECKSUM_CALCULATION: when_required
+          AWS_RESPONSE_CHECKSUM_VALIDATION: when_required
+        run: |
+          gzip -9 -c ruby.wasm > /tmp/ruby.wasm.gz
+
+          # One key, overwritten each time, since only the newest build is of
+          # any use.  That rules out caching it as immutable: the URL no longer
+          # changes with the contents, so a long max-age would go on serving
+          # the previous binary.  Five minutes bounds how stale a visitor's
+          # copy can be just after a deploy, and revalidation costs a 304
+          # rather than 12 MB.
+          aws s3api put-object \
+            --endpoint-url "https://${{ secrets.CLOUDFLARE_ACCOUNT_ID }}.r2.cloudflarestorage.com" \
+            --bucket "${{ vars.R2_BUCKET }}" \
+            --key ruby-head.wasm \
+            --body /tmp/ruby.wasm.gz \
+            --content-type application/wasm \
+            --content-encoding gzip \
+            --cache-control "public, max-age=300" \
+            --no-cli-pager
+
+          echo '{"rubyWasmUrl":"${{ vars.R2_PUBLIC_URL }}/ruby-head.wasm"}' > config.json
+          echo "uploaded=true" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: sandbox
+          path: |
+            sandbox/index.html
+            sandbox/boot.rb
+            sandbox/examples.js
+            sandbox/manifest.json
+            sandbox/config.json
+            ${{ steps.r2.outputs.uploaded != 'true' && 'sandbox/ruby.wasm' || '' }}
+            sandbox/rb
+            sandbox/assets
+          if-no-files-found: ignore
+          retention-days: 7
+
+  deploy:
+    if: github.ref == 'refs/heads/master'
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: sandbox
+          path: site
+
+      - uses: actions/configure-pages@v6
+      - uses: actions/upload-pages-artifact@v5
+        with:
+          path: site
+      - id: deploy
+        uses: actions/deploy-pages@v5

data/README.md

@@ -14,6 +14,10 @@ Author.
 #   WHERE "authors"."age" BETWEEN 20 AND 40 AND "posts"."published" = TRUE
 ```
 
+**[Try it in your browser](https://shugo.github.io/activerecord-refined/)** —
+Ruby 4.1, ActiveRecord and SQLite run in the page, so the examples build real
+SQL and return real rows without a `ruby-master` build of your own.
+
 ## History
 
 This gem was formerly known as **activerecord-refinements**, created by Akira Matsuda
@@ -41,6 +45,10 @@ works again without monkey-patching `Symbol` globally.
 * Ruby 4.1 or later (for `Proc#refined`; not released yet, so a `ruby-master` build is needed for now)
 * ActiveRecord 7.0 or later
 
+The [sandbox](https://shugo.github.io/activerecord-refined/) is there to skip
+that build: it carries its own Ruby 4.1. `sandbox/` in this repository is what
+it is made of.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -79,6 +87,24 @@ Author.where { :country.in?(%w[JP US]) }    # IN
 Author.where { :country.null? }             # IS NULL
 ```
 
+`!` negates any of these. Where SQL has a negative of its own, so does the
+block, which is the same rows written the way they would be written by hand:
+
+```ruby
+Author.where { :country.not_null? }             # IS NOT NULL
+Author.where { :country.not_in?(%w[JP US]) }    # NOT IN
+Author.where { :age.not_between?(20, 40) }      # not between 20 and 40
+Author.where { :name.not_like?('A%') }          # NOT LIKE
+Author.where { :name.not_ilike?('a%') }         # NOT ILIKE / NOT LIKE
+
+Author.where { !:name.start_with?('A') }        # NOT (name LIKE 'A%')
+```
+
+Nothing turns on the choice: `NOT (country IS NULL)` and `country IS NOT NULL`
+select the same rows, NULLs included. `not_between?` is the one whose SQL
+looks unlike its name — Arel writes it as the two comparisons, `age < 20 OR
+age > 40`, which is again the same rows.
+
 `in?` also takes a relation as a subquery. Without an explicit select list the
 subquery selects the relation's primary key, the same way ActiveRecord's own
 `where(id: relation)` does:
@@ -118,7 +144,7 @@ collation, so it means the same thing everywhere:
 
 ```ruby
 Author.where { :name.ilike?('ma%') }        # ILIKE 'ma%' / LIKE 'ma%'
-Author.where { :name.casecmp?('Matz') }     # LOWER(name) = LOWER('Matz')
+Author.where { :name.casecmp?('Alice') }     # LOWER(name) = LOWER('Alice')
 ```
 
 `not_distinct_from?` and `distinct_from?` compare with NULL treated as a
@@ -239,23 +265,53 @@ ActiveRecord's `with` and `with_recursive` need nothing from this gem: a CTE
 is joined by name like any other table, so its `ON` clause is a block, where
 Rails' own documentation reaches for a string join.
 
-`from` takes the CTE's name as a symbol, with `as` to select it under the
-model's own table name so the model's columns resolve:
+`from_cte` takes the CTE's name and selects it under the model's own table
+name, so the model's columns resolve:
 
 ```ruby
 Node.with_recursive(
   tree: [
-    Node.where { :id == root.id },
-    Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] },
+    Node.where { :id == root.id }.
+      select { [:id, :name, :parent_id, 0.as(:depth)] },
+    Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] }.
+      select { [:nodes[:id], :nodes[:name], :nodes[:parent_id],
+                (:tree[:depth] + 1).as(:depth)] },
   ]
-).from(:tree, as: :nodes)
+).from_cte(:tree)
 # WITH RECURSIVE "tree" AS (
-#   SELECT "nodes".* FROM "nodes" WHERE "nodes"."id" = 1
+#   SELECT "nodes"."id", "nodes"."name", "nodes"."parent_id", 0 AS depth
+#     FROM "nodes" WHERE "nodes"."id" = 1
 #   UNION ALL
-#   SELECT "nodes".* FROM "nodes" INNER JOIN "tree" ON "nodes"."parent_id" = "tree"."id"
+#   SELECT "nodes"."id", "nodes"."name", "nodes"."parent_id",
+#          ("tree"."depth" + 1) AS depth
+#     FROM "nodes" INNER JOIN "tree" ON "nodes"."parent_id" = "tree"."id"
 # ) SELECT "nodes".* FROM "tree" AS "nodes"
 ```
 
+The anchor starts the count and the recursive member adds one, which is how
+the shape of a tree comes out of a flat table. The `0` is a value rather than
+SQL — see [`value`](#aggregates-functions-and-aliases) below for why a number
+can say `.as` directly.
+
+The alias on the last line is there for ActiveRecord's sake, not SQL's:
+written by hand that line would be `SELECT * FROM tree`. ActiveRecord goes on qualifying
+columns with the model's table name, so without the alias that name is not in
+the query and anything qualifying a column fails:
+
+```ruby
+Node.with_recursive(tree: [...]).from(:tree).where(name: 'root')
+# PG::UndefinedTable: missing FROM-clause entry for table "nodes"
+```
+
+Since the model's name is the only one that works, `from_cte` takes it from
+the model rather than asking. `from(:tree, as: :nodes)` is the same thing
+spelled out, and is what to reach for when the name wanted is not the model's.
+
+What makes this worth spelling out is how selectively it breaks. `count`,
+`order` and `select` never qualify, so they work without the alias on every
+adapter; it is `where` and `find_by` that stop. A query can therefore look
+right until the day a condition is added to it.
+
 A non-recursive CTE joins the same way:
 
 ```ruby
@@ -277,18 +333,54 @@ so a misspelling is a `NoMethodError` where you wrote it, and a name Ruby also
 answers to — `rand` — means the SQL one inside a block:
 
 ```
-abs  ceil  char_length  coalesce  concat  date_trunc  exp  floor  format
-greatest  least  length  ln  log  lower  ltrim  mod  now  nullif  power  rand
-replace  round  rtrim  sqrt  substr  trim  upper
+abs  acos  asin  atan  atan2  cast  ceil  char_length  coalesce  concat
+cos  current_date  current_time  current_timestamp  date_trunc  degrees
+exp  extract  floor  format  greatest  least  length  ln  localtime
+localtimestamp  log  log10  log2  lower  ltrim  mod  now  nullif  pi
+power  radians  rand  replace  round  rtrim  sign  sin  sqrt  substr  tan
+trim  trunc  upper
 ```
 
 Most are spelled the same everywhere. Where they are not, the method names one
 meaning and each adapter gets its own spelling: `char_length`, `greatest` and
 `least` become `LENGTH`, `MAX` and `MIN` on SQLite, and `rand` is `RAND` on
-MySQL and `RANDOM` elsewhere. Where an adapter has no equivalent — `date_trunc`
-outside PostgreSQL, `now` on SQLite — the block raises `NotImplementedError`
+MySQL and `RANDOM` elsewhere, and `trunc` is `TRUNCATE` on MySQL, which
+insists on the second argument the others default to zero — SQLite's takes
+only the one. Where an adapter has no equivalent — `date_trunc` outside
+PostgreSQL, `now` and the `local*` pair on SQLite, `log2` on PostgreSQL,
+whose spelling is `log(2, x)` — the block raises `NotImplementedError`
 rather than leaving the database to reject the SQL.
 
+`current_date`, `current_time`, `current_timestamp`, `localtime` and
+`localtimestamp` come out without parentheses, as the grammar has them —
+written as calls, PostgreSQL and SQLite would reject them. What does go into
+parentheses is an optional precision — `current_timestamp(3)` — which
+`current_date` never takes and SQLite never accepts. `current_timestamp` is
+the portable spelling of what `now` means, and reaches SQLite where `now`
+does not:
+
+```ruby
+Post.where { :published_at <= current_timestamp }
+# SELECT "posts".* FROM "posts" WHERE "posts"."published_at" <= CURRENT_TIMESTAMP
+```
+
+`extract` and `cast` are grammar as well: the field and the type go where no
+value could. The field has to be a plain name, and the type has to look like
+a type — a plain name, at most parenthesized with lengths, so the adapters'
+own spellings like `double precision` or `decimal(10,2)` pass; anything else
+raises `ArgumentError`. The type is the adapter's own name for the type, and
+whether it exists is the database's to say. SQLite spells everything
+`extract` does as `strftime` formats, which no renaming carries, so `extract`
+raises there:
+
+```ruby
+Post.where { extract(:year, :created_at) == 2026 }
+# SELECT "posts".* FROM "posts" WHERE EXTRACT(YEAR FROM "posts"."created_at") = 2026
+
+Post.select { cast(:price, 'decimal(10,2)').as(:price) }
+# SELECT CAST("posts"."price" AS decimal(10,2)) AS price
+```
+
 `format` is printf formatting, and raises on MySQL, where a function of the
 same name does something else entirely: it puts separators in a number, and
 reads a printf template as the number zero rather than complaining. `fn` still
@@ -314,6 +406,29 @@ written into the SQL as given — so those two have to be plain names,
 optionally qualified by a schema in `fn`'s case. Anything else raises
 `ArgumentError` rather than reaching the query.
 
+One place asks for a value to be said out loud: the top of a select list.
+Everywhere else a bare literal is already a value — `where { :age > 18 }`,
+`concat(:name, '-x')` — but ActiveRecord reads a string in `select` as SQL,
+so `value` is how you ask for the other meaning. It carries the predications
+and arithmetic with it, so a literal can be compared and combined like
+anything else. Numbers have a shorthand, since nothing else could be meant by
+one:
+
+```ruby
+Node.select { [:id, value(0).as(:depth)] }
+# SELECT "nodes"."id", 0 AS depth FROM "nodes"
+
+Node.select { [:id, 0.as(:depth)] }         # the same thing
+
+Post.select { [:title, value('draft').as(:state)] }
+# SELECT "posts"."title", 'draft' AS state FROM "posts"
+```
+
+The shorthand is `Integer` and `Float` only. `String` keeps its two meanings —
+SQL in a select list, a value everywhere else — and refining it would make the
+same literal mean one thing or the other depending on whether it had been sent
+a message.
+
 `fn` reaches functions without a method of their own. Its name is emitted as
 written, so a case-sensitive one can be spelled exactly:
 

data/activerecord-refined.gemspec

@@ -12,7 +12,10 @@ Gem::Specification.new do |gem|
   gem.summary       = 'ActiveRecord + Ruby 4.1 Proc#refined'
   gem.homepage      = 'https://github.com/shugo/activerecord-refined'
 
-  gem.files         = `git ls-files`.split($/)
+  # sandbox/ is a site, not part of the library: its Gemfile.lock and
+  # package-lock.json have no business in anyone's bundle.  CLAUDE.md is
+  # addressed to whoever is working on the repository, not to anyone using it.
+  gem.files         = `git ls-files`.split($/).grep_v(%r{^sandbox/|^CLAUDE\.md$})
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]

data/benchmark/query_building.rb

@@ -28,10 +28,10 @@ T = User.arel_table
 # Each variant must generate equivalent SQL; sanity-print once.
 VARIANTS = {
   "simple equality" => {
-    "hash"   => -> { User.where(name: "matz").to_sql },
-    "string" => -> { User.where("name = ?", "matz").to_sql },
-    "arel"   => -> { User.where(T[:name].eq("matz")).to_sql },
-    "block"  => -> { User.where { :name == "matz" }.to_sql },
+    "hash"   => -> { User.where(name: "alice").to_sql },
+    "string" => -> { User.where("name = ?", "alice").to_sql },
+    "arel"   => -> { User.where(T[:name].eq("alice")).to_sql },
+    "block"  => -> { User.where { :name == "alice" }.to_sql },
   },
   "range (BETWEEN)" => {
     "hash"   => -> { User.where(age: 20..40).to_sql },
@@ -41,13 +41,13 @@ VARIANTS = {
   "LIKE" => {
     "string" => -> { User.where("name LIKE ?", "ma%").to_sql },
     "arel"   => -> { User.where(T[:name].matches("ma%", nil, true)).to_sql },
-    "block"  => -> { User.where { :name.like?("ma%") }.to_sql },
+    "block"  => -> { User.where { :name.like?("al%") }.to_sql },
   },
   "compound AND/OR" => {
-    "string"   => -> { User.where("age >= ? AND (name = ? OR name = ?)", 18, "matz", "nobu").to_sql },
-    "arel"     => -> { User.where(T[:age].gteq(18).and(T[:name].eq("matz").or(T[:name].eq("nobu")))).to_sql },
-    "relation" => -> { User.where(age: 18..).and(User.where(name: "matz").or(User.where(name: "nobu"))).to_sql },
-    "block"    => -> { User.where { (:age >= 18) & ((:name == "matz") | (:name == "nobu")) }.to_sql },
+    "string"   => -> { User.where("age >= ? AND (name = ? OR name = ?)", 18, "alice", "bob").to_sql },
+    "arel"     => -> { User.where(T[:age].gteq(18).and(T[:name].eq("alice").or(T[:name].eq("bob")))).to_sql },
+    "relation" => -> { User.where(age: 18..).and(User.where(name: "alice").or(User.where(name: "bob"))).to_sql },
+    "block"    => -> { User.where { (:age >= 18) & ((:name == "alice") | (:name == "bob")) }.to_sql },
   },
 }
 
@@ -97,8 +97,8 @@ context = ActiveRecord::Refined::BlockContext.new
 syntax = ActiveRecord::Refined::BlockSyntax
 
 {
-  "simple equality" => proc { :name == "matz" },
-  "compound AND/OR" => proc { (:age >= 18) & ((:name == "matz") | (:name == "nobu")) },
+  "simple equality" => proc { :name == "alice" },
+  "compound AND/OR" => proc { (:age >= 18) & ((:name == "alice") | (:name == "bob")) },
 }.each do |label, blk|
   refined = blk.refined(syntax)
   context.instance_exec(&refined) # the copy is made here, on the first call
@@ -115,7 +115,7 @@ puts "1000 more calls from the same call site copied #{iseq_count.call - before}
 
 puts
 puts "=== where the block path spends its time ==="
-block = proc { :name == "matz" }
+block = proc { :name == "alice" }
 refined_block = block.refined(ActiveRecord::Refined::BlockSyntax)
 context = ActiveRecord::Refined::BlockContext.new
 Benchmark.ips do |x|

data/examples/ctes.rb

@@ -31,23 +31,54 @@ Product.create!(name: 'apple', category_id: groceries.id, price: 2)
 
 # 1. Recursive CTE: every category below 'electronics', itself included.
 #    The recursive member joins the CTE by name, so its ON clause is a block
-#    rather than the string join Rails' own documentation reaches for.  `from`
-#    then selects the CTE under the model's table name, which is what lets
-#    Category's own columns resolve against it.
+#    rather than the string join Rails' own documentation reaches for.
+#    `from_cte` then selects the CTE under the model's table name.
+#
+#    That alias is ActiveRecord's requirement rather than SQL's: by hand the
+#    last line would be `SELECT * FROM tree`.  ActiveRecord keeps qualifying
+#    columns with the model's table name, so without it `where` and `find_by`
+#    look for a table the query does not have.  `count`, `order` and `select`
+#    never qualify and would work either way, which makes it easy to miss.
 subtree =
   Category.with_recursive(
     tree: [
       Category.where { :id == electronics.id },
       Category.joins(:tree) { :categories[:parent_id] == :tree[:id] },
     ]
-  ).from(:tree, as: :categories)
+  ).from_cte(:tree)
 
 puts '--- 1. Recursive CTE walking a category tree ---'
 puts subtree.to_sql
 puts subtree.order { :name }.pluck(:name).inspect
 puts
 
-# 2. The same CTE as a subquery: products anywhere under 'electronics'.
+# 2. One walk over every tree, carrying down where each row started and how
+#    far it has come.  Which tree is wanted is then an ordinary `where`, asked
+#    afterwards, so the CTE is not rebuilt for each root.  0 is a value rather
+#    than SQL: at the top of a select list a bare string would be SQL, so
+#    numbers say `.as` directly and anything else says `value(...).as`.
+forest =
+  Category.with_recursive(
+    tree: [
+      Category.where { :parent_id.null? }.
+        select { [:id, :name, :parent_id, :id.as(:root_id), 0.as(:depth)] },
+      Category.joins(:tree) { :categories[:parent_id] == :tree[:id] }.
+        select { [:categories[:id], :categories[:name], :categories[:parent_id],
+                  :tree[:root_id], (:tree[:depth] + 1).as(:depth)] },
+    ]
+  ).from_cte(:tree).order { [:depth, :id] }
+
+puts '--- 2. Recursive CTE carrying the root and the depth down ---'
+puts forest.to_sql
+puts forest.map {|c| [c.name, c.root_id, c.depth] }.inspect
+
+# The alias from_cte puts on the CTE is what lets this `where` qualify
+# root_id; without it the column would be looked for in a table the query no
+# longer has.
+puts forest.where { :root_id == electronics.id }.map {|c| [c.name, c.depth] }.inspect
+puts
+
+# 3. The same CTE as a subquery: products anywhere under 'electronics'.
 #    The outer query joins the CTE by name like any other table.
 products_below =
   Product.with_recursive(
@@ -57,12 +88,12 @@ products_below =
     ]
   ).joins(:tree) { :tree[:id] == :products[:category_id] }
 
-puts '--- 2. Recursive CTE joined from the outer query ---'
+puts '--- 3. Recursive CTE joined from the outer query ---'
 puts products_below.to_sql
 puts products_below.order { :name }.pluck(:name).inspect
 puts
 
-# 3. A plain CTE, named once and used twice: categories that hold something
+# 4. A plain CTE, named once and used twice: categories that hold something
 #    expensive, and the count of products in each.
 expensive =
   Category.with(pricey: Product.where { :price >= 100 }).
@@ -76,7 +107,7 @@ expensive =
       ]
     }
 
-puts '--- 3. Plain CTE joined and aggregated ---'
+puts '--- 4. Plain CTE joined and aggregated ---'
 puts expensive.to_sql
 puts expensive.map {|c| [c.category, c.pricey_count, c.top_price] }.inspect
 puts

data/examples/predicates.rb

@@ -16,11 +16,11 @@ Setup.new.up
 class Account < ActiveRecord::Base
 end
 
-Account.create!(login: 'matz',       country: 'JP', age: 60)
-Account.create!(login: 'nobu',       country: 'JP', age: 50)
-Account.create!(login: 'tenderlove', country: 'US', age: 45)
-Account.create!(login: '100%_pure',  country: nil,  age: 30)
-Account.create!(login: '1002000',    country: 'US', age: 25)
+Account.create!(login: 'alice',     country: 'JP', age: 60)
+Account.create!(login: 'bob',       country: 'JP', age: 50)
+Account.create!(login: 'carol',     country: 'US', age: 45)
+Account.create!(login: '100%_pure', country: nil,  age: 30)
+Account.create!(login: '1002000',   country: 'US', age: 25)
 
 def show(title, relation, rows)
   puts "--- #{title} ---"
@@ -63,12 +63,12 @@ show('distinct_from? keeps NULLs, != drops them',
 #    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?('%love') },
-  Account.where { :login.like?('%love') }.pluck(:login))
+  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?('ma', 'no') },
-  Account.where { :login.start_with?('ma', 'no') }.pluck(:login))
+  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
@@ -83,8 +83,8 @@ show('include? escapes wildcards; like? does not',
 # 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?('MaTz') },
-  Account.where { :login.casecmp?('MaTz') }.pluck(:login))
+  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.

data/examples/subqueries.rb

@@ -24,13 +24,13 @@ class Post < ActiveRecord::Base
   def self.published = where { :published == true }
 end
 
-matz  = Author.create!(name: 'matz')
-nobu  = Author.create!(name: 'nobu')
+alice  = Author.create!(name: 'alice')
+bob  = Author.create!(name: 'bob')
 quiet = Author.create!(name: 'quiet')
 
-Post.create!(title: 'refinements', author_id: matz.id, likes: 100, published: true)
-Post.create!(title: 'parser',      author_id: matz.id, likes: 40,  published: true)
-Post.create!(title: 'draft',       author_id: nobu.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} ---"