unreliable 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e32845f793b8cf8d2200fad74d279a8a49a9d9cd2667628dec2be952f9853f7
-  data.tar.gz: b3d7922e822f5c81d816c6860efdec1e7375921f33c37ca80428587f0179aa19
+  metadata.gz: 03cacbb1f651eeac84c72fe0534624779978b5c954f9e0612c89784555c1b0bb
+  data.tar.gz: b2157f68e867d7ba3ced7b0bb4bc4d0dbad964cfdbe229d915a8080e84a2fd8c
 SHA512:
-  metadata.gz: 847f0641314a2f5c7270fb8550a5326a2912a8a58b3dedee183853cfa0fb5a8b4af6f8dffbb898fd9c183a22a3976aaca2a99c9fb215a73b1464b2f5cf60f65b
-  data.tar.gz: 68f3009ddaf290b01cfb1ec04d9012eb95d9bc5069f7c5ef6e4d0cc5a1a04b5b366ad67235f48ee3193cea798828cc353ec35bb7b93ebee3cb4bddc3a4b5581f
+  metadata.gz: e037706c73288b463555844acbcf70ba73c03416d28252c32c2ceb26280bda10898d55270fbde8c650fc60bad1cf21f1a5ef049d6cad8d7c0cd15a4ca01c7cfa
+  data.tar.gz: f9fd9946c411f6691e645626d186ec79a856f7007aedd2becfed8d6bfac25ad04f1e319fd00b26ad1ecb3c3b67870a88c3bd4b102ff8b05b323fcfe0fc620d1a

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## Unreliable 1.0.2 (July 22, 2026) ##
+
+### Fixed
+
+* Postgres bugfix when using textual DISTINCT
+* Postgres bugfix when using computed columns
+
 ## Unreliable 1.0.1 (June 4, 2026) ##
 
 ### Changed

data/lib/unreliable/build_order.rb

@@ -37,13 +37,23 @@ module Unreliable
     end
 
     def distinct_on_postgres?(adapter_name)
-      distinct_value && adapter_name == "PostgreSQL"
+      distinct_query? && adapter_name == "PostgreSQL"
     end
 
     def distinct_on_sqlserver?(adapter_name)
       # SQL Server rejects ORDER BY expressions not in the select list when
       # DISTINCT is used, so we don't append NEWID() to DISTINCT queries.
-      distinct_value && adapter_name == "SQLServer"
+      distinct_query? && adapter_name == "SQLServer"
+    end
+
+    def distinct_query?
+      # `.distinct` sets distinct_value, but a raw "DISTINCT ..." / "DISTINCT ON (...)"
+      # written into `.select` does not. SQL only allows a statement-level DISTINCT as
+      # the leading keyword of the select clause, so we detect it at the start of a
+      # select fragment (an aggregate's inner `count(DISTINCT x)` is never at the start).
+      # A false positive only forgoes randomization; a miss would append an ORDER BY that
+      # PostgreSQL and SQL Server reject for DISTINCT queries.
+      distinct_value || select_values.any? { |value| value.to_s.match?(/\A\s*DISTINCT\b/i) }
     end
 
     def from_only_internal_metadata?(arel)
@@ -83,6 +93,7 @@ module Unreliable
       arel.orders
         .grep(Arel::Nodes::Ordering) # Don't try to parse textual orders
         .map(&:expr)
+        .grep(Arel::Attributes::Attribute) # Skip computed expressions
         .select { |expr| expr.relation.name == from_table_name }
         .map(&:name)
         .map(&:to_s) # In Rails < 5.2, the order column names are symbols; >= 5.2, strings

