ridgepole 3.2.2 → 3.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa8b60187f54d3f6f510aae6326606c4d0885c3867cc48c6b51d27fd5ac1c5e1
-  data.tar.gz: 5c52635dff367490eeb5ebda435ea26e4c90f784ef4036c21fb6d58865b93674
+  metadata.gz: 30883571738ca7fb36863b862ea2c3c447dd2b557065c60c1c1a21a66beddb42
+  data.tar.gz: 425b7bc6cc0f9efffa9ea3b02fe681db1a242d1d2b41fcceee2d463082a7c866
 SHA512:
-  metadata.gz: 54c4b813601a1bc68891456a7d95ab41641dc63270ca22b0652f06d6757d49b6740a6c0738cc3f5f28c69c5d80c22bd2ecb0b7e7d7de12e6c321f591b95db6cd
-  data.tar.gz: df2418e5c2bb8ebfe5759c04d3656e524f3b94e995ba24c67f6e74629bdce00667c324d0265433a7333b335ab9245b133c5212a5f0dc282a57692bb6c83b41cf
+  metadata.gz: 6e716a0ade803f5ae29aec8f861f06009aaec35274fcc4fbb28984525d956ca7c2a4681700938ce04906f1e192e6acf4838cbf37c50739b15d75c88743d7b4ba
+  data.tar.gz: 1a208c2dadeda2e1ccc0c250223f51351688b35b8046c5819998fe4249fb507e973b30310648fc12f3b7b84a4fb584771622fa91f2828eff57919b2a79f5ab70

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## 3.2
 
+### 3.2.4 (2026/08/08)
+
+- Fix inverted "No change" log in `--diff --with-apply`. [pull#730](https://github.com/ridgepole/ridgepole/pull/730)
+
+### 3.2.3 (2026/08/01)
+
+- Emit `validate_constraint` when DB is NOT VALID and DSL implies validated. [pull#718](https://github.com/ridgepole/ridgepole/pull/718)
+- Ignore `validate: false` diff when existing constraint lacks `:validate`. [pull#716](https://github.com/ridgepole/ridgepole/pull/716)
+
 ### 3.2.2 (2026/06/14)
 
 - Fix constraint removal order when dropping columns. [pull#705](https://github.com/ridgepole/ridgepole/pull/705)

data/README.md

@@ -1,4 +1,4 @@
-# Ridgepole
+![](https://github.com/user-attachments/assets/e446e211-054a-43d8-978b-c52ae6f1ea93)
 
 Ridgepole is a tool to manage DB schema.
 
@@ -10,17 +10,18 @@ It defines DB schema using [Rails DSL](http://guides.rubyonrails.org/migrations.
 [![codecov](https://codecov.io/gh/ridgepole/ridgepole/graph/badge.svg)](https://codecov.io/gh/ridgepole/ridgepole)
 
 > [!TIP]
-> Also developing similar declarative schema tools — single Go binary, plain SQL as the schema definition:
+> Also developing similar declarative schema tools — single Go binary, plain SQL as the schema definition. Give it a try.
 >
 > * [pistachio](https://github.com/winebarrel/pistachio): for PostgreSQL
-> * [myschema](https://github.com/winebarrel/myschema): for MySQL
 
 > [!warning]
 > The order of columns when exporting has changed in Rails 8.1. https://github.com/rails/rails/pull/53281
 >
 > If you do not want to sort the columns, use `--disable-sort-columns` option.
 
-> [!note]
+<details>
+<summary>Note</summary>
+
 > * ridgepole v3.2.0
 >   * Use `udiff` instead of `diffy` (cf. https://github.com/ridgepole/ridgepole/pull/657)
 > * ridgepole v3.1.0
@@ -49,6 +50,8 @@ It defines DB schema using [Rails DSL](http://guides.rubyonrails.org/migrations.
 >   * cf. https://github.com/rails/rails/commit/c2a6f618d22cca4d9b7be7fa7652e7aac509350c#diff-55f41513f027a3d219629f475f03c2d1105ca55c5093d691e1b3dc4710c6cc0b
 > * SQLite does not support.
 
+</details>
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -102,6 +105,7 @@ Usage: ridgepole [options]
         --drop-table-only
         --mysql-change-table-options
         --mysql-change-table-comment
+        --pg-change-table-comment
         --check-relation-type DEF_PK
         --ignore-table-comment
         --skip-column-comment-change
@@ -286,6 +290,26 @@ create_table "users", force: :cascade do |t|
 end
 ```
 
+## Functional Index (MySQL)
+
+MySQL 8.0.13 or later supports functional key parts, also known as expression
+indexes. MySQL normalizes these expressions when storing them, and Ridgepole
+compares the normalized expression with the one in your Schemafile. To avoid
+repeated diffs, use the expression produced by `ridgepole --export` in your
+Schemafile.
+
+```ruby
+create_table "users", force: :cascade do |t|
+  t.datetime "deleted_at"
+  t.string   "email", null: false
+  t.string   "name", null: false
+
+  t.index "(lower(`name`))", name: "index_users_on_lower_name"
+  t.index "(case when (`deleted_at` is null) then `email` else NULL end)",
+          name: "index_users_on_active_email", unique: true
+end
+```
+
 ## Execute
 ```ruby
 create_table "authors", force: :cascade do |t|

data/bin/ridgepole

@@ -290,7 +290,7 @@ begin
 
       differ, _out = delta.migrate if differ
 
-      logger.info('No change') if differ
+      logger.info('No change') unless differ
     elsif delta.differ?
       differ = noop_migrate(delta, options)
       exit_code = 1 if differ

data/lib/ridgepole/delta.rb

@@ -568,6 +568,10 @@ remove_index(#{table_name.inspect}, #{target})
       (delta[:add] || {}).each_value do |attrs|
         append_add_foreign_key(table_name, attrs, post_buf, options)
       end
+
+      (delta[:validate] || {}).each_value do |attrs|
+        append_validate_foreign_key(table_name, attrs, post_buf)
+      end
     end
 
     def append_add_foreign_key(table_name, attrs, buf, _options)
@@ -594,6 +598,21 @@ remove_foreign_key(#{table_name.inspect}, #{target})
     RUBY
     end
 
+    def append_validate_foreign_key(table_name, attrs, buf)
+      attrs_options = attrs[:options] || {}
+      fk_name = attrs_options[:name]
+
+      target = if fk_name
+                 "name: #{fk_name.inspect}"
+               else
+                 attrs.fetch(:to_table).inspect
+               end
+
+      buf.puts(<<-RUBY)
+validate_foreign_key(#{table_name.inspect}, #{target})
+      RUBY
+    end
+
     def append_change_check_constraints(table_name, delta, pre_buf, post_buf)
       (delta[:delete] || {}).each_value do |attrs|
         append_remove_check_constraint(table_name, attrs, pre_buf)
@@ -602,6 +621,10 @@ remove_foreign_key(#{table_name.inspect}, #{target})
       (delta[:add] || {}).each_value do |attrs|
         append_add_check_constraint(table_name, attrs, post_buf)
       end
+
+      (delta[:validate] || {}).each_value do |attrs|
+        append_validate_check_constraint(table_name, attrs, post_buf)
+      end
     end
 
     def append_add_check_constraint(table_name, attrs, buf, force_bulk_change = false)
@@ -628,6 +651,15 @@ remove_check_constraint(#{table_name.inspect}, #{expression.inspect}, **#{attrs_
       RUBY
     end
 
+    def append_validate_check_constraint(table_name, attrs, buf)
+      attrs_options = attrs[:options] || {}
+      name = attrs_options[:name]
+
+      buf.puts(<<-RUBY)
+validate_check_constraint(#{table_name.inspect}, name: #{name.inspect})
+      RUBY
+    end
+
     def append_change_exclusion_constraints(table_name, delta, pre_buf, post_buf)
       (delta[:delete] || {}).each_value do |attrs|
         append_remove_exclusion_constraint(table_name, attrs, pre_buf)

data/lib/ridgepole/diff.rb

@@ -524,13 +524,18 @@ module Ridgepole
         next if ignore_fk
 
         if from_attrs
-          if from_attrs != to_attrs
-            foreign_keys_delta[:add] ||= {}
-            foreign_keys_delta[:add][foreign_key_name_or_tables] = to_attrs
+          if from_attrs != to_attrs && !ignorable_validate_diff?(from_attrs, to_attrs)
+            if validate_only_diff?(from_attrs, to_attrs)
+              foreign_keys_delta[:validate] ||= {}
+              foreign_keys_delta[:validate][foreign_key_name_or_tables] = to_attrs
+            else
+              foreign_keys_delta[:add] ||= {}
+              foreign_keys_delta[:add][foreign_key_name_or_tables] = to_attrs
 
-            unless options[:merge]
-              foreign_keys_delta[:delete] ||= {}
-              foreign_keys_delta[:delete][foreign_key_name_or_tables] = from_attrs
+              unless options[:merge]
+                foreign_keys_delta[:delete] ||= {}
+                foreign_keys_delta[:delete][foreign_key_name_or_tables] = from_attrs
+              end
             end
           end
         else
@@ -558,12 +563,19 @@ module Ridgepole
         from_attrs = from.delete(name)
 
         if from_attrs
-          if normalize_check_constraint(from_attrs) != normalize_check_constraint(to_attrs)
-            check_constraints_delta[:add] ||= {}
-            check_constraints_delta[:add][name] = to_attrs
+          from_normalized = normalize_check_constraint(from_attrs)
+          to_normalized = normalize_check_constraint(to_attrs)
+          if from_normalized != to_normalized && !ignorable_validate_diff?(from_normalized, to_normalized)
+            if validate_only_diff?(from_normalized, to_normalized)
+              check_constraints_delta[:validate] ||= {}
+              check_constraints_delta[:validate][name] = to_attrs
+            else
+              check_constraints_delta[:add] ||= {}
+              check_constraints_delta[:add][name] = to_attrs
 
-            check_constraints_delta[:delete] ||= {}
-            check_constraints_delta[:delete][name] = from_attrs
+              check_constraints_delta[:delete] ||= {}
+              check_constraints_delta[:delete][name] = from_attrs
+            end
           end
         else
           check_constraints_delta[:add] ||= {}
@@ -587,6 +599,33 @@ module Ridgepole
       attr
     end
 
+    # 'validate: false' (NOT VALID) is a strategy for ALTER TABLE ADD CONSTRAINT to avoid
+    # ACCESS EXCLUSIVE lock on large tables. NOT VALID state itself is persisted by the DB,
+    # but PostgreSQL ignores NOT VALID for constraints created inline within CREATE TABLE, so
+    # whether the resulting constraint is NOT VALID depends on how it was created. Restoring
+    # NOT VALID via DROP + ADD has no benefit, so ignore the diff when the DB dump lacks
+    # :validate and the DSL specifies validate: false.
+    def ignorable_validate_diff?(from_attrs, to_attrs)
+      from_options = from_attrs[:options] || {}
+      to_options = to_attrs[:options] || {}
+      return false unless to_options[:validate] == false && !from_options.key?(:validate)
+
+      from_attrs == to_attrs.merge(options: to_options.except(:validate))
+    end
+
+    # Reverse of ignorable_validate_diff?: DB has a NOT VALID constraint (validate: false)
+    # and the DSL implies validated (:validate missing or true). Emit VALIDATE CONSTRAINT
+    # instead of DROP + re-ADD so the full-table scan runs under SHARE UPDATE EXCLUSIVE
+    # (concurrent DML allowed) rather than ACCESS EXCLUSIVE lock.
+    def validate_only_diff?(from_attrs, to_attrs)
+      from_options = from_attrs[:options] || {}
+      to_options = to_attrs[:options] || {}
+      return false unless from_options[:validate] == false && to_options[:validate] != false
+
+      from_attrs.merge(options: from_options.except(:validate)) ==
+        to_attrs.merge(options: to_options.except(:validate))
+    end
+
     def scan_exclusion_constraints_change(from, to, table_delta)
       from = (from || {}).dup
       to = (to || {}).dup

data/lib/ridgepole/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ridgepole
-  VERSION = '3.2.2'
+  VERSION = '3.2.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridgepole
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.2.4
 platform: ruby
 authors:
 - Genki Sugawara
@@ -245,14 +245,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.87.0
+        version: 1.88.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.87.0
+        version: 1.88.2
 - !ruby/object:Gem::Dependency
   name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement