database_consistency 3.0.14 → 3.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0599ad1c39057b6a4ec4bb2c60938454a92296906258cda66b5b9f47081447e
-  data.tar.gz: 77d57bb76d65535e3dea3dfa88d8b5efcce14a230682ee472fd26a1f605c619a
+  metadata.gz: d104523d7460faf27ac7523f032b1802b140560870685207fecaac76bcf76367
+  data.tar.gz: 955b8cc5a9217e578d4a2a2d36a198eca615b11c0ac7e060382904229950fd5c
 SHA512:
-  metadata.gz: 9cffcfa84c2731c584788352910c712f9947cc4fcdc73f24bb68128889f6ec0674accdef8d2390d113fb4f16c7e37e5c859dd09fe649d75b2be04b4964fc10c3
-  data.tar.gz: 3fc92238031f7e9e3611179a5fcad66b8105374eaa799416ae426248a9f88b7baafd61642e98a2eb03d3db0d591cf241d7515388f309b058dca2c20fd04d783d
+  metadata.gz: 652477c0b3c936abbd3f443fad7de53331339a012d229939e61c204d3e60c03a55c3c5eb741aa5aaf5e4dd8d0ac03865e7a4ed80d58d37f85bf2e885eeaf163e
+  data.tar.gz: 657642ff01a583796083f8030a42cd0411b641ebe1fa624872f7467506815a15199493e4cc5765d300e58d65257f93a9cb8b8239a13302e46bffc87dc699124c

data/lib/database_consistency/helper/and_clauses.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Helper
+    # The `AND` clauses of a SQL predicate: which `AND`s actually join two
+    # clauses, and what the clause list looks like once nested conjunctions have
+    # been flattened into it.
+    module AndClauses
+      module_function
+
+      # Sorts top-level clauses so `a AND b` and `b AND a` reach the same string
+      # before comparison. Clauses are kept verbatim so parentheses binding an
+      # `OR` survive. The block, when given, supplies the value each clause is
+      # ordered by, which lets a caller order by a clause's real text while the
+      # clauses themselves still carry masked literals.
+      def sort(sql, &sort_key)
+        return sql if top_level_or?(sql)
+
+        clauses = split(sql)
+        return sql if clauses.length == 1
+
+        clauses.sort_by { |clause| sort_key ? sort_key.call(clause) : clause }.join(' AND ')
+      end
+
+      # `a AND b OR c` means `(a AND b) OR c`, so ordering the clauses of such a
+      # predicate would move one across the `OR` and change what it means.
+      # Active Record's `or` generates exactly this shape. A predicate carrying
+      # one is left alone; `split` assumes a conjunction and is not asked.
+      def top_level_or?(sql)
+        depth = 0
+
+        sql.scan(/[()]|\bOR\b/i) do |token|
+          case token
+          when '(' then depth += 1
+          when ')' then depth -= 1
+          else return true if depth.zero?
+          end
+        end
+
+        false
+      end
+
+      # Splits on the `AND`s that actually join two clauses: one inside a
+      # parenthesized group, or the one completing a `BETWEEN` range, belongs to
+      # its clause instead. A group whose own top level is a conjunction is
+      # flattened, so `a AND (b AND c)` and `a AND b AND c` split the same way.
+      def split(sql)
+        sql.split(/\s+AND\s+/i)
+           .each_with_object([]) { |fragment, clauses| append_fragment(clauses, fragment) }
+           .flat_map { |clause| flatten_group(clause) }
+      end
+
+      # Starts a new clause, or hands the fragment to the previous clause when
+      # that one is still waiting for the rest of itself.
+      def append_fragment(clauses, fragment)
+        previous = clauses.pop if clauses.last && incomplete?(clauses.last)
+
+        clauses << [previous, fragment].compact.join(' AND ')
+      end
+
+      # A clause is incomplete while it holds an unclosed parenthesis, or a
+      # `BETWEEN` whose range is still missing the `AND` that ends it.
+      def incomplete?(clause)
+        Parentheses.unclosed?(clause) ||
+          clause.scan(/\bBETWEEN\b/i).length > clause.scan(/\bAND\b/i).length
+      end
+
+      # `a AND (b AND c)` means `a AND b AND c`, so a group whose top level is a
+      # conjunction is flattened into the surrounding clause list. An `OR`
+      # nested deeper inside it stays in its own group and is split around.
+      def flatten_group(clause)
+        inner = Parentheses.strip_outer(clause)
+        return [clause] if inner == clause || top_level_or?(inner)
+
+        split(inner)
+      end
+    end
+  end
+end

data/lib/database_consistency/helper/parentheses.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Helper
+    # Parenthesis bookkeeping for SQL predicates: what a pair of parentheses
+    # encloses, and whether a fragment is still waiting for one to close.
+    module Parentheses
+      module_function
+
+      # Repeatedly removes one wrapping layer when the whole fragment is
+      # enclosed, e.g. `((foo))` -> `foo`.
+      def strip_outer(sql)
+        stripped_sql = sql.strip
+
+        stripped_sql = stripped_sql[1..-2].strip while wrapping?(stripped_sql)
+
+        stripped_sql
+      end
+
+      # Returns true only when one outer pair encloses the whole string, not
+      # when that parenthesis closes earlier inside the expression.
+      def wrapping?(sql)
+        return false unless sql.start_with?('(') && sql.end_with?(')')
+
+        depth = 0
+
+        sql[1..-2].each_char do |char|
+          depth = depth_after(depth, char)
+          return false if depth.negative?
+        end
+
+        depth.zero?
+      end
+
+      # Returns true while the fragment opens a group it never closes.
+      def unclosed?(sql)
+        sql.count('(') > sql.count(')')
+      end
+
+      # Tracks nesting depth character by character.
+      def depth_after(depth, char)
+        case char
+        when '('
+          depth + 1
+        when ')'
+          depth - 1
+        else
+          depth
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/helper.rb

@@ -167,12 +167,10 @@ module DatabaseConsistency
     # `attribute IS NOT NULL` clause and never match the partial index.
     def uniqueness_validator_where_sql(model, attribute, validator)
       conditions_sql = conditions_where_sql(model, validator.options[:conditions])
-      guard_sql = conditions_sql ? nil : uniqueness_validator_guard_sql(model, attribute, validator)
+      return conditions_sql.presence if conditions_sql
 
-      sql_parts = [conditions_sql, guard_sql].reject { |part| part.nil? || part == '' }
-      return nil if sql_parts.empty?
-
-      normalize_condition_sql(sql_parts.join(' AND '))
+      guard_sql = uniqueness_validator_guard_sql(model, attribute, validator)
+      normalize_condition_sql(guard_sql) if guard_sql
     end
 
     # Returns true when validator conditions and index WHERE clause are a valid
@@ -199,6 +197,14 @@ module DatabaseConsistency
     # rather than the end of it.
     CONDITION_LITERAL = /'(?:[^']|'')*'/.freeze
 
+    # Matches a quoted identifier spelled like a keyword the normalizer reads,
+    # such as a column named `"or"`. Once its quotes were stripped it would read
+    # as the keyword, so it is renamed to an identifier-shaped placeholder
+    # instead and written back in double quotes at the end, which keeps the
+    # result the same when it is normalized again.
+    KEYWORD_IDENTIFIER = /["`](and|or|not|between|in|is|null|true|false)["`]/i.freeze
+    KEYWORD_IDENTIFIER_PLACEHOLDER = /__database_consistency_identifier_(\w+?)__/.freeze
+
     # Matches a masked literal, so steps that run on masked SQL can step over
     # the `<` and `>` in the placeholder.
     MASKED_LITERAL = Regexp.new(
@@ -321,6 +327,21 @@ module DatabaseConsistency
       \)? \s* \)
     /xi.freeze
 
+    # Matches one bound of a `BETWEEN` range: a number, a masked literal or a
+    # column.
+    BETWEEN_BOUND = /-?\d+(?:\.\d+)?(?:e[+-]?\d+)?|#{MASKED_LITERAL.source}|[a-z_][\w.]*/i.freeze
+
+    # Matches an inclusive range over a lone column, in the same three places
+    # as a bare boolean predicate, capturing the column and both bounds. A range
+    # over an expression, or with any other kind of bound, is left unmatched.
+    # A bare `NOT` is not one of the places, because it negates the whole range.
+    BETWEEN_RANGE = /
+      (^ | (?: \bAND\b | \bOR\b | (?<![\w.]) \( ))
+      \s* ([a-z_][\w.]*)
+      \s+ BETWEEN \s+ (#{BETWEEN_BOUND}) \s+ AND \s+ (#{BETWEEN_BOUND})
+      (?= \s* (?: $ | \bAND\b | \bOR\b | \) ))
+    /xi.freeze
+
     # Normalizes SQL predicates into a canonical form so semantically equivalent
     # Rails validators and database partial indexes can be compared safely.
     def normalize_condition_sql(sql)
@@ -333,7 +354,7 @@ module DatabaseConsistency
                                 .then { |value| mask_condition_literals(value) }
 
       normalize_masked_condition_sql(
-        masked_sql.then { |value| strip_outer_parentheses(value) }
+        masked_sql.then { |value| Parentheses.strip_outer(value) }
                   .then { |value| normalize_boolean_and_null_keywords(value) },
         literals
       )
@@ -344,9 +365,10 @@ module DatabaseConsistency
     # final structural clean-ups, and only then restores the literal values.
     # Restoring last protects literal contents from whitespace collapse and
     # clause sorting.
-    def normalize_masked_condition_sql(masked_sql, literals)
+    def normalize_masked_condition_sql(masked_sql, literals) # rubocop:disable Metrics/AbcSize
       masked_sql
         .then { |value| normalize_adapter_syntax(value) }
+        .then { |value| expand_between_ranges(value) }
         .then { |value| normalize_boolean_predicates(value) }
         .then { |value| normalize_array_any_predicates(value) }
         .then { |value| normalize_negated_blank_or_nil_predicates(value) }
@@ -357,7 +379,8 @@ module DatabaseConsistency
 
     # Masks non-empty string literals so later regexes cannot rewrite their
     # contents. Empty literals are left untouched because negated-blank
-    # normalization relies on them.
+    # normalization relies on them. A quoted identifier spelled like a keyword
+    # is masked too, as described at `KEYWORD_IDENTIFIER`.
     def mask_condition_literals(sql)
       literals = []
       masked_sql = sql.gsub(CONDITION_LITERAL) do |match|
@@ -368,16 +391,19 @@ module DatabaseConsistency
           format(LITERAL_PLACEHOLDER, index: literals.length - 1)
         end
       end
+      masked_sql = masked_sql.gsub(KEYWORD_IDENTIFIER) { "__database_consistency_identifier_#{Regexp.last_match(1)}__" }
       [masked_sql, literals]
     end
 
     # Restores literals in the order they were masked. Uses a block replacement
     # so backslashes inside the literal are not interpreted as regexp backrefs.
+    # A masked keyword identifier comes back in double quotes, whichever quote
+    # it was written with.
     def unmask_condition_literals(sql, literals)
       literals.each_with_index do |literal, index|
         sql = sql.sub(format(LITERAL_PLACEHOLDER, index: index)) { literal }
       end
-      sql
+      sql.gsub(KEYWORD_IDENTIFIER_PLACEHOLDER, '"\1"')
     end
 
     # PostgreSQL writes any literal it had to coerce as a quoted string with a
@@ -515,40 +541,15 @@ module DatabaseConsistency
       normalized_sql
     end
 
-    # Repeatedly removes one wrapping layer of parentheses when the whole SQL
-    # fragment is enclosed, e.g. `((foo))` -> `foo`.
-    def strip_outer_parentheses(sql)
-      stripped_sql = sql.strip
+    # Writes an inclusive range out as the two comparisons PostgreSQL stores it
+    # as, so `qty BETWEEN 1 AND 10` lines up with `(qty >= 1) AND (qty <= 10)`.
+    # It runs before boolean predicates are read, so a bound that is a column
+    # is not mistaken for one.
+    def expand_between_ranges(sql)
+      sql.gsub(BETWEEN_RANGE) do
+        prefix, column, lower, upper = Regexp.last_match.captures
 
-      stripped_sql = stripped_sql[1..-2].strip while wrapped_with_parentheses?(stripped_sql)
-
-      stripped_sql
-    end
-
-    # Returns true only when the string is entirely wrapped by one outer pair of
-    # parentheses, not when parentheses close earlier inside the expression.
-    def wrapped_with_parentheses?(sql)
-      return false unless sql.start_with?('(') && sql.end_with?(')')
-
-      depth = 0
-
-      sql[1..-2].each_char do |char|
-        depth = parenthesis_depth(depth, char)
-        return false if depth.negative?
-      end
-
-      depth.zero?
-    end
-
-    # Tracks parenthesis nesting depth character by character.
-    def parenthesis_depth(depth, char)
-      case char
-      when '('
-        depth + 1
-      when ')'
-        depth - 1
-      else
-        depth
+        "#{prefix} #{column} >= #{lower} AND #{column} <= #{upper}"
       end
     end
 
@@ -588,20 +589,18 @@ module DatabaseConsistency
       end
     end
 
-    # Sorts simple `AND` clauses so `a AND b` and `b AND a` normalize to the
-    # same string before comparison. Two clauses can be identical apart from the
+    # Sorts the `AND` clauses so `a AND b` and `b AND a` normalize to the same
+    # string before comparison. Two clauses can be identical apart from the
     # string each one compares against, and then those strings decide the order,
     # which is why the literals go back in before the sort. A placeholder is
     # numbered by where its literal appeared, so sorting on the placeholders
-    # would leave such a pair in whichever order it arrived in.
+    # would leave such a pair in whichever order it arrived in. A column named
+    # like a keyword is ordered by its bare name, so its quotes do not move it
+    # ahead of every other clause.
     def sort_and_clauses(sql, literals)
-      # Matches `AND` with surrounding whitespace and splits the expression into
-      # comparable clause fragments.
-      clauses = sql.split(/\s+AND\s+/i)
-      return sql if clauses.length == 1
-
-      clauses.map! { |clause| strip_outer_parentheses(clause) }
-      clauses.sort_by { |clause| unmask_condition_literals(clause, literals) }.join(' AND ')
+      AndClauses.sort(sql) do |clause|
+        unmask_condition_literals(clause.gsub(KEYWORD_IDENTIFIER_PLACEHOLDER, '\1'), literals)
+      end
     end
 
     # Builds the implicit SQL guard introduced by validator options that skip

data/lib/database_consistency/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  VERSION = '3.0.14'
+  VERSION = '3.0.15'
 end

data/lib/database_consistency.rb

@@ -4,6 +4,8 @@ require 'active_record'
 
 require 'database_consistency/version'
 require 'database_consistency/helper'
+require 'database_consistency/helper/parentheses'
+require 'database_consistency/helper/and_clauses'
 require 'database_consistency/files_helper'
 require 'database_consistency/prism_helper'
 require 'database_consistency/configuration'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 3.0.14
+  version: 3.0.15
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -186,6 +186,8 @@ files:
 - lib/database_consistency/errors.rb
 - lib/database_consistency/files_helper.rb
 - lib/database_consistency/helper.rb
+- lib/database_consistency/helper/and_clauses.rb
+- lib/database_consistency/helper/parentheses.rb
 - lib/database_consistency/prism_helper.rb
 - lib/database_consistency/processors/associations_processor.rb
 - lib/database_consistency/processors/base_processor.rb