torque-postgresql 3.4.1 → 4.0.0.rc1

data/lib/torque/postgresql/relation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'relation/distinct_on'
-require_relative 'relation/auxiliary_statement'
 require_relative 'relation/inheritance'
 
 require_relative 'relation/merger'
@@ -12,7 +11,6 @@ module Torque
       extend ActiveSupport::Concern
 
       include DistinctOn
-      include AuxiliaryStatement
       include Inheritance
 
       SINGLE_VALUE_METHODS = [:itself_only]
@@ -107,7 +105,7 @@ module Torque
           end
         end
 
-      module ClassMethods
+      class_methods do
         # Easy and storable way to access the name used to get the record table
         # name when using inheritance tables
         def _record_class_attribute
@@ -115,7 +113,7 @@ module Torque
             .inheritance.record_class_column_name.to_sym
         end
 
-        # Easy and storable way to access the name used to get the indicater of
+        # Easy and storable way to access the name used to get the indicate of
         # auto casting inherited records
         def _auto_cast_attribute
           @@auto_cast ||= Torque::PostgreSQL.config
@@ -135,16 +133,14 @@ module Torque
         end
 
         # Allow extra keyword arguments to be sent to +InsertAll+
-        if Torque::PostgreSQL::AR720
-          def upsert_all(attributes, **xargs)
-            xargs = xargs.reverse_merge(on_duplicate: :update)
-            ::ActiveRecord::InsertAll.execute(self, attributes, **xargs)
-          end
+        def upsert_all(attributes, **xargs)
+          xargs = xargs.reverse_merge(on_duplicate: :update)
+          ::ActiveRecord::InsertAll.execute(self, attributes, **xargs)
         end
       end
     end
 
-    # Include the methos here provided and then change the constants to ensure
+    # Include the methods here provided and then change the constants to ensure
     # the operation of ActiveRecord Relation
     ActiveRecord::Relation.include Relation
     ActiveRecord::Relation.prepend Relation::Initializer

data/lib/torque/postgresql/schema_cache.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 require 'torque/postgresql/schema_cache/inheritance'
-
-if Torque::PostgreSQL::AR710
-  require 'torque/postgresql/schema_cache/schema_reflection'
-  require 'torque/postgresql/schema_cache/bound_schema_reflection'
-end
+require 'torque/postgresql/schema_cache/schema_reflection'
+require 'torque/postgresql/schema_cache/bound_schema_reflection'
 
 module Torque
   module PostgreSQL
@@ -73,7 +70,7 @@ module Torque
       end
 
       def clear_data_source_cache!(connection_or_name, name = connection_or_name) # :nodoc:
-        Torque::PostgreSQL::AR710 ? super : super(name)
+        super
         @data_sources_model_names.delete name
         @inheritance_dependencies.delete name
         @inheritance_associations.delete name
@@ -130,8 +127,7 @@ module Torque
         def reload_inheritance_data!(source)
           return if @inheritance_loaded
 
-          method_name = Torque::PostgreSQL::AR720 ? :with_connection : :then
-          source.public_send(method_name) do |connection|
+          source.with_connection do |connection|
             @inheritance_dependencies = connection.inherited_tables
             @inheritance_associations = generate_associations
             @inheritance_loaded = true
@@ -145,14 +141,12 @@ module Torque
         end
 
         # Use this method to also load any irregular model name
-        method_name = Torque::PostgreSQL::AR720 ? :add_all : :prepare_data_sources
-        define_method(method_name) do |source = nil|
-          Torque::PostgreSQL::AR710 ? super(source) : super()
+        def add_all(source = nil)
+          super
 
           data_sources = source.present? ? tables_to_cache(source) : @data_sources.keys
           @data_sources_model_names = prepare_irregular_models(data_sources)
         end
-
     end
 
     ActiveRecord::ConnectionAdapters::SchemaCache.prepend SchemaCache

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '3.4.1'
+    VERSION = '4.0.0.rc1'
   end
 end

data/lib/torque/postgresql.rb

@@ -12,6 +12,7 @@ require 'torque/postgresql/config'
 require 'torque/postgresql/version'
 require 'torque/postgresql/collector'
 require 'torque/postgresql/geometry_builder'
+require 'torque/postgresql/predicate_builder'
 
 require 'torque/postgresql/i18n'
 require 'torque/postgresql/arel'
@@ -19,7 +20,6 @@ require 'torque/postgresql/adapter'
 require 'torque/postgresql/associations'
 require 'torque/postgresql/attributes'
 require 'torque/postgresql/autosave_association'
-require 'torque/postgresql/auxiliary_statement'
 require 'torque/postgresql/inheritance'
 require 'torque/postgresql/base' # Needs to be after inheritance
 require 'torque/postgresql/insert_all'
@@ -28,5 +28,6 @@ require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'
 require 'torque/postgresql/schema_cache'
 require 'torque/postgresql/table_name'
+require 'torque/postgresql/function'
 
 require 'torque/postgresql/railtie' if defined?(Rails)

data/spec/initialize.rb

@@ -0,0 +1,58 @@
+require_relative '../lib/torque/postgresql/auxiliary_statement'
+
+require_relative '../lib/torque/postgresql/adapter/schema_overrides'
+
+require_relative '../lib/torque/postgresql/adapter/oid/box'
+require_relative '../lib/torque/postgresql/adapter/oid/circle'
+require_relative '../lib/torque/postgresql/adapter/oid/enum'
+require_relative '../lib/torque/postgresql/adapter/oid/enum_set'
+require_relative '../lib/torque/postgresql/adapter/oid/interval'
+require_relative '../lib/torque/postgresql/adapter/oid/line'
+require_relative '../lib/torque/postgresql/adapter/oid/segment'
+
+require_relative '../lib/torque/postgresql/attributes/enum'
+require_relative '../lib/torque/postgresql/attributes/enum_set'
+require_relative '../lib/torque/postgresql/attributes/period'
+require_relative '../lib/torque/postgresql/attributes/full_text_search'
+
+require_relative '../lib/torque/postgresql/relation/auxiliary_statement'
+
+module Torque
+  module PostgreSQL
+    ActiveRecord::Base.belongs_to_many_required_by_default = false
+
+    Attributes::Enum.include_on(ActiveRecord::Base)
+    Attributes::EnumSet.include_on(ActiveRecord::Base)
+    Attributes::Period.include_on(ActiveRecord::Base)
+    Attributes::FullTextSearch.include_on(ActiveRecord::Base)
+
+    Relation.include(Relation::AuxiliaryStatement)
+
+    ::Object.const_set('TorqueCTE', AuxiliaryStatement)
+    ::Object.const_set('TorqueRecursiveCTE', AuxiliaryStatement::Recursive)
+
+    config.enum.namespace = ::Object.const_set('Enum', Module.new)
+    config.enum.namespace.define_singleton_method(:const_missing) do |name|
+      Attributes::Enum.lookup(name)
+    end
+
+    config.enum.namespace.define_singleton_method(:sample) do |name|
+      Attributes::Enum.lookup(name).sample
+    end
+
+    ar_type = ActiveRecord::Type
+    ar_type.register(:enum,     Adapter::OID::Enum,     adapter: :postgresql)
+    ar_type.register(:enum_set, Adapter::OID::EnumSet,  adapter: :postgresql)
+
+    ar_type.register(:box,      Adapter::OID::Box,      adapter: :postgresql)
+    ar_type.register(:circle,   Adapter::OID::Circle,   adapter: :postgresql)
+    ar_type.register(:line,     Adapter::OID::Line,     adapter: :postgresql)
+    ar_type.register(:segment,  Adapter::OID::Segment,  adapter: :postgresql)
+
+    ar_type.register(:interval, Adapter::OID::Interval, adapter: :postgresql)
+
+    Arel.build_operations(config.arel.infix_operators)
+
+    ActiveRecord::Base.connection.torque_load_additional_types
+  end
+end

data/spec/mocks/cache_query.rb

@@ -1,33 +1,33 @@
 module Mocks
   module CacheQuery
-    if Torque::PostgreSQL::AR720
-      def get_last_executed_query(&block)
-        cache = ActiveRecord::Base.connection.query_cache
-        cache.instance_variable_set(:@enabled, true)
+    def get_last_executed_query(&block)
+      cache = ActiveRecord::Base.connection.query_cache
+      cache.instance_variable_set(:@enabled, true)
 
-        map = cache.instance_variable_get(:@map)
+      map = cache.instance_variable_get(:@map)
 
-        block.call
-        result = map.keys.first
+      block.call
+      result = map.keys.first
 
-        cache.instance_variable_set(:@enabled, false)
-        map.delete(result)
+      cache.instance_variable_set(:@enabled, false)
+      map.delete(result)
 
