torque-postgresql 4.0.0.rc1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a341f61802bc246d4004168a49fc5f67156b7dc3c962321a28e73fc8288e0db
-  data.tar.gz: ca658f344ed87f29b94eb1e115a13b4ef6d4d954c450b6f4e9892f7788b35e39
+  metadata.gz: d80bb198f5645c35915440f05a4ad083830221de27983c4c7b936c394e7bcbbb
+  data.tar.gz: a73a8de3a63b806e08f42109a3bb703e7ce19a20ae55a317c7fb763215612396
 SHA512:
-  metadata.gz: 4e83150ee16db03f72e39d85c33932f38f43351501e673133e42f7df98208cacfe34e9eb0b505ede452fae872b770c5de9c8cdded5927b5d527fc9b6a7757dc7
-  data.tar.gz: 91c9b79d9698c720c5ed77a775f9758069ac41c5fd625c7870180e85a8f4ed16a4998c4b93ff8de04eb6e828b689046801b9a3e7c76efeef22dc0a91b9083797
+  metadata.gz: 42a366f328d284ed37c601e0007a32f65b6615f69185b44fb82e0b943ab77a9e5b810189e00f2f200cf9e9b22e373bf33798c5496c76cfbfcd236bcc8bb923fe
+  data.tar.gz: 45385a880da9922eeb72c4d7e2adb29c26081865747c080973d409e61866a027cccd14a4276c8e0f95daf34d4d59c74a0a1c7cd7aecbb611763734cd12d3e064

data/lib/generators/torque/function_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class FunctionGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_function_file create_migration_file
+    end
+  end
+end

data/lib/generators/torque/templates/function.sql.erb

@@ -0,0 +1,4 @@
+CREATE OR REPLACE FUNCTION <%= name %>()
+RETURNS void AS $$
+  -- Function body goes here
+$$ LANGUAGE sql;

data/lib/generators/torque/templates/type.sql.erb

@@ -0,0 +1,2 @@
+DROP TYPE IF EXISTS <%= name %>;
+CREATE TYPE <%= name %>;

data/lib/generators/torque/templates/view.sql.erb

@@ -0,0 +1,3 @@
+<%= "DROP MATERIALIZED VIEW IF EXISTS #{name};\n" if options[:materialized] %>CREATE <%= options[:materialized] ? 'MATERIALIZED' : 'OR REPLACE' %> VIEW <%= name %> AS (
+  -- View body goes here
+);

data/lib/generators/torque/type_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class TypeGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_type_file create_migration_file
+    end
+  end
+end

data/lib/generators/torque/view_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class ViewGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      class_option :materialized, type: :boolean, aliases: %i(--m), default: false,
+        desc: 'Use materialized view instead of regular view'
+
+      alias create_view_file create_migration_file
+    end
+  end
+end

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -154,19 +154,10 @@ module Torque
 
         # Build the query for allowed schemas
         def user_defined_schemas_sql
-          conditions = []
-          conditions << <<-SQL.squish if schemas_blacklist.any?
-            nspname NOT LIKE ALL (ARRAY['#{schemas_blacklist.join("', '")}'])
-          SQL
-
-          conditions << <<-SQL.squish if schemas_whitelist.any?
-            nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
-          SQL
-
           <<-SQL.squish
             SELECT nspname
             FROM pg_catalog.pg_namespace
-            WHERE 1=1 AND #{conditions.join(' AND ')}
+            WHERE 1=1 AND #{filter_by_schema.join(' AND ')}
             ORDER BY oid
           SQL
         end
@@ -191,6 +182,53 @@ module Torque
           SQL
         end
 
