torque-postgresql 3.4.1 → 4.0.0

data/lib/torque/postgresql/versioned_commands.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'versioned_commands/command_migration'
+require_relative 'versioned_commands/migration_context'
+require_relative 'versioned_commands/migrator'
+require_relative 'versioned_commands/schema_table'
+
+module Torque
+  module PostgreSQL
+    # Takes advantage of Rails migrations to create other sorts of
+    # objects/commands that can also be versioned. Everything migrated will
+    # still live within Migrations borders (i.e., the schema_migrations), but
+    # the way they are handled and registered in the schema dumper is completely
+    # different
+    module VersionedCommands
+      RAILS_APP = defined?(Rails.application.paths)
+      NAME_MATCH = '"?((?:[_a-z0-9]+"?\."?)?[_a-z0-9]+)"?'
+
+      class << self
+        # Check if the type is current enabled
+        def valid_type?(type)
+          PostgreSQL.config.versioned_commands.types.include?(type.to_sym)
+        end
+
+        # Run the internal validations for the given type and content
+        def validate!(type, content, name)
+          method_name = :"validate_#{type}!"
+          return send(method_name, content, name) if valid_type?(type)
+          raise ArgumentError, "Unknown versioned command type: #{type}"
+        end
+
+        # Get the content of the command based on the type, name, and version
+        def fetch_command(dirs, type, name, version)
+          paths = Array.wrap(dirs).map { |d| "#{d}/**/*_#{type}_#{name}_v#{version}.sql" }
+          files = Dir[*paths]
+          return File.read(files.first) if files.one?
+
+          raise ArgumentError, <<~MSG.squish if files.none?
+            No previous version found for #{type} #{name}
+            of version v#{version}.
+          MSG
+
+          raise ArgumentError, <<~MSG.squish if files.many?
+            Multiple files found for #{type} #{name}
+            of version v#{version}.
+          MSG
+        end
+
+        # The regexp is dynamic due to the list of available types
+        def filename_regexp
+          @filename_regexp ||= begin
+            types = PostgreSQL.config.versioned_commands.types
+            Regexp.new([
+              "\\A([0-9]+)_",
+              "(create|update|remove)_",
+              "(#{types.join('|')})_",
+              "([_a-z0-9]*)",
+              "_v([0-9]+)",
+              "\\.?([_a-z0-9]*)?",
+              "\\.sql\\z",
+            ].join)
+          end
+        end
+
+        private
+
+          # Validate that the content of the command is correct
+          def validate_function!(content, name)
+            result = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              "FUNCTION\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+
+            names = result.map(&:last).compact.uniq(&:downcase)
+            raise ArgumentError, <<~MSG.squish if names.size > 1
+              Multiple functions definition found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish unless result.all?(&:first)
+              'OR REPLACE' is required for proper migration support.
+            MSG
+
+            fn_name = names.first.downcase.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if fn_name != name.downcase
+              Function name must match file name.
+            MSG
+          end
+
+          # Validate that the content of the command is correct
+          def validate_type!(content, name)
+            creates = content.scan(Regexp.new(['^\s*CREATE\s+TYPE\s+', NAME_MATCH].join, 'mi'))
+            drops = content.scan(Regexp.new([
+              '^\s*DROP\s+TYPE\s+(IF\s+EXISTS)?\s*',
+              NAME_MATCH,
+            ].join, 'mi'))
+
+            raise ArgumentError, <<~MSG.squish if creates.size > 1
+              More than one type definition found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if drops.size > 1
+              More than one type drop found.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if drops.empty?
+              'DROP TYPE' is required for proper migration support.
+            MSG
+
+            create_name = creates.first.last.downcase
+            raise ArgumentError, <<~MSG.squish if drops.first.last.downcase != create_name
+              Drop does not match create.
+            MSG
+
+            create_name = create_name.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if create_name != name.downcase
+              Type name must match file name.
+            MSG
+          end
+
+          # Validate that the content of the command is correct
+          def validate_view!(content, name)
+            result = content.scan(Regexp.new([
+              '^\s*CREATE\s+(OR\s+REPLACE)?\s*',
+              '((?:TEMP|TEMPORARY|MATERIALIZED)\s+)?',
+              '(?:RECURSIVE\s+)?',
+              "VIEW\\s+#{NAME_MATCH}",
+            ].join, 'mi'))
+
+            raise ArgumentError, <<~MSG.squish if result.empty?
+              Missing or invalid view definition.
+            MSG
+
+            raise ArgumentError, <<~MSG.squish if result.size > 1
+              More than one view definition found.
+            MSG
+
+            with_replace, opt, view_name = result.first
+            if opt&.strip == 'MATERIALIZED'
+              raise ArgumentError, <<~MSG.squish if with_replace.present?
+                Materialized view does not support 'OR REPLACE'.
+              MSG
+
+              with_drop = "DROP MATERIALIZED VIEW IF EXISTS #{view_name};"
+              raise ArgumentError, <<~MSG.squish unless content.include?(with_drop)
+                'DROP MATERIALIZED VIEW IF EXISTS' is required for proper migration support.
+              MSG
+            else
+              raise ArgumentError, <<~MSG.squish if with_replace.blank?
+                'OR REPLACE' is required for proper migration support.
+              MSG
+            end
+
+            view_name = view_name.downcase.sub('.', '_')
+            raise ArgumentError, <<~MSG.squish if view_name != name.downcase
+              View name must match file name.
+            MSG
+          end
+      end
+    end
+  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,67 @@
+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'
+require_relative '../lib/torque/postgresql/relation/join_series'
+require_relative '../lib/torque/postgresql/relation/buckets'
+
+require_relative '../lib/torque/postgresql/versioned_commands'
+
+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)
+    Relation.include(Relation::JoinSeries)
+    Relation.include(Relation::Buckets)
+
+    config.versioned_commands.enabled = true
+    ActiveRecord::Schema::Definition.include(Adapter::Definition)
+
+    ::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 = 6
 
 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
 
@@ -123,6 +127,7 @@ ActiveRecord::Schema.define(version: version) do
   create_table "users", force: :cascade do |t|
     t.string   "name", null: false
     t.enum     "role", enum_type: :roles, default: :visitor
+    t.integer  "age"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
   end

data/spec/spec_helper.rb

@@ -4,7 +4,12 @@ require 'factory_bot'
 require 'dotenv'
 require 'faker'
 require 'rspec'
-require 'byebug'
+
+begin
+  require 'debug/prelude'
+rescue LoadError
+  # No debugger available, skip
+end
 
 Dotenv.load
 
@@ -21,7 +26,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"'