active_record-postgres-constraints 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5271c66bc4b63fe16a80b9777e4cd2c208408664b441752579a5faf5882fb439
-  data.tar.gz: 54609bd96e07eaba2bb66ad2ec4fed1c0ba0a21de4fc93b40db65941556ba916
+  metadata.gz: b3315c2077c81d530ad63720aea7fda16d01298233aec01e5f47990c2aa43969
+  data.tar.gz: '048e1f4a77a7839d9eec3a75b8417dcfcd72390c960eeee3e75f2599369113a4'
 SHA512:
-  metadata.gz: 12eef31e5ea5b276c312497ec44b9b6f18eed9bc6f74dd41d5d9667abfd0952b816c2e74e1081e27e1cb4edddb5920da8747ced197be6327cb41b612f6b2b9d6
-  data.tar.gz: f0dc14c943ce9e0ed4369d100c6cbc6e392d2f8ffcc2fc1a4dd541f263994814ec403e293a27d2eb22d33b6dbf6fece66553ef0f707ad6223730a090ce698285
+  metadata.gz: 3cdba026319a96312e707fb97efa408b1394c71812ed4fde78dd086f7916dc5cf0e854d8d86570e96e7ad8a69eb8fc01b02ff14f42cbf0aa3afe868abf454e61
+  data.tar.gz: 3ccba16e546aa92e2d0d436cc66df0c84acd0605ede6b7ad40a12158879e223424ab0c1f03c53569f7b5e870c1cc9bdbcf73c17cdbd519f17a423ac8db221ad8

data/README.md

@@ -14,7 +14,7 @@ using features like this, then you should set the schema format to :sql.
 No longer is this the case.  You can now use the default schema format
 (:ruby) and still preserve your check constraints.
 
-At this time, this only supports check constraints for the postgresql ActiveRecord database adapter.
+At this time, this only supports check and exclude constraints for the postgresql ActiveRecord database adapter.
 
 ## Usage
 
