pg_trunk 0.1.0

data/spec/operations/composite_types/change_composite_type_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+# frozen_text_literal: true
+
+describe ActiveRecord::Migration, "#change_composite_type" do
+  before_all { run_migration "create_schema :paint" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_composite_type "paint.colored_point" do |t|
+        t.column "x", "integer"
+        t.column "y", "integer"
+        t.column "color", "text", collation: "en_US"
+        t.comment "2D point with a color"
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT (10, -1, 'blue')::paint.colored_point" }
+
+  context "when new column is added" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.add_column "z", "integer"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.column "z", "integer"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT (10, -1, 'blue', 6)::paint.colored_point" }
+
+    its(:execution) { is_expected.to enable_sql_request(new_query) }
+    its(:execution) { is_expected.to disable_sql_request(old_query) }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(new_query) }
+    its(:inversion) { is_expected.to enable_sql_request(old_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when the column is dropped" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.drop_column "color", "text", collation: "en_US"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT (10, 11)::paint.colored_point" }
+
+    its(:execution) { is_expected.to enable_sql_request(new_query) }
+    its(:execution) { is_expected.to disable_sql_request(old_query) }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+
+    it { is_expected.to be_irreversible.because_of(/y/i) }
+  end
+
+  context "when an absent column is dropped without :if_exists option" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.drop_column "f"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "when an absent column is dropped with `if_exists: true` option" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.drop_column "f", if_exists: true
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.not_to change_schema }
+    it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+  end
+
+  context "when columns are renamed" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.rename_column "y", to: "z"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "z", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when columns are changed with :from options" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.change_column "x", "bigint", from_type: "integer"
+          t.change_column "y", "bigint", from_type: "integer"
+          t.change_column "color", "text", collation: "POSIX", from_type: "text", from_collation: "en_US"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "bigint"
+          t.column "y", "bigint"
+          t.column "color", "text", collation: "POSIX"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when columns are changed without :from options" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |t|
+          t.change_column "x", "bigint"
+          t.change_column "y", "bigint"
+          t.change_column "color", "text", collation: "POSIX"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "bigint"
+          t.column "y", "bigint"
+          t.column "color", "text", collation: "POSIX"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    it { is_expected.to be_irreversible }
+  end
+
+  context "when column is changed with `force: :cascade` option" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point", force: :cascade do |t|
+          t.change_column "x", "bigint", from_type: "integer"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "bigint"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    it { is_expected.to be_irreversible.because_of(/force: :cascade/) }
+  end
+
+  context "when comment is changed with :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |d|
+          d.comment "Colored 2D point", from: "2D point with a color"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "Colored 2D point"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when comment is changed without :from option" do
+    let(:migration) do
+      <<~RUBY
+        change_composite_type "paint.colored_point" do |d|
+          d.comment "Colored 2D point"
+        end
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "Colored 2D point"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+    it { is_expected.to be_irreversible.because_of(/comment/i) }
+  end
+
+  context "without changes" do
+    let(:migration) { 'change_composite_type "dict.us_postal_code"' }
+
+    it { is_expected.to fail_validation.because(/there are no changes/i) }
+  end
+end

data/spec/operations/composite_types/create_composite_type_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#create_composite_type" do
+  before_all { run_migration "create_schema :paint" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        create_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT (10, -1, 'blue')::paint.colored_point" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "without columns" do
+    let(:migration) do
+      <<~RUBY
+        create_composite_type "paint.nothing" do |t|
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+    let(:query) { "SELECT NULL::paint.nothing" }
+
+    its(:execution) { is_expected.to enable_sql_request(query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.to disable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        create_composite_type do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/composite_types/drop_composite_type_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_composite_type" do
+  before_all { run_migration "create_schema :paint" }
+  before { run_migration(snippet) }
+
+  let(:snippet) do
+    <<~RUBY
+      create_composite_type "paint.colored_point" do |t|
+        t.column "x", "integer"
+        t.column "y", "integer"
+        t.column "color", "text", collation: "en_US"
+        t.comment "2D point with a color"
+      end
+    RUBY
+  end
+  let(:query) { "SELECT (10, -1, 'blue')::paint.colored_point" }
+
+  context "with a full definition" do
+    let(:migration) do
+      <<~RUBY
+        drop_composite_type "paint.colored_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+          t.comment "2D point with a color"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+
+    its(:inversion) { is_expected.to enable_sql_request(query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a qualified name only" do
+    let(:migration) do
+      <<~RUBY
+        drop_composite_type "paint.colored_point"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "paint.colored_point"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(query) }
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+
+    its(:inversion) { is_expected.to remove(snippet).from_schema }
+    its(:inversion) { is_expected.to insert(new_snippet).into_schema }
+  end
+
+  context "when the type is used" do
+    before do
+      run_migration <<~RUBY
+        # The function depends on the composite type
+        create_function "make_red(p paint.colored_point) paint.colored_point",
+                        body: "SELECT (p.x, p.y, 'red')::paint.colored_point"
+      RUBY
+    end
+
+    context "without the `force` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_composite_type "paint.colored_point"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `force: :cascade` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_composite_type "paint.colored_point", force: :cascade
+        RUBY
+      end
+
+      its(:execution) { is_expected.to disable_sql_request(query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+      it { is_expected.to be_irreversible.because_of(/force: :cascade/i) }
+    end
+  end
+
+  context "when the type is absent without the `if_exists` option" do
+    let(:migration) do
+      <<~RUBY
+        drop_composite_type "foo"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to raise_error(StandardError) }
+  end
+
+  context "when the type is absent with the `if_exists: true` option" do
+    let(:migration) do
+      <<~RUBY
+        drop_composite_type "foo", if_exists: true
+      RUBY
+    end
+
+    its(:execution) { is_expected.not_to change_schema }
+    it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+  end
+end

data/spec/operations/composite_types/rename_composite_type_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_composite_type" do
+  before_all { run_migration "create_schema :paint" }
+  before { run_migration(old_snippet) }
+
+  let(:old_snippet) do
+    <<~RUBY
+      create_composite_type "paint.colored_point" do |t|
+        t.column "x", "integer"
+        t.column "y", "integer"
+        t.column "color", "text", collation: "en_US"
+      end
+    RUBY
+  end
+  let(:old_query) { "SELECT (1, 1, 'black')::paint.colored_point;" }
+
+  context "with new name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_enum "paint.colored_point", to: "cpoint"
+      RUBY
+    end
+    let(:new_snippet) do
+      <<~RUBY
+        create_composite_type "cpoint" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text", collation: "en_US"
+        end
+      RUBY
+    end
+    let(:new_query) { "SELECT (1, 1, 'black')::cpoint;" }
+
+    its(:execution) { is_expected.to enable_sql_request(new_query) }
+    its(:execution) { is_expected.to disable_sql_request(old_query) }
+    its(:execution) { is_expected.to remove(old_snippet).from_schema }
+    its(:execution) { is_expected.to insert(new_snippet).into_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(new_query) }
+    its(:inversion) { is_expected.to enable_sql_request(old_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with the same name and schema" do
+    let(:migration) do
+      <<~RUBY
+        rename_enum "paint.colored_point", to: "paint.colored_point"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name must be different/i) }
+  end
+
+  context "without new schema/name" do
+    let(:migration) do
+      <<~RUBY
+        rename_composite_type "paint.colored_point"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/new name can't be blank/i) }
+  end
+
+  context "without name" do
+    let(:migration) do
+      <<~RUBY
+        rename_composite_type to: "cpoint"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/name can't be blank/i) }
+  end
+end

data/spec/operations/dependency_resolver_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+# There is a couple tests just to check the order of objects creation
+# in the resulting database schema.
+describe ActiveRecord::Migration do
+  context "with a table -> function -> check_constraint dependency" do
+    let(:migration) do
+      <<~RUBY
+        create_table "users", force: :cascade do |t|
+          t.string "first_name"
+          t.string "last_name"
+        end
+
+        create_function "full_name(u users) text" do |f|
+          f.volatility :immutable
+          f.strict true
+          f.parallel :safe
+          f.body <<~Q.chomp
+            SELECT (
+            CASE WHEN u.first_name IS NULL THEN '' ELSE u.first_name || ' ' END
+            ) || COALESCE(u.last_name, '')
+          Q
+        end
+
+        add_check_constraint "users", "length(users.full_name) > 0"
+
+        # no dependencies here, that's why the table must be moved up
+        # before users (in alphabetical order)
+        create_table "colors" do |t|
+          t.string "name"
+          t.string "code"
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY
+        create_table "colors", force: :cascade do |t|
+          t.string "name"
+          t.string "code"
+        end
+
+        create_table "users", force: :cascade do |t|
+          t.string "first_name"
+          t.string "last_name"
+        end
+
+        create_function "full_name(u users) text" do |f|
+          f.volatility :immutable
+          f.strict true
+          f.parallel :safe
+          f.body <<~Q.chomp
+            SELECT (
+            CASE WHEN u.first_name IS NULL THEN '' ELSE u.first_name || ' ' END
+            ) || COALESCE(u.last_name, '')
+          Q
+        end
+
+        add_check_constraint "users", "length(full_name(users.*)) > 0"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+  end
+
+  context "with a table -> function -> index dependency" do
+    let(:migration) do
+      <<~RUBY
+        create_table "users", force: :cascade do |t|
+          t.string "first_name"
+          t.string "last_name"
+        end
+
+        create_function "full_name(u users) text" do |f|
+          f.volatility :immutable
+          f.strict true
+          f.parallel :safe
+          f.body <<~Q.chomp
+            SELECT (
+            CASE WHEN u.first_name IS NULL THEN '' ELSE u.first_name || ' ' END
+            ) || COALESCE(u.last_name, '')
+          Q
+        end
+
+        add_index "users", "full_name(users.*)", name: "users_full_name_idx"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "with a composite -> domain -> function dependency", since_version: 12 do
+    let(:migration) do
+      <<~RUBY
+        create_composite_type "color_point" do |t|
+          t.column "x", "integer"
+          t.column "y", "integer"
+          t.column "color", "text"
+        end
+
+        create_domain "rb_point", as: "color_point" do |d|
+          d.constraint <<~Q.chomp, name: "valid_color"
+            (VALUE).color = 'red'::text OR (VALUE).color = 'blue'::text
+          Q
+          d.constraint "(VALUE).x IS NOT NULL", name: "valid_x"
+          d.constraint "(VALUE).y IS NOT NULL", name: "valid_y"
+        end
+
+        create_function "distance(a rb_point, b rb_point) double precision" do |f|
+          f.body <<~Q.chomp
+            SELECT |/ (((b.x) - (a.x)) ^ 2 + ((b.y) - (a.y)) ^ 2 +
+            (CASE WHEN b.color != a.color THEN 1 ELSE 0 END))
+          Q
+          f.comment <<~Q.chomp
+            Apply the Pythagorean theorem adding 1 as a distance between colors
+          Q
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "with a enum -> table dependency", since_version: 12 do
+    let(:migration) do
+      <<~RUBY
+        create_enum "currency" do |e|
+          e.values "CFR", "EUR", "JPY", "USD"
+        end
+
+        create_table "transactions", force: :cascade do |t|
+          t.text "sender"
+          t.text "receiver"
+          t.column "currency", "currency"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "with a domain -> table dependency", since_version: 12 do
+    let(:migration) do
+      <<~RUBY
+        create_domain "currency", as: "text" do |d|
+          d.constraint "VALUE ~ '^[A-Z]{3}$'::text", name: "currency_check"
+        end
+
+        create_table "transactions", force: :cascade do |t|
+          t.text "sender"
+          t.text "receiver"
+          t.column "currency", "currency"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+
+  context "with a composite_type -> table dependency", since_version: 12 do
+    let(:migration) do
+      <<~RUBY
+        create_composite_type "sum" do |t|
+          t.column "currency", "text"
+          t.column "value", "integer"
+        end
+
+        create_table "transactions", force: :cascade do |t|
+          t.text "sender"
+          t.text "receiver"
+          t.column "summa", "sum"
+        end
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+  end
+end