-        result
-      end
-    else
-      def get_last_executed_query(&block)
-        conn = ActiveRecord::Base.connection
-        conn.instance_variable_set(:@query_cache_enabled, true)
-
-        block.call
-        result = conn.query_cache.keys.first
+      result
+    end
 
-        conn.instance_variable_set(:@query_cache_enabled, false)
-        conn.instance_variable_get(:@query_cache).delete(result)
+    def get_query_with_binds(&block)
+      result = nil
 
-        result
+      original_method = ActiveRecord::Base.connection.method(:raw_execute)
+      original_method.receiver.define_singleton_method(:raw_execute) do |*args, **xargs, &block|
+        result ||= [args.first, args.third]
+        super(*args, **xargs, &block)
       end
+
+      block.call
+      original_method.receiver.define_singleton_method(:raw_execute, &original_method.to_proc)
+
+      result
     end
   end
 end

data/spec/mocks/create_table.rb

@@ -1,34 +1,14 @@
 module Mocks
   module CreateTable
     def mock_create_table
-      path = ActiveRecord::Base.connection.method(:create_table).super_method.source_location[0]
-
-      before :all do
-        ActiveRecord::ConnectionAdapters::SchemaStatements.send(:define_method, :create_table) do |table_name, **options, &block|
-          td = create_table_definition(table_name, **options)
-
-          # Does things as the same as schema statements
-          if options[:id] != false && !options[:as]
-            pk = options.fetch(:primary_key) do
-              ActiveRecord::Base.get_primary_key table_name.to_s.singularize
-            end
-
-            if pk.is_a?(Array)
-              td.primary_keys pk
-            else
-              td.primary_key pk, options.fetch(:id, :primary_key), **options
-            end
-          end
-
-          block.call(td) if block.present?
-
-          # Now generate the SQL and return it
-          schema_creation.accept td
+      around do |example|
+        original_method = ActiveRecord::Base.connection.method(:log)
+        original_method.receiver.define_singleton_method(:log) do |sql, *, **, &block|
+          sql
         end
-      end
 
-      after :all do
-        load path
+        example.run
+        original_method.receiver.define_singleton_method(:log, &original_method.to_proc)
       end
     end
   end

data/spec/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-version = 4
+version = 5
 
 return if ActiveRecord::Migrator.current_version == version
 ActiveRecord::Schema.define(version: version) do
@@ -60,6 +60,7 @@ ActiveRecord::Schema.define(version: version) do
     t.enum     "type", enum_type: :types
     t.enum     "conflicts", enum_type: :conflicts, array: true
     t.jsonb    "metadata"
+    # t.column   "pieces", :int4multirange
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end
@@ -92,12 +93,14 @@ ActiveRecord::Schema.define(version: version) do
   end
 
   create_table "courses", force: :cascade do |t|
-    t.integer  "category_id"
-    t.string   "title", null: false
-    t.interval "duration"
-    t.enum     "types", enum_type: :types, array: true
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
+    t.integer         "category_id"
+    t.string          "title", null: false
+    t.interval        "duration"
+    t.enum            "types", enum_type: :types, array: true
+    t.search_language "lang", null: false, default: 'english'
+    t.search_vector   "search_vector", columns: :title, language: :lang
+    t.datetime        "created_at", null: false
+    t.datetime        "updated_at", null: false
   end
 
   create_table "images", force: :cascade, id: false do |t|
@@ -105,11 +108,12 @@ ActiveRecord::Schema.define(version: version) do
   end
 
   create_table "posts", force: :cascade do |t|
-    t.integer  "author_id"
-    t.integer  "activity_id"
-    t.string   "title"
-    t.text     "content"
-    t.enum     "status", enum_type: :content_status
+    t.integer       "author_id"
+    t.integer       "activity_id"
+    t.string        "title"
+    t.text          "content"
+    t.enum          "status", enum_type: :content_status
+    t.search_vector "search_vector", columns: %i[title content]
     t.index ["author_id"], name: "index_posts_on_author_id", using: :btree
   end
 
@@ -172,6 +176,9 @@ ActiveRecord::Schema.define(version: version) do
   # create_table "activity_images", force: :cascade, inherits: [:activities, :images]
 
   add_foreign_key "posts", "authors"
+rescue Exception => e
+  byebug
+  raise
 end
 
 ActiveRecord::Base.connection.schema_cache.clear!

data/spec/spec_helper.rb

@@ -21,7 +21,11 @@ cleaner = ->() do
   cache.instance_variable_set(:@inheritance_associations, {})
 end
 
-load File.join('schema.rb')
+# Load all the files that are optional and managed by Railtie
+require_relative 'initialize'
+
+# This needs to come after loading all optional features
+require_relative 'schema'
 Dir.glob(File.join('spec', '{models,factories,mocks}', '**', '*.rb')) do |file|
   require file[5..-4]
 end

data/spec/tests/arel_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 RSpec.describe 'Arel' do
   context 'on inflix operation' do
-    let(:list) { Torque::PostgreSQL::Arel::INFLIX_OPERATION }
     let(:collector) { ::Arel::Collectors::SQLString }
     let(:attribute) { ::Arel::Table.new('a')['sample'] }
     let(:conn) { ActiveRecord::Base.connection }
@@ -21,12 +20,13 @@ RSpec.describe 'Arel' do
       [:doesnt_right_extend, ::Arel.sql('numrange(5, 6)'), 'numrange(5, 6)'],
       [:doesnt_left_extend,  ::Arel.sql('numrange(7, 8)'), 'numrange(7, 8)'],
       [:adjacent_to,         ::Arel.sql('numrange(9, 0)'), 'numrange(9, 0)'],
-    ].each do |(operator, value, quoted_value)|
-      klass_name = operator.to_s.camelize
+    ].each do |(operation, value, quoted_value)|
+      klass_name = operation.to_s.camelize
 
-      context "##{operator}" do
+      context "##{operation}" do
+        let(:operator) { instance.operator }
         let(:instance) do
-          attribute.public_send(operator, value.is_a?(Array) ? ::Arel.array(value) : value)
+          attribute.public_send(operation, value.is_a?(Array) ? ::Arel.array(value) : value)
         end
 
         context 'for attribute' do
@@ -41,7 +41,7 @@ RSpec.describe 'Arel' do
           let(:result) { visitor.accept(instance, collector.new).value }
 
           it 'returns a formatted operation' do
-            expect(result).to be_eql("\"a\".\"sample\" #{list[klass_name]} #{quoted_value}")
+            expect(result).to be_eql("\"a\".\"sample\" #{operator} #{quoted_value}")
           end
         end
       end
@@ -123,9 +123,34 @@ RSpec.describe 'Arel' do
       quoted = ::Arel::Nodes::build_quoted([1])
       casted = ::Arel::Nodes::build_quoted(1, attribute)
 
+      expect(attribute.pg_cast('text').to_sql).to be_eql('"a"."sample"::text')
+      expect(quoted.pg_cast('bigint', true).to_sql).to be_eql('ARRAY[1]::bigint[]')
+      expect(casted.pg_cast('string').to_sql).to be_eql("1::string")
+    end
+
+    it 'provides proper support to cast methods' do
+      attribute = ::Arel::Table.new('a')['sample']
+      quoted = ::Arel::Nodes::build_quoted([1])
+      casted = ::Arel::Nodes::build_quoted(1)
+
       expect(attribute.cast('text').to_sql).to be_eql('"a"."sample"::text')
       expect(quoted.cast('bigint', true).to_sql).to be_eql('ARRAY[1]::bigint[]')
-      expect(casted.cast('string').to_sql).to be_eql("1::string")
+
+      changed_result = ActiveRecord.gem_version >= Gem::Version.new('8.0.2')
+      changed_result = changed_result ? 'CAST(1 AS string)' : '1::string'
+      expect(casted.pg_cast('string').to_sql).to be_eql("1::string")
+    end
+
+    it 'properly works combined on a query' do
+      condition = Video.arel_table[:tag_ids].contains([1,2]).cast(:bigint, :array)
+      query = Video.all.where(condition).to_sql
+
+      expect(query).to include('WHERE "videos"."tag_ids" @> ARRAY[1, 2]::bigint[]')
+
+      condition = QuestionSelect.arel_table[:options].overlaps(%w[a b]).cast(:string, :array)
+      query = QuestionSelect.all.where(condition).to_sql
+
+      expect(query).to include('"options" && ARRAY[\'a\', \'b\']::string[]')
     end
   end
 end

data/spec/tests/auxiliary_statement_spec.rb

@@ -587,7 +587,7 @@ RSpec.describe 'AuxiliaryStatement' do
         result << ' FROM "categories"'
         result << ' WHERE "categories"."parent_id" IS NULL'
         result << ' UNION'
-        result << ' SELECT "categories"."id", "categories"."parent_id", array_append("all_categories"."path", "categories"."id"::varchar) AS path'
+        result << ' SELECT "categories"."id", "categories"."parent_id", ARRAY_APPEND("all_categories"."path", "categories"."id"::varchar) AS path'
         result << ' FROM "categories", "all_categories"'
         result << ' WHERE "categories"."parent_id" = "all_categories"."id"'
         result << ' ) SELECT "courses".* FROM "courses" INNER JOIN "all_categories"'
@@ -607,7 +607,7 @@ RSpec.describe 'AuxiliaryStatement' do
         result << ' FROM "categories"'
         result << ' WHERE "categories"."parent_id" IS NULL'
         result << ' UNION'
-        result << ' SELECT "categories"."id", "categories"."parent_id", array_append("all_categories"."p", "categories"."name"::varchar) AS p'
+        result << ' SELECT "categories"."id", "categories"."parent_id", ARRAY_APPEND("all_categories"."p", "categories"."name"::varchar) AS p'
         result << ' FROM "categories", "all_categories"'
         result << ' WHERE "categories"."parent_id" = "all_categories"."id"'
         result << ' ) SELECT "courses".*, "all_categories"."p" AS category_path FROM "courses" INNER JOIN "all_categories"'
@@ -889,7 +889,7 @@ RSpec.describe 'AuxiliaryStatement' do
         result << ' FROM "categories"'
         result << ' WHERE "categories"."parent_id" IS NULL'
         result << ' UNION'
-        result << ' SELECT "categories"."id", "categories"."parent_id", array_append("category"."a", "categories"."b"::varchar) AS a'
+        result << ' SELECT "categories"."id", "categories"."parent_id", ARRAY_APPEND("category"."a", "categories"."b"::varchar) AS a'
         result << ' FROM "categories", "category"'
         result << ' WHERE "categories"."parent_id" = "category"."id"'
         result << ' ) SELECT "courses".*, "category"."a" AS c FROM "courses" INNER JOIN "category"'

data/spec/tests/belongs_to_many_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 RSpec.describe 'BelongsToMany' do
   context 'on model' do
     let(:model) { Video }
+    let(:key) { :tests }
     let(:builder) { Torque::PostgreSQL::Associations::Builder::BelongsToMany }
     let(:reflection) { Torque::PostgreSQL::Reflection::BelongsToManyReflection }
-    let(:key) { Torque::PostgreSQL::AR720 ? :tests : 'tests' }
 
     after { model._reflections = {} }
 
@@ -34,8 +34,8 @@ RSpec.describe 'BelongsToMany' do
 
   context 'on association' do
     let(:other) { Tag }
+    let(:key) { :tags }
     let(:initial) { FactoryBot.create(:tag) }
-    let(:key) { Torque::PostgreSQL::AR720 ? :tags : 'tags' }
 
     before { Video.belongs_to_many(:tags) }
     subject { Video.create(title: 'A') }
@@ -58,7 +58,7 @@ RSpec.describe 'BelongsToMany' do
     it 'loads associated records' do
       subject.update(tag_ids: [initial.id])
       expect(subject.tags.to_sql).to be_eql(<<-SQL.squish)
-        SELECT "tags".* FROM "tags" WHERE "tags"."id" IN (#{initial.id})
+        SELECT "tags".* FROM "tags" WHERE "tags"."id" = #{initial.id}
       SQL
 
       expect(subject.tags.load).to be_a(ActiveRecord::Associations::CollectionProxy)
@@ -370,6 +370,18 @@ RSpec.describe 'BelongsToMany' do
       expect { query.load }.not_to raise_error
     end
 
+    context 'when handling binds' do
+      let(:tag_ids) { FactoryBot.create_list(:tag, 5).map(&:id) }
+      let!(:record) { Video.new(tag_ids: tag_ids) }
+
+      it 'uses rails default with in and several binds' do
+        sql, binds = get_query_with_binds { record.tags.load }
+
+        expect(sql).to include(' WHERE "tags"."id" IN ($1, $2, $3, $4, $5)')
+        expect(binds.size).to be_eql(5)
+      end
+    end
+
     context 'when the attribute has a default value' do
       subject { FactoryBot.create(:item) }
 
@@ -424,16 +436,28 @@ RSpec.describe 'BelongsToMany' do
 
     subject { game.create }
 
-    it 'loads associated records' do
+    it 'loads one associated records' do
       subject.update(player_ids: [other.id])
       expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
-        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
+        SELECT "players".* FROM "players" WHERE "players"."id" = '#{other.id}'
       SQL
 
       expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.players.to_a).to be_eql([other])
     end
 
+    it 'loads several associated records' do
+      entries = [other, player.create]
+      subject.update(player_ids: entries.map(&:id))
+      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
+        SELECT "players".* FROM "players"
+        WHERE "players"."id" IN ('#{entries[0].id}', '#{entries[1].id}')
+      SQL
+
+      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.players.to_a).to be_eql(entries)
+    end
+
     it 'can preload records' do
       records = 5.times.map { player.create }
       subject.players.concat(records)
@@ -452,6 +476,49 @@ RSpec.describe 'BelongsToMany' do
     end
   end
 
+  context 'using callbacks' do
+    let(:tags) { FactoryBot.create_list(:tag, 3) }
+    let(:collectors) { Hash.new { |h, k| h[k] = [] } }
+
+    subject { Video.create(title: 'A') }
+
+    after do
+      Video.reset_callbacks(:save)
+      Video._reflections = {}
+    end
+
+    before do
+      subject.update_attribute(:tag_ids, tags.first(2).pluck(:id))
+      Video.belongs_to_many(:tags,
+        before_add:    ->(_, tag) { collectors[:before_add]    << tag },
+        after_add:     ->(_, tag) { collectors[:after_add]     << tag },
+        before_remove: ->(_, tag) { collectors[:before_remove] << tag },
+        after_remove:  ->(_, tag) { collectors[:after_remove]  << tag },
+      )
+    end
+
+    it 'works with id changes' do
+      subject.tag_ids = tags.drop(1).pluck(:id)
+      subject.save!
+
+      expect(collectors[:before_add]).to be_eql([tags.last])
+      expect(collectors[:after_add]).to be_eql([tags.last])
+
+      expect(collectors[:before_remove]).to be_eql([tags.first])
+      expect(collectors[:after_remove]).to be_eql([tags.first])
+    end
+
+    it 'works with record changes' do
+      subject.tags = tags.drop(1)
+
+      expect(collectors[:before_add]).to be_eql([tags.last])
+      expect(collectors[:after_add]).to be_eql([tags.last])
+
+      expect(collectors[:before_remove]).to be_eql([tags.first])
+      expect(collectors[:after_remove]).to be_eql([tags.first])
+    end
+  end
+
   context 'using custom keys' do
     let(:connection) { ActiveRecord::Base.connection }
     let(:post) { Post }

data/spec/tests/enum_set_spec.rb

@@ -43,13 +43,7 @@ RSpec.describe 'Enum' do
   end
 
   context 'on schema' do
-    let(:source) do
-      if Torque::PostgreSQL::AR720
-        ActiveRecord::Base.connection_pool
-      else
-        ActiveRecord::Base.connection
-      end
-    end
+    let(:source) { ActiveRecord::Base.connection_pool }
 
     let(:dump_result) do
       ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
@@ -275,10 +269,11 @@ RSpec.describe 'Enum' do
   end
 
   context 'on model' do
+    let(:instance) { Course.new }
+
     before(:each) { decorate(Course, :types) }
 
     subject { Course }
-    let(:instance) { Course.new }
 
     it 'has all enum set methods' do
       expect(subject).to  respond_to(:types)
@@ -301,17 +296,23 @@ RSpec.describe 'Enum' do
 
     it 'scope the model correctly' do
       query = subject.a.to_sql
-      expect(query).to match(/"courses"."types" @> ARRAY\['A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" @> '{A}'::types[]})
     end
 
     it 'has a match all scope' do
       query = subject.has_types('B', 'A').to_sql
-      expect(query).to match(/"courses"."types" @> ARRAY\['B', 'A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" @> '{B,A}'::types[]})
     end
 
     it 'has a match any scope' do
       query = subject.has_any_types('B', 'A').to_sql
-      expect(query).to match(/"courses"."types" && ARRAY\['B', 'A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" && '{B,A}'::types[]})
+    end
+
+    it 'uses bind param instead of raw value' do
+      sql, binds = get_query_with_binds { subject.has_any_types('B', 'A').load }
+      expect(sql).to include('WHERE "courses"."types" && $1::types[]')
+      expect(binds.first.value).to eq(%w[B A])
     end
   end
 end