database_consistency 3.0.13 → 3.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c161f165c612d3196799c754ef057f0236c1bdcfd1bbd87d3c2fc0a2f28bc8
-  data.tar.gz: 1196509cb852b3a5ded62f8866b19f34ab6d9abc80af89d0806b08a25b779b56
+  metadata.gz: d104523d7460faf27ac7523f032b1802b140560870685207fecaac76bcf76367
+  data.tar.gz: 955b8cc5a9217e578d4a2a2d36a198eca615b11c0ac7e060382904229950fd5c
 SHA512:
-  metadata.gz: e4ba6f89c64740f04fa2a091fd5d137d4295b3884a9a24a524902e46ab20e80d5b7a76db77de59d1e8b214ef656724da103154169bbc99dada06eb6e1f150a26
-  data.tar.gz: 618299c5d08832c05120596316c919526ee72b6646272b10dfa624d98a47021931a5f3baa439906305ec615cc3ed7e2f31e55c963891355ffe2fbf244b07c622
+  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,30 @@ 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(
+      Regexp.escape(LITERAL_PLACEHOLDER).sub('%<index>d') { '\d+' }
+    ).freeze
+
+    # Matches an operator together with whatever spaces were written around it.
+    # `+` and `-` are left out: either can be a sign as well as an operator, and
+    # telling the two apart takes a parser. `->` and `->>` are the exception,
+    # since neither can be read as a sign.
+    CONDITION_OPERATOR = %r{\s*(->>?|[<>=!~@#%^&|?*/]+)\s*}.freeze
+
+    # Matches either of the two, so the spacing step can find operators while
+    # passing over the placeholders.
+    MASKED_LITERAL_OR_OPERATOR = Regexp.union(MASKED_LITERAL, CONDITION_OPERATOR).freeze
+
     # Matches a number PostgreSQL had to quote in order to coerce it, together
     # with the cast that says it is a number rather than a string. `::text` is
     # deliberately absent from the list so a genuine string keeps its quotes.
@@ -244,7 +266,9 @@ module DatabaseConsistency
     IN_LIST_OPENING = /(?<!\bIN\s)/i.freeze
 
     # Matches a bare identifier wrapped in parentheses, e.g. `(internal_name)`.
-    WRAPPED_IDENTIFIER = /#{IN_LIST_OPENING}\(([a-z_][\w.]*)\)/i.freeze
+    # The lookbehind keeps the argument list of a call such as `lower(name)`
+    # intact.
+    WRAPPED_IDENTIFIER = /(?<![\w.])#{IN_LIST_OPENING}\(([a-z_][\w.]*)\)/i.freeze
 
     # Matches a parenthesized numeric literal, e.g. `(0)` or `(0.001)`, which is
     # what a cast such as `(0)::numeric` leaves behind once the cast is gone.
@@ -262,20 +286,26 @@ module DatabaseConsistency
 
     # Matches a bare negated boolean predicate such as `NOT archived`, in the
     # three places one can stand: at the start of an expression, after `AND` or
-    # `OR`, or after an opening parenthesis.
+    # `OR`, or after an opening parenthesis. The whitespace before whatever
+    # follows sits inside the lookahead, so the match leaves it in place instead
+    # of consuming it and fusing the next `AND` / `OR` to the rewritten
+    # predicate. The lookbehind keeps a call's own parenthesis out of the
+    # boolean positions, so the argument of `lower(...)` is not read as a
+    # predicate of its own.
     NEGATED_BOOLEAN_PREDICATE = /
-      (^ | (?: \bAND\b | \bOR\b | \( ))
-      \s* NOT \s+ ([a-z_][\w.]*) \s*
-      (?= $ | (?: \bAND\b | \bOR\b | \) ))
+      (^ | (?: \bAND\b | \bOR\b | (?<![\w.]) \( ))
+      \s* NOT \s+ ([a-z_][\w.]*)
+      (?= \s* (?: $ | \bAND\b | \bOR\b | \) ))
     /xi.freeze
 
     # Matches a bare boolean predicate such as `most_recent` in those same three
-    # places. It runs after the negated form so that `NOT archived` is already
-    # gone and cannot be read as the predicate `archived`.
+    # places, with the same lookahead and lookbehind. It runs after the negated
+    # form so that `NOT archived` is already gone and cannot be read as the
+    # predicate `archived`.
     BARE_BOOLEAN_PREDICATE = /
-      (^ | (?: \bAND\b | \bOR\b | \( ))
-      \s* ([a-z_][\w.]*) \s*
-      (?= $ | (?: \bAND\b | \bOR\b | \) ))
+      (^ | (?: \bAND\b | \bOR\b | (?<![\w.]) \( ))
+      \s* ([a-z_][\w.]*)
+      (?= \s* (?: $ | \bAND\b | \bOR\b | \) ))
     /xi.freeze
 
     # Matches `column = ANY (ARRAY[...])` or `column != ALL ((ARRAY[...]))`,
@@ -297,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)
@@ -309,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
       )
@@ -320,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) }
@@ -333,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|
@@ -344,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
@@ -442,11 +492,23 @@ module DatabaseConsistency
       "#{sign}#{expanded}".sub(/(\.\d*?)0+\z/, '\1').chomp('.')
     end
 
+    # Gives every operator a space either side, every comma a space after it
+    # and no parenthesis a space on its inside, which is how PostgreSQL writes
+    # an indexdef however the index was typed.
+    def normalize_operator_spacing(sql)
+      spaced_sql = sql.gsub(MASKED_LITERAL_OR_OPERATOR) do |match|
+        match.match?(MASKED_LITERAL) ? match : " #{match.strip} "
+      end
+      spaced_sql = spaced_sql.gsub(/\s*,\s*/, ', ')
+      spaced_sql.gsub(/\(\s+/, '(').gsub(/\s+\)/, ')')
+    end
+
     # Rewrites the spellings that differ between adapters, or between what an
     # adapter stores and what Active Record writes: quoted identifiers, casts,
-    # exponent notation, the spacing of an `IN` list, the parentheses PostgreSQL
-    # adds around a cast operand and the `<>` it writes for inequality. Literals are masked throughout, so
-    # none of it reaches the inside of a value.
+    # exponent notation, the spacing of an `IN` list, of operators and of
+    # commas, the parentheses PostgreSQL adds around a cast operand and the `<>`
+    # it writes for inequality. Literals are masked throughout, so none of it
+    # reaches the inside of a value.
     def normalize_adapter_syntax(sql)
       # Strips quoted identifiers (double quotes on PostgreSQL/SQLite,
       # backticks on MySQL) so the same column normalizes across adapters.
@@ -457,9 +519,11 @@ module DatabaseConsistency
       # reach the same string and the list is recognisable to the unwrappers
       # below. `\b` keeps a call such as `min(1)` out of it.
       normalized_sql = normalized_sql.gsub(/\bIN\s*\(/i, 'IN (')
+      normalized_sql = normalize_operator_spacing(normalized_sql)
       normalized_sql = unwrap_redundant_parentheses(normalized_sql)
-      # `/\s*<>\s*/` rewrites the SQL inequality operator `<>` to `!=`.
-      normalized_sql = normalized_sql.gsub(/\s*<>\s*/, ' != ')
+      # Rewrites the SQL inequality operator `<>` to `!=`; the spacing step
+      # has already given it a space either side.
+      normalized_sql = normalized_sql.gsub('<>', '!=')
       normalized_sql.gsub(/\s+/, ' ').strip
     end
 
@@ -477,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
-
-      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
+    # 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
 
-    # 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
 
@@ -550,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.13'
+  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.13
+  version: 3.0.15
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-22 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