data/lib/unreliable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Unreliable
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/computed_order_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# An order can be a directional node (Ascending/Descending) wrapping a computed
+# expression rather than a plain column. Those wrappers survive the
+# Arel::Nodes::Ordering grep in order_columns, but their .expr is not an
+# Arel::Attributes::Attribute and has no .relation. The wrapped expr can be any
+# of several node classes -- a SqlLiteral, a NamedFunction, an aggregate, etc.
+# None of them can cover a primary key, so the query must be randomized (and
+# must not raise).
+#
+# Note: a plain string order like .order("name DESC") does NOT reach this code;
+# it becomes a bare SqlLiteral that the Ordering grep drops (see
+# textual_order_spec.rb). Only a *directional* node wrapping a non-column does.
+
+RSpec.describe "computed order" do
+  it "randomly selects when ordered by a string-key hash alias" do
+    # No explicit Arel -- the idiomatic hash form. "name_len" isn't a real column,
+    # so it becomes a quoted SqlLiteral identifier wrapped in a Descending node.
+    expect(Cat.order("name_len" => :desc).to_sql).to end_with(
+      adapter_rand('ORDER BY "name_len" DESC, RANDOM()')
+    )
+  end
+
+  it "randomly selects when ordered by a SqlLiteral with a direction" do
+    expect(Cat.order(Arel.sql("name_len").desc).to_sql).to end_with(
+      adapter_rand("ORDER BY name_len DESC, RANDOM()")
+    )
+  end
+
+  it "randomly selects when ordered by a function expression (NamedFunction)" do
+    expect(Cat.order(Cat.arel_table[:name].lower.desc).to_sql).to end_with(
+      adapter_rand('ORDER BY LOWER("cats"."name") DESC, RANDOM()')
+    )
+  end
+
+  it "randomly selects when ordered by an aggregate expression (Count)" do
+    expect(Cat.order(Cat.arel_table[:id].count.desc).to_sql).to end_with(
+      adapter_rand('ORDER BY COUNT("cats"."id") DESC, RANDOM()')
+    )
+  end
+
+  it "randomly selects when ordered by an arithmetic expression (Grouping)" do
+    # (attr + 1) is an Arel::Nodes::Grouping, which does not mix in .desc on
+    # ActiveRecord 5.2, so wrap it in a Descending node directly.
+    expect(Cat.order(Arel::Nodes::Descending.new(Cat.arel_table[:id] + 1)).to_sql).to end_with(
+      adapter_rand('ORDER BY ("cats"."id" + 1) DESC, RANDOM()')
+    )
+  end
+
+  it "randomly selects on a composite-PK table ordered by a computed expression" do
+    expect(Shelf.order(Arel.sql("LENGTH(contents)").asc).to_sql).to end_with(
+      adapter_rand("ORDER BY LENGTH(contents) ASC, RANDOM()")
+    )
+  end
+
+  it "does not randomize when the PK is covered even though a computed order is also present" do
+    # order_columns must still recognize the real "id" attribute after skipping
+    # the computed expression, so the covered-PK short-circuit still applies.
+    expect(Cat.order(:id).order(Arel.sql("LENGTH(name)").desc).to_sql).to end_with(
+      adapter_rand('ORDER BY "cats"."id" ASC, LENGTH(name) DESC')
+    )
+  end
+end

data/spec/select_distinct_raw_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# DISTINCT written as a raw string in .select (rather than via the .distinct
+# relation method) does not set distinct_value. Without detecting it, the gem
+# appends ORDER BY RANDOM(), which PostgreSQL and SQL Server reject:
+#
+#   for SELECT DISTINCT, ORDER BY expressions must appear in select list
+#   SELECT DISTINCT ON expressions must match initial ORDER BY expressions
+#
+# On MySQL and SQLite the appended random order is accepted, so -- as with the
+# .distinct relation method -- those adapters still get randomized.
+
+RSpec.describe "raw DISTINCT in select" do
+  it "does not append a randomizing order to a raw DISTINCT select on postgres/sqlserver" do
+    expect(Cat.select("DISTINCT name").to_sql).to end_with(
+      case UnreliableTest.find_adapter
+      when "postgresql", "sqlserver"
+        adapter_quotes('DISTINCT name FROM "cats"')
+      else
+        adapter_rand("ORDER BY RANDOM()")
+      end
+    )
+  end
+
+  it "does not append a randomizing order to a raw DISTINCT ON select on postgres",
+    skip: ((UnreliableTest.find_adapter == "postgresql") ? false : "DISTINCT ON is PostgreSQL-only syntax") do
+    expect(Cat.select("DISTINCT ON (name) *").to_sql).to end_with(
+      adapter_rand('SELECT DISTINCT ON (name) * FROM "cats"')
+    )
+  end
+
+  it "still detects DISTINCT written in lowercase" do
+    expect(Cat.select("distinct name").to_sql).to end_with(
+      case UnreliableTest.find_adapter
+      when "postgresql", "sqlserver"
+        adapter_quotes('distinct name FROM "cats"')
+      else
+        adapter_rand("ORDER BY RANDOM()")
+      end
+    )
+  end
+
+  it "does not treat an aggregate's inner DISTINCT as a statement-level DISTINCT" do
+    # count(DISTINCT ...) is not a SELECT DISTINCT, so the query must still be randomized.
+    expect(Cat.select("count(DISTINCT name) AS n").to_sql).to end_with(
+      adapter_rand("ORDER BY RANDOM()")
+    )
+  end
+
+  it "executes a raw DISTINCT select without a server error" do
+    expect { Cat.select("DISTINCT name").load }.not_to raise_error
+  end
+
+  it "executes a raw DISTINCT ON select without a server error",
+    skip: ((UnreliableTest.find_adapter == "postgresql") ? false : "DISTINCT ON is PostgreSQL-only syntax") do
+    expect { Cat.select("DISTINCT ON (name) *").load }.not_to raise_error
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unreliable
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - James McCarthy
@@ -69,6 +69,7 @@ files:
 - lib/unreliable/railtie.rb
 - lib/unreliable/version.rb
 - spec/adapter_option_spec.rb
+- spec/computed_order_spec.rb
 - spec/config_disable_nesting_spec.rb
 - spec/config_thread_safety_spec.rb
 - spec/env_spec.rb
@@ -95,6 +96,7 @@ files:
 - spec/model_update_arel_10_spec.rb
 - spec/pluck_exists_aggregate_spec.rb
 - spec/railtie_spec.rb
+- spec/select_distinct_raw_spec.rb
 - spec/spec_helper.rb
 - spec/textual_order_raw_spec.rb
 - spec/textual_order_spec.rb
@@ -119,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: For ActiveRecord tests, surface ambiguous-ordering bugs
 test_files: []