@@ -44,6 +44,34 @@ remove_check_constraint :people
 remove_check_constraint :people, title: ['Mr.', 'Mrs.', 'Dr.']
 ```
 
+#### Add an exclude constraint
+Add exclude constraints to a table in a migration:
+
+```ruby
+create_table :booking do |t|
+  t.integer :room_id
+  t.datetime :from
+  t.datetime :to
+  t.exclude_constraint using: :gist, 'tsrange("from", "to")' => :overlaps, room_id: :equals
+end
+```
+
+OR
+
+```ruby
+add_exclude_constraint :booking, using: :gist, 'tsrange("from", "to")' => :overlaps, room_id: :equals
+```
+
+#### Remove an exclude constraint
+
+```ruby
+# If you don't need it to be reversible:
+remove_exclude_constraint :booking
+
+# If you need it to be reversible (Recommended):
+remove_exclude_constraint :booking, using: :gist, 'tsrange("from", "to")' => :overlaps, room_id: :equals
+```
+
 ## Installation
 Add this line to your application's Gemfile:
 

data/Rakefile

@@ -7,4 +7,5 @@ rescue LoadError
 end
 
 require 'bundler/gem_tasks'
+require 'parallel_tests/tasks'
 task default: :spec

data/lib/active_record/postgres/constraints.rb

@@ -1,51 +1,33 @@
 # frozen_string_literal: true
 
-require_relative 'constraints/command_recorder'
-require_relative 'constraints/postgresql_adapter'
-require_relative 'constraints/railtie'
-require_relative 'constraints/schema_creation'
-require_relative 'constraints/schema_dumper'
-require_relative 'constraints/table_definition'
-require_relative 'constraints/version'
-
 module ActiveRecord
   module Postgres
     module Constraints
-      class << self
-        def normalize_conditions(conditions)
-          conditions = [conditions] unless conditions.is_a?(Array)
-          conditions = conditions.map do |condition|
-            if condition.is_a?(Hash)
-              normalize_conditions_hash(condition)
-            else
-              condition
-            end
-          end
-
-          return conditions.first if 1 == conditions.length
-
-          "(#{conditions.join(') AND (')})"
-        end
+      CONSTRAINT_TYPES = {
+        check: 'c',
+        exclude: 'x',
+      }.freeze
 
-        def normalize_conditions_hash(hash)
-          hash = hash.reduce([]) do |array, (column, predicate)|
-            predicate = predicate.join("', '") if predicate.is_a?(Array)
-            array << "#{column} IN ('#{predicate}')"
-          end
-          "(#{hash.join(') AND (')})"
-        end
+      def self.class_for_constraint_type(type)
+        'ActiveRecord::Postgres::Constraints::Types::'\
+        "#{type.to_s.classify}".constantize
+      end
 
-        def to_sql(table, name_or_conditions, conditions = nil)
-          if conditions
-            name = name_or_conditions
-          else
-            name = "#{table}_#{Time.zone.now.nsec}"
-            conditions = name_or_conditions
-          end
+      def self.normalize_name_and_conditions(table, name_or_conditions, conditions)
+        return [name_or_conditions, conditions] if conditions
 
-          "CONSTRAINT #{name} CHECK (#{normalize_conditions(conditions)})"
-        end
+        ["#{table}_#{Time.zone.now.nsec}", name_or_conditions]
       end
     end
   end
 end
+
+require_relative 'constraints/command_recorder'
+require_relative 'constraints/postgresql_adapter'
+require_relative 'constraints/railtie'
+require_relative 'constraints/schema_creation'
+require_relative 'constraints/schema_dumper'
+require_relative 'constraints/table_definition'
+require_relative 'constraints/types/check'
+require_relative 'constraints/types/exclude'
+require_relative 'constraints/version'

data/lib/active_record/postgres/constraints/command_recorder.rb

@@ -4,26 +4,32 @@ module ActiveRecord
   module Postgres
     module Constraints
       module CommandRecorder
-        def add_check_constraint(*args, &block)
-          record(:add_check_constraint, args, &block)
-        end
+        CONSTRAINT_TYPES.keys.each do |type|
+          define_method("add_#{type}_constraint") do |*args, &block|
+            record(:"add_#{type}_constraint", args, &block)
+          end
 
-        def invert_add_check_constraint(args, &block)
-          [:remove_check_constraint, args, block]
-        end
+          define_method("invert_add_#{type}_constraint") do |args, &block|
+            [:"remove_#{type}_constraint", args, block]
+          end
 
-        def remove_check_constraint(*args, &block)
-          if args.length < 3
-            raise ActiveRecord::IrreversibleMigration,
-              'To make this migration reversible, pass the constraint to '\
-              'remove_check_constraint, i.e. `remove_check_constraint, '\
-              "#{args[0].inspect}, #{args[1].inspect}, 'price > 999'`"
+          define_method("remove_#{type}_constraint") do |*args, &block|
+            if args.length < 3
+              example_constraint = ActiveRecord::Postgres::Constraints.
+                class_for_constraint_type(type).
+                example_constraint
+
+              raise ActiveRecord::IrreversibleMigration,
+                'To make this migration reversible, pass the constraint to '\
+                "remove_#{type}_constraint, i.e. `remove_#{type}_constraint "\
+                "#{args[0].inspect}, #{args[1].inspect}, #{example_constraint}`"
+            end
+            record(:"remove_#{type}_constraint", args, &block)
           end
-          record(:remove_check_constraint, args, &block)
-        end
 
-        def invert_remove_check_constraint(args, &block)
-          [:add_check_constraint, args, block]
+          define_method("invert_remove_#{type}_constraint") do |args, &block|
+            [:"add_#{type}_constraint", args, block]
+          end
         end
       end
     end

data/lib/active_record/postgres/constraints/postgresql_adapter.rb

@@ -4,20 +4,36 @@ module ActiveRecord
   module Postgres
     module Constraints
       module PostgreSQLAdapter