+        # Get all possible schema entries that can be created via versioned
+        # commands of the provided type. Mostly for covering removals and not
+        # dump them
+        def list_versioned_commands(type)
+          query =
+            case type
+            when :function
+              <<-SQL.squish
+                SELECT n.nspname AS schema, p.proname AS name
+                FROM pg_catalog.pg_proc p
+                INNER JOIN pg_namespace n ON n.oid = p.pronamespace
+                WHERE 1=1 AND #{filter_by_schema.join(' AND ')};
+              SQL
+            when :type
+              <<-SQL.squish
+                SELECT n.nspname AS schema, t.typname AS name
+                FROM pg_type t
+                INNER JOIN pg_namespace n ON n.oid = t.typnamespace
+                WHERE 1=1 AND t.typtype NOT IN ('e')
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
+            when :view
+              <<-SQL.squish
+                SELECT n.nspname AS schema, c.relname AS name
+                FROM pg_class c
+                INNER JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE 1=1 AND c.relkind IN ('v', 'm')
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
+            end
+
+          select_rows(query, 'SCHEMA')
+        end
+
+        # Build the condition for filtering by schema
+        def filter_by_schema
+          conditions = []
+          conditions << <<-SQL.squish if schemas_blacklist.any?
+            nspname NOT LIKE ALL (ARRAY['#{schemas_blacklist.join("', '")}'])
+          SQL
+
+          conditions << <<-SQL.squish if schemas_whitelist.any?
+            nspname LIKE ANY (ARRAY['#{schemas_whitelist.join("', '")}'])
+          SQL
+          conditions
+        end
+
       end
     end
   end

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -49,6 +49,28 @@ module Torque
           end
       end
 
+      # Add exclusive support for versioned commands when importing from schema
+      # dump. This ensures that such methods are not available in regular
+      # migrations.
+      module Definition
+
+        def create_function(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:function)
+          execute VersionedCommands.fetch_command(dir, :function, name, version)
+        end
+
+        def create_type(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:type)
+          execute VersionedCommands.fetch_command(dir, :type, name, version)
+        end
+
+        def create_view(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:view)
+          execute VersionedCommands.fetch_command(dir, :view, name, version)
+        end
+
+      end
+
       ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
       ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
     end

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -12,6 +12,15 @@ module Torque
           (?:\s*,\s*'([A-D])')?
         /ix
 
+        def initialize(*)
+          super
+
+          if with_versioned_commands?
+            @versioned_commands = VersionedCommands::SchemaTable.new(@connection.pool)
+            @ignore_tables << @versioned_commands.table_name
+          end
+        end
+
         def dump(stream) # :nodoc:
           @connection.dump_mode!
           super
@@ -22,6 +31,13 @@ module Torque
 
         private
 
+          def types(stream) # :nodoc:
+            super
+
+            versioned_commands(stream, :type)
+            versioned_commands(stream, :function)
+          end
+
           def tables(stream) # :nodoc:
             around_tables(stream) { dump_tables(stream) }
           end
@@ -30,6 +46,7 @@ module Torque
             functions(stream) if fx_functions_position == :beginning
 
             yield
+            versioned_commands(stream, :view, true)
 
             functions(stream) if fx_functions_position == :end
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
@@ -70,7 +87,7 @@ module Torque
             # dump foreign keys at the end to make sure all dependent tables exist.
             if @connection.supports_foreign_keys?
               foreign_keys_stream = StringIO.new
-              sorted_tables.each do |tbl|
+              sorted_tables.each do |(tbl, *)|
                 foreign_keys(tbl, foreign_keys_stream)
               end
 
@@ -147,6 +164,35 @@ module Torque
             settings.to_h.transform_values(&:inspect)
           end
 
+          # Simply add all versioned commands to the stream
+          def versioned_commands(stream, type, add_newline = false)
+            return unless with_versioned_commands?
+
+            list = @versioned_commands.versions_of(type.to_s)
+            return if list.empty?
+
+            existing = list_existing_versioned_commands(type)
+
+            stream.puts if add_newline
+            stream.puts "  # These are #{type.to_s.pluralize} managed by versioned commands"
+            list.each do |(name, version)|
+              next if existing.exclude?(name)
+
+              stream.puts "  create_#{type} \"#{name}\", version: #{version}"
+            end
+            stream.puts unless add_newline
+          end
+
+          def list_existing_versioned_commands(type)
+            @connection.list_versioned_commands(type).each_with_object(Set.new) do |entry, set|
+              set << (entry.first == 'public' ? entry.last : entry.join('_'))
+            end
+          end
+
+          def with_versioned_commands?
+            PostgreSQL.config.versioned_commands.enabled
+          end
+
           def fx_functions_position
             return unless defined?(::Fx::SchemaDumper::Function)
             Fx.configuration.dump_functions_at_beginning_of_schema ? :beginning : :end

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -137,6 +137,51 @@ module Torque
           super + [:schema, :inherits]
         end
 
+        # Add proper support for schema load when using versioned commands
+        def assume_migrated_upto_version(version)
+          return super unless PostgreSQL.config.versioned_commands.enabled
+          return super if (commands = pool.migration_context.migration_commands).empty?
+
+          version = version.to_i
+          migration_context = pool.migration_context
+          migrated = migration_context.get_all_versions
+          versions = migration_context.migrations.map(&:version)
+
+          inserting = (versions - migrated).select { |v| v < version }
+          inserting << version unless migrated.include?(version)
+          return if inserting.empty?
+
+          duplicated = inserting.tally.filter_map { |v, count| v if count > 1 }
+          raise <<~MSG.squish if duplicated.present?
+            Duplicate migration #{duplicated.first}.
+            Please renumber your migrations to resolve the conflict.
+          MSG
+
+          VersionedCommands::SchemaTable.new(pool).create_table
+          execute insert_versions_sql(inserting)
+        end
+
+        # Add proper support for schema load when using versioned commands
+        def insert_versions_sql(versions)
+          return super unless PostgreSQL.config.versioned_commands.enabled
+
+          commands = pool.migration_context.migration_commands.select do |migration|
+            versions.include?(migration.version)
+          end
+
+          return super if commands.empty?
+
+          table = quote_table_name(VersionedCommands::SchemaTable.new(pool).table_name)
+
+          sql = super(versions - commands.map(&:version))
+          sql << "\nINSERT INTO #{table} (version, type, object_name) VALUES\n"
+          sql << commands.map do |m|
+            +"(#{quote(m.version)}, #{quote(m.type)}, #{quote(m.object_name)})"
+          end.join(",\n")
+          sql << ";"
+          sql
+        end
+
         private
 
           # Remove the schema from the sequence name

data/lib/torque/postgresql/arel/nodes.rb

@@ -19,6 +19,20 @@ module Torque
           end
         end
 
+        class Ref < ::Arel::Nodes::Unary
+          attr_reader :reference
+          alias to_s expr
+
+          def initialize(expr, reference = nil)
+            @reference = reference
+            super expr
+          end
+
+          def as(other)
+            @reference&.as(other) || super
+          end
+        end
+
       end
 
       ::Arel.define_singleton_method(:array) do |*values, cast: nil|

data/lib/torque/postgresql/arel/visitors.rb

@@ -25,6 +25,10 @@ module Torque
         end
 
         ## TORQUE VISITORS
+        def visit_Torque_PostgreSQL_Arel_Nodes_Ref(o, collector)
+          collector << quote_table_name(o.expr)
+        end
+
         # Allow casting any node
         def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
           visit(o.left, collector) << '::' << o.right

data/lib/torque/postgresql/attributes/builder/full_text_search.rb

@@ -6,7 +6,7 @@ module Torque
       module Builder
         class FullTextSearch
           attr_accessor :klass, :attribute, :options, :klass_module,
-            :default_rank, :default_order, :default_language
+            :default_rank, :default_mode, :default_order, :default_language
 
           def initialize(klass, attribute, options = {})
             @klass = klass
@@ -14,6 +14,7 @@ module Torque
             @options = options
 
             @default_rank = options[:with_rank] == true ? 'rank' : options[:with_rank]&.to_s
+            @default_mode = options[:mode] || PostgreSQL.config.full_text_search.default_mode
 
             @default_order =
               case options[:order]
@@ -53,30 +54,6 @@ module Torque
           end
 
           # Creates a class method as the scope that builds the full text search
-          #
-          # def full_text_search(value, order: :asc, rank: :rank, language: 'english', phrase: true)
-          #   attr = arel_table["search_vector"]
-          #   fn = ::Torque::PostgreSQL::FN
-          #
-          #   lang = language.to_s if !language.is_a?(::Symbol)
-          #   lang ||= arel_table[language.to_s].pg_cast(:regconfig) if has_attribute?(language)
-          #   lang ||= public_send(language) if respond_to?(language)
-          #
-          #   raise ArgumentError, <<~MSG.squish if lang.nil?
-          #     Unable to determine language from #{language.inspect}.
-          #   MSG
-          #
-          #   value = fn.bind(:value, value.to_s, attr.type_caster)
-          #   lang = fn.bind(:lang, lang, attr.type_caster) if lang.is_a?(::String)
-          #
-          #   query = fn.public_send(phrase ? :phraseto_tsquery : :to_tsquery, lang, value)
-          #   ranker = fn.ts_rank(attr, query) if rank || order
-          #
-          #   result = where(fn.infix(:"@@", attr, query))
-          #   result = result.order(ranker.public_send(order == :desc ? :desc : :asc)) if order
-          #   result.select_extra_values += [ranker.as(rank == true ? 'rank' : rank.to_s)] if rank
-          #   result
-          # end
           def add_scope_to_module
             klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{scope_name}(value#{scope_args})
@@ -87,14 +64,25 @@ module Torque
                 lang ||= arel_table[language.to_s] if has_attribute?(language)
                 lang ||= public_send(language) if respond_to?(language)
 
-                raise ::ArgumentError, <<~MSG.squish if lang.nil?
+                function = {
+                  default: :to_tsquery,
+                  phrase: :phraseto_tsquery,
+                  plain: :plainto_tsquery,
+                  web: :websearch_to_tsquery,
+                }[mode.to_sym]
+
+                raise ::ArgumentError, <<~MSG.squish if lang.blank?
                   Unable to determine language from \#{language.inspect}.
                 MSG
 
+                raise ::ArgumentError, <<~MSG.squish if function.nil?
+                  Invalid mode \#{mode.inspect} for full text search.
+                MSG
+
                 value = fn.bind(:value, value.to_s, attr.type_caster)
                 lang = fn.bind(:lang, lang, attr.type_caster) if lang.is_a?(::String)
 
-                query = fn.public_send(phrase ? :phraseto_tsquery : :to_tsquery, lang, value)
+                query = fn.public_send(function, lang, value)
                 ranker = fn.ts_rank(attr, query) if rank || order
 
                 result = where(fn.infix(:"@@", attr, query))
@@ -111,7 +99,7 @@ module Torque
             args << ", order: #{default_order.inspect}"
             args << ", rank: #{default_rank.inspect}"
             args << ", language: #{default_language.inspect}"
-            args << ", phrase: true"
+            args << ", mode: :#{default_mode}"
             args
           end
         end

data/lib/torque/postgresql/base.rb

@@ -17,7 +17,8 @@ module Torque
       end
 
       class_methods do
-        delegate :distinct_on, :with, :itself_only, :cast_records, to: :all
+        delegate :distinct_on, :with, :itself_only, :cast_records, :join_series,
+          :buckets, to: :all
 
         # Make sure that table name is an instance of TableName class
         def reset_table_name

data/lib/torque/postgresql/config.rb

@@ -22,6 +22,12 @@ module Torque
     # same configuration is set to true
     config.eager_load = false
 
+    # Add support for joining any query/association with a generated series
+    config.join_series = true
+
+    # Add support for querying and calculating histogram buckets
+    config.buckets = true
+
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
@@ -290,6 +296,14 @@ module Torque
       # Defines the default language when generating search vector columns
       fts.default_language = 'english'
 
+      # Defines the default mode to be used when generating full text search
+      # queries. It can be one of the following:
+      #   - :default (to_tsquery)
+      #   - :phrase (phraseto_tsquery)
+      #   - :plain (plainto_tsquery)
+      #   - :web (websearch_to_tsquery)
+      fts.default_mode = :phrase
+
       # Defines the default index type to be used when creating search vector.
       # It still requires that the column requests an index
       fts.default_index_type = :gin
@@ -303,7 +317,7 @@ module Torque
       builder.enabled = %i[regexp arel_attribute enumerator_lazy]
 
       # When active, values provided to array attributes will be handled more
-      # efficiently. It will use the +ANY+ operator on a equality check and
+      # friendly. It will use the +ANY+ operator on a equality check and
       # overlaps when the given value is an array
       builder.handle_array_attributes = false
 
@@ -318,5 +332,25 @@ module Torque
 
     end
 
+    # Configure versioned commands features
+    config.nested(:versioned_commands) do |vs|
+
+      # This is a feature that developers must explicitly opt-in. It is designed
+      # in a way that prevents a large impact on Rails' original migrations
+      # behavior. But, it is still a feature that everyone may not need, and
+      # some may complain about the additional schema table, which also uses
+      # inheritance
+      vs.enabled = false
+
+      # Define the list of commands that are going to be versioned by this
+      # method
+      vs.types = %i[function type view]
+
+      # The name of the table that will inherit from +schema_migrations+ and
+      # store the list of versioned commands that have been executed
+      vs.table_name = 'schema_versioned_commands'
+
+    end
+
   end
 end

data/lib/torque/postgresql/function.rb

@@ -25,6 +25,14 @@ module Torque
           bind(arel_attribute.name, value, arel_attribute.type_caster)
         end
 
+        # A facilitator to create a bind param with a specific type
+        def bind_type(value, type = nil, name: 'value', cast: nil)
+          type ||= ruby_type_to_model_type(value)
+          type = ActiveModel::Type.lookup(type) if type.is_a?(Symbol)
+          result = bind(name, value, type)
+          cast ? result.pg_cast(cast) : result
+        end
+
         # A facilitator to create an infix operation
         def infix(op, left, right)
           ::Arel::Nodes::InfixOperation.new(op, left, right)
@@ -38,6 +46,12 @@ module Torque
           args.reduce { |left, right| infix(:"||", left, right) }
         end
 
+        # A simple helper to trick Rails into producing the right SQL for
+        # grouping operations
+        def group_by(arel, name)
+          Arel::Nodes::Ref.new(name.to_s, arel)
+        end
+
         # As of now, this indicates that it supports any direct calls, since
         # the idea is to simply map to an Arel function with the same name,
         # without checking if it actually exists
@@ -53,6 +67,25 @@ module Torque
           ::Arel::Nodes::NamedFunction.new(name.to_s.upcase, args)
         end
 
+        private
+
+          def ruby_type_to_model_type(value)
+            case value
+            when Integer then :integer
+            when Float then :float
+            when String then :string
+            when Time, ActiveSupport::TimeWithZone then :time
+            when TrueClass, FalseClass then :boolean
+            when DateTime then :datetime
+            when Date then :date
+            when BigDecimal then :decimal
+            when ActiveSupport::Duration
+              Adapter::OID::Interval.new
+            else
+              raise ArgumentError, "Cannot infer type from value: #{value.inspect}."
+            end
+          end
+
       end
     end
 

data/lib/torque/postgresql/railtie.rb

@@ -19,6 +19,17 @@ module Torque
             ActiveRecord::Base.belongs_to_many_required_by_default =
               torque_config.associations.belongs_to_many_required_by_default
 
+            ## General features
+            if torque_config.join_series
+              require_relative 'relation/join_series'
+              Relation.include(Relation::JoinSeries)
+            end
+
+            if torque_config.buckets
+              require_relative 'relation/buckets'
+              Relation.include(Relation::Buckets)
+            end
+
             ## Schemas Enabled Setup
             if (config = torque_config.schemas).enabled
               require_relative 'adapter/schema_overrides'
@@ -109,7 +120,21 @@ module Torque
             PostgreSQL::Arel.build_operations(torque_config.arel.infix_operators)
             if (mod = torque_config.arel.expose_function_helper_on&.to_s)
               parent, _, name = mod.rpartition('::')
-              parent.constantize.const_set(name, PostgreSQL::FN)
+              parent = parent ? parent.constantize : ::Object
+
+              raise ArgumentError, <<~MSG.squish if parent.const_defined?(name)
+                Unable to expose Arel function helper on #{mod} because the constant
+                #{name} is already defined on #{parent}. Please choose a different name.
+              MSG
+
+              parent.const_set(name, PostgreSQL::FN)
+            end
+
+            ## Versioned Commands Setup
+            if (config = torque_config.versioned_commands).enabled
+              require_relative 'versioned_commands'
+
+              ActiveRecord::Schema::Definition.include(Adapter::Definition)
             end
 
             # Make sure to load all the types that are handled by this gem on

data/lib/torque/postgresql/relation/auxiliary_statement.rb

@@ -6,9 +6,14 @@ module Torque
       module AuxiliaryStatement
 
         # :nodoc:
-        def auxiliary_statements_values; get_value(:auxiliary_statements); end
+        def auxiliary_statements_values
+          @values.fetch(:auxiliary_statements, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
+        def auxiliary_statements_values=(value)
+          assert_modifiable!
+          @values[:auxiliary_statements] = value
+        end
 
         # Set use of an auxiliary statement
         def with(*args, **settings)