-        def add_check_constraint(table, name_or_conditions, conditions = nil)
-          constraint = Constraints.to_sql(table, name_or_conditions, conditions)
+        CONSTRAINT_TYPES.keys.each do |type|
+          define_method "add_#{type}_constraint" do |table, name_or_conditions, conditions = nil|
+            add_constraint(type, table, name_or_conditions, conditions)
+          end
+
+          define_method "remove_#{type}_constraint" do |table, name, conditions = nil|
+            remove_constraint(type, table, name, conditions)
+          end
+        end
+
+        def add_constraint(type, table, name_or_conditions, conditions)
+          constraint =
+            ActiveRecord::Postgres::Constraints.
+              class_for_constraint_type(type).
+              to_sql(table, name_or_conditions, conditions)
           execute("ALTER TABLE #{table} ADD #{constraint}")
         end
 
-        def remove_check_constraint(table, name, _conditions = nil)
+        def remove_constraint(_type, table, name, _conditions)
           execute("ALTER TABLE #{table} DROP CONSTRAINT #{name}")
         end
 
         def constraints(table)
-          sql = "SELECT conname, consrc FROM pg_constraint
+          types = CONSTRAINT_TYPES.values.map { |v| "'#{v}'" }.join(', ')
+          sql = "SELECT conname, consrc, contype,
+            pg_get_constraintdef(pg_constraint.oid) AS definition
+            FROM pg_constraint
             JOIN pg_class ON pg_constraint.conrelid = pg_class.oid
             WHERE
-              pg_constraint.contype = 'c'
+              pg_constraint.contype IN (#{types})
               AND
               pg_class.relname = '#{table}'".tr("\n", ' ').squeeze(' ')
           execute sql

data/lib/active_record/postgres/constraints/railtie.rb

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
-module ActiveRecord
-  module Postgres
-    module Constraints
-      class Railtie < Rails::Railtie
-        initializer 'active_record.postgres.constraints.patch_active_record' do |*_args|
-          engine = self
-          ActiveSupport.on_load(:active_record) do
-            AR_CAS = ::ActiveRecord::ConnectionAdapters
+if defined?(::Rails::Railtie)
+  module ActiveRecord
+    module Postgres
+      module Constraints
+        class Railtie < ::Rails::Railtie
+          initializer 'active_record.postgres.constraints.patch_active_record' do |*_args|
+            engine = self
+            ActiveSupport.on_load(:active_record) do
+              AR_CAS = ::ActiveRecord::ConnectionAdapters
 
-            engine.apply_patch! if engine.pg?
+              engine.apply_patch! if engine.pg?
+            end
           end
-        end
 
-        def apply_patch!
-          Rails.logger.info do
-            'Applying Postgres Constraints patches to ActiveRecord'
-          end
-          AR_CAS::TableDefinition.include TableDefinition
-          AR_CAS::PostgreSQLAdapter.include PostgreSQLAdapter
-          AR_CAS::AbstractAdapter::SchemaCreation.prepend SchemaCreation
+          def apply_patch!
+            Rails.logger.info do
+              'Applying Postgres Constraints patches to ActiveRecord'
+            end
+            AR_CAS::TableDefinition.include TableDefinition
+            AR_CAS::PostgreSQLAdapter.include PostgreSQLAdapter
+            AR_CAS::AbstractAdapter::SchemaCreation.prepend SchemaCreation
 
-          ::ActiveRecord::Migration::CommandRecorder.include CommandRecorder
-          ::ActiveRecord::SchemaDumper.prepend SchemaDumper
-        end
+            ::ActiveRecord::Migration::CommandRecorder.include CommandRecorder
+            ::ActiveRecord::SchemaDumper.prepend SchemaDumper
+          end
 
-        def pg?
-          config = ActiveRecord::Base.connection_config
-          return true if config && 'postgresql' == config[:adapter]
+          def pg?
+            config = ActiveRecord::Base.connection_config
+            return true if config && 'postgresql' == config[:adapter]
 
-          Rails.logger.warn do
-            'Not applying Postgres Constraints patches to ActiveRecord ' \
-              'since the database is not postgres'
+            Rails.logger.warn do
+              'Not applying Postgres Constraints patches to ActiveRecord ' \
+                'since the database is not postgres'
+            end
+            false
           end
-          false
         end
       end
     end

data/lib/active_record/postgres/constraints/schema_creation.rb

@@ -8,7 +8,7 @@ module ActiveRecord
         def visit_TableDefinition(table_definition)
           # rubocop:enable Naming/MethodName
           result = super
-          return result unless table_definition.check_constraints
+          return result unless table_definition.constraints
 
           nesting = 0
           # Find the closing paren of the "CREATE TABLE ( ... )" clause
@@ -17,7 +17,7 @@ module ActiveRecord
             nesting, should_break = adjust_nesting(nesting, token)
             break i if should_break
           end
-          result[index] = ", #{table_definition.check_constraints.join(', ')})"
+          result[index] = ", #{table_definition.constraints.join(', ')})"
           result
         end
 

data/lib/active_record/postgres/constraints/schema_dumper.rb

@@ -5,17 +5,44 @@ module ActiveRecord
     module Constraints
       module SchemaDumper
         def indexes_in_create(table, stream)
-          super
           constraints = @connection.constraints(table)
+          indexes = @connection.indexes(table).reject do |index|
+            constraints.pluck('conname').include?(index_name(index))
+          end
+          dump_indexes(indexes, stream)
+          dump_constraints(constraints, stream)
+        end
+
+        private
+
+        def dump_indexes(indexes, stream)
+          return unless indexes.any?
+
+          index_statements = indexes.map do |index|
+            "    t.index #{index_parts(index).join(', ')}"
+          end
+          stream.puts index_statements.sort.join("\n")
+        end
+
+        def dump_constraints(constraints, stream)
           return unless constraints.any?
 
           constraint_statements = constraints.map do |constraint|
-            name = constraint['conname']
-            conditions = constraint['consrc']
-            "    t.check_constraint :#{name}, #{conditions.inspect}"
+            type = CONSTRAINT_TYPES.key(constraint['contype'])
+            ActiveRecord::Postgres::Constraints.
+              class_for_constraint_type(type).
+              to_schema_dump(constraint)
           end
           stream.puts constraint_statements.sort.join("\n")
         end
+
+        def index_name(index)
+          if index.is_a?(ActiveRecord::ConnectionAdapters::IndexDefinition)
+            index.name
+          else
+            index['name']
+          end
+        end
       end
     end
   end

data/lib/active_record/postgres/constraints/table_definition.rb

@@ -4,12 +4,21 @@ module ActiveRecord
   module Postgres
     module Constraints
       module TableDefinition
-        attr_reader :check_constraints
+        attr_reader :constraints
 
-        def check_constraint(name_or_conditions, conditions = nil)
-          @check_constraints ||= []
-          constraint = Constraints.to_sql(name, name_or_conditions, conditions)
-          check_constraints << constraint
+        CONSTRAINT_TYPES.keys.each do |type|
+          define_method "#{type}_constraint" do |name_or_conditions, conditions = nil|
+            add_constraint(type, name_or_conditions, conditions)
+          end
+        end
+
+        def add_constraint(type, name_or_conditions, conditions)
+          @constraints ||= []
+          constraint =
+            ActiveRecord::Postgres::Constraints.
+              class_for_constraint_type(type).
+              to_sql(name, name_or_conditions, conditions)
+          constraints << constraint
         end
       end
     end

data/lib/active_record/postgres/constraints/types/check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Postgres
+    module Constraints
+      module Types
+        module Check
+          class << self
+            def to_sql(table, name_or_conditions, conditions = nil)
+              name, conditions = ActiveRecord::Postgres::Constraints.
+                normalize_name_and_conditions(table, name_or_conditions, conditions)
+              "CONSTRAINT #{name} CHECK (#{normalize_conditions(conditions)})"
+            end
+
+            def to_schema_dump(constraint)
+              name = constraint['conname']
+              conditions = constraint['consrc']
+              "    t.check_constraint :#{name}, #{conditions.inspect}"
+            end
+
+            def example_constraint
+              "'price > 999'"
+            end
+
+            private
+
+            def normalize_conditions(conditions)
+              conditions = [conditions] unless conditions.is_a?(Array)
+              conditions = conditions.map do |condition|
+                if condition.is_a?(Hash)
+                  normalize_conditions_hash(condition)
+                else
+                  condition
+                end
+              end
+
+              return conditions.first if 1 == conditions.length
+
+              "(#{conditions.join(') AND (')})"
+            end
+
+            def normalize_conditions_hash(hash)
+              hash = hash.reduce([]) do |array, (column, predicate)|
+                predicate = predicate.join("', '") if predicate.is_a?(Array)
+                array << "#{column} IN ('#{predicate}')"
+              end
+              "(#{hash.join(') AND (')})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/postgres/constraints/types/exclude.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Postgres
+    module Constraints
+      module Types
+        module Exclude
+          OPERATOR_SYMBOLS = {
+            equals: '=',
+            overlaps: '&&',
+          }.freeze
+
+          class << self
+            def to_sql(table, name_or_conditions, conditions = nil)
+              name, conditions = ActiveRecord::Postgres::Constraints.
+                normalize_name_and_conditions(table, name_or_conditions, conditions)
+
+              using = conditions.delete(:using)
+              using = " USING #{using}" if using
+
+              where = conditions.delete(:where)
+              where = " WHERE (#{where})" if where
+
+              conditions = normalize_conditions(conditions).join(', ')
+
+              "CONSTRAINT #{name} EXCLUDE#{using} (#{conditions})#{where}"
+            end
+
+            def to_schema_dump(constraint)
+              name = constraint['conname']
+              definition = constraint['definition']
+
+              using = definition.match(/USING (\w*)/).try(:[], 1)
+              using = "using: :#{using}, " if using
+
+              where = definition.match(/WHERE \((.*)\)/).try(:[], 1)
+              where = "where: '#{where}'" if where
+
+              exclusions = definition_to_exclusions(definition).join(', ')
+              conditions = "#{using}#{exclusions}#{", #{where}" if where}"
+
+              "    t.exclude_constraint :#{name}, #{conditions}"
+            end
+
+            def example_constraint
+              %(using: :gist, 'tsrange("from", "to")' => :overlaps, project_id: :equals)
+            end
+
+            private
+
+            def definition_to_exclusions(definition)
+              definition.
+                split(' WHERE')[0].
+                match(/\((.*)/)[1].
+                chomp(')').
+                scan(/((?:[^,(]+|(\((?>[^()]+|\g<-1>)*)\))+)/).
+                map!(&:first).
+                map!(&:strip).
+                flatten.
+                map! { |exclusion| element_and_operator(exclusion) }
+            end
+
+            def element_and_operator(exclusion)
+              element, operator = exclusion.strip.split(' WITH ')
+              "#{normalize_element(element)} #{normalize_operator(operator)}"
+            end
+
+            def normalize_conditions(conditions)
+              conditions.map do |element, operator|
+                "#{element} WITH #{OPERATOR_SYMBOLS[operator.to_sym]}"
+              end
+            end
+
+            def normalize_element(element)
+              element.include?('(') ? "'#{element}' =>" : "#{element}:"
+            end
+
+            def normalize_operator(operator)
+              ":#{OPERATOR_SYMBOLS.invert[operator]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/postgres/constraints/version.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Postgres
     module Constraints
-      VERSION = '0.1.5'
+      VERSION = '0.2.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-postgres-constraints
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Isaac Betesh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-13 00:00:00.000000000 Z
+date: 2020-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -48,16 +48,16 @@ dependencies:
   name: osm-rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.15
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.15
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -110,6 +110,8 @@ files:
 - lib/active_record/postgres/constraints/schema_creation.rb
 - lib/active_record/postgres/constraints/schema_dumper.rb
 - lib/active_record/postgres/constraints/table_definition.rb
+- lib/active_record/postgres/constraints/types/check.rb
+- lib/active_record/postgres/constraints/types/exclude.rb
 - lib/active_record/postgres/constraints/version.rb
 homepage: https://github.com/on-site/active_record-postgres-constraints
 licenses: