torque-postgresql 4.0.0.rc1 → 4.0.0

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Relation
+      module Buckets
+
+        # :nodoc:
+        def buckets_value
+          @values.fetch(:buckets, nil)
+        end
+        # :nodoc:
+        def buckets_value=(value)
+          assert_modifiable!
+          @values[:buckets] = value
+        end
+
+        # Specifies how to bucket records. It works for both the calculations
+        # or just putting records into groups. For example:
+        #
+        #   User.buckets(:created_at, [1.year.ago, 1.month.ago, 1.week.ago])
+        #   # Returns all users grouped by created_at in the given time ranges
+        #
+        #   User.buckets(:age, 0..100, step: 10).count
+        #   # Counts all users grouped by age buckets of 10 years
+        def buckets(*value, **xargs)
+          spawn.buckets!(*value, **xargs)
+        end
+
+        # Like #buckets, but modifies relation in place.
+        def buckets!(attribute, values, count: nil, cast: nil, as: nil)
+          raise ArgumentError, <<~MSG.squish if !values.is_a?(Array) && !values.is_a?(Range)
+            Buckets must be an array or a range.
+          MSG
+
+          count ||= 1 if values.is_a?(Range)
+          attribute = arel_table[attribute] unless ::Arel.arel_node?(attribute)
+          self.buckets_value = [attribute, values, count, cast, as]
+          self
+        end
+
+        # When performing calculations with buckets, this method add a grouping
+        # clause to the query by the bucket values, and then adjust the keys
+        # to match provided values
+        def calculate(*)
+          return super if buckets_value.blank?
+
+          raise ArgumentError, <<~MSG.squish if group_values.present?
+            Cannot calculate with buckets when there are already group values.
+          MSG
+
+          keys = buckets_keys
+          self.group_values = [FN.group_by(build_buckets_node, :bucket)]
+          super.transform_keys { |key| keys[key - 1] }
+        end
+
+        module Initializer
+          # Hook into the output of records to make sure we group by the buckets
+          def records
+            return super if buckets_value.blank?
+
+            keys = buckets_keys
+            col = buckets_column
+            super.group_by do |record|
+              val = (record[col] || 0) - 1
+              keys[val] if val >= 0 && val < keys.size
+            end
+          end
+        end
+
+        private
+
+          # Hook arel build to add the column
+          def build_arel(*)
+            return super if buckets_value.blank? || select_values.present?
+
+            self.select_extra_values += [build_buckets_node.as(buckets_column)]
+            super
+          end
+
+          # Build the Arel node for the buckets function
+          def build_buckets_node
+            attribute, values, count, cast, * = buckets_value
+
+            if values.is_a?(Range)
+              FN.width_bucket(
+                attribute,
+                FN.bind_type(values.begin, name: 'bucket_start', cast: 'numeric'),
+                FN.bind_type(values.end, name: 'bucket_end', cast: 'numeric'),
+                FN.bind_type(count, name: 'bucket_count', cast: 'integer'),
+              )
+            else
+              FN.width_bucket(attribute, ::Arel.array(values, cast: cast))
+            end
+          end
+
+          # Returns the column used for buckets, if any
+          def buckets_column
+            buckets_value.last&.to_s || 'bucket'
+          end
+
+          # Transform a range into the proper keys for buckets
+          def buckets_keys
+            keys = buckets_value.second
+            return keys unless keys.is_a?(Range)
+
+            left = nil
+            step = buckets_value.third
+            step = (keys.end - keys.begin).fdiv(step)
+            step = step.to_i if step.to_i == step
+            keys.step(step).each_with_object([]) do |right, result|
+              next left = right if left.nil?
+
+              start, left = left, right
+              result << Range.new(start, left, true)
+            end
+          end
+
+      end
+
+      Initializer.include(Buckets::Initializer)
+    end
+  end
+end

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

@@ -6,9 +6,14 @@ module Torque
       module DistinctOn
 
         # :nodoc:
-        def distinct_on_values; get_value(:distinct_on); end
+        def distinct_on_values
+          @values.fetch(:distinct_on, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def distinct_on_values=(value); set_value(:distinct_on, value); end
+        def distinct_on_values=(value)
+          assert_modifiable!
+          @values[:distinct_on] = value
+        end
 
         # Specifies whether the records should be unique or not by a given set
         # of fields. For example:

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

@@ -6,14 +6,24 @@ module Torque
       module Inheritance
 
         # :nodoc:
-        def cast_records_value; get_value(:cast_records); end
+        def cast_records_values
+          @values.fetch(:cast_records, FROZEN_EMPTY_ARRAY)
+        end
         # :nodoc:
-        def cast_records_value=(value); set_value(:cast_records, value); end
+        def cast_records_values=(value)
+          assert_modifiable!
+          @values[:cast_records] = value
+        end
 
         # :nodoc:
-        def itself_only_value; get_value(:itself_only); end
+        def itself_only_value
+          @values.fetch(:itself_only, nil)
+        end
         # :nodoc:
-        def itself_only_value=(value); set_value(:itself_only, value); end
+        def itself_only_value=(value)
+          assert_modifiable!
+          @values[:itself_only] = value
+        end
 
         delegate :quote_table_name, :quote_column_name, to: :connection
 
@@ -46,7 +56,7 @@ module Torque
         def cast_records!(*types, **options)
           where!(regclass.pg_cast(:varchar).in(types.map(&:table_name))) if options[:filter]
           self.select_extra_values += [regclass.as(_record_class_attribute.to_s)]
-          self.cast_records_value = (types.present? ? types : model.casted_dependents.values)
+          self.cast_records_values = (types.present? ? types : model.casted_dependents.values)
           self
         end
 
@@ -62,11 +72,11 @@ module Torque
 
           # Build all necessary data for inheritances
           def build_inheritances(arel)
-            return unless self.cast_records_value.present?
+            return if self.cast_records_values.empty?
 
             mergeable = inheritance_mergeable_attributes
 
-            columns = build_inheritances_joins(arel, self.cast_records_value)
+            columns = build_inheritances_joins(arel, self.cast_records_values)
             columns = columns.map do |column, arel_tables|
               next arel_tables.first[column] if arel_tables.size == 1
 
@@ -77,7 +87,7 @@ module Torque
               end
             end
 
-            columns.push(build_auto_caster_marker(arel, self.cast_records_value))
+            columns.push(build_auto_caster_marker(arel, self.cast_records_values))
             self.select_extra_values += columns.flatten if columns.any?
           end
 

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Relation
+      module JoinSeries
+
+        # Create the proper arel join
+        class << self
+          def build(relation, range, with: nil, as: :series, step: nil, time_zone: nil, mode: :inner, &block)
+            validate_build!(range, step)
+
+            args = [bind_value(range.begin), bind_value(range.end)]
+            args << bind_value(step) if step
+            args << bind_value(time_zone) if time_zone
+
+            result = Arel::Nodes::Ref.new(as.to_s)
+            func = FN.generate_series(*args).as(as.to_s)
+            condition = build_join_on(result, relation, with, &block)
+            arel_join(mode).new(func, func.create_on(condition))
+          end
+
+          private
+
+            # Make sure we have a viable range
+            def validate_build!(range, step)
+              raise ArgumentError, <<~MSG.squish unless range.is_a?(Range)
+                Value must be a Range.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if range.begin.nil?
+                Beginless Ranges are not supported.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if range.end.nil?
+                Endless Ranges are not supported.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if !range.begin.is_a?(Numeric) && step.nil?
+                missing keyword: :step
+              MSG
+            end
+
+            # Creates the proper bind value
+            def bind_value(value)
+              case value
+              when Integer
+                FN.bind_type(value, :integer, name: 'series', cast: 'integer')
+              when Float
+                FN.bind_type(value, :float, name: 'series', cast: 'numeric')
+              when String
+                FN.bind_type(value, :string, name: 'series', cast: 'text')
+              when ActiveSupport::TimeWithZone
+                FN.bind_type(value, :time, name: 'series', cast: 'timestamptz')
+              when Time
+                FN.bind_type(value, :time, name: 'series', cast: 'timestamp')
+              when DateTime
+                FN.bind_type(value, :datetime, name: 'series', cast: 'timestamp')
+              when ActiveSupport::Duration
+                type = Adapter::OID::Interval.new
+                FN.bind_type(value, type, name: 'series', cast: 'interval')
+              when Date then bind_value(value.to_time(:utc))
+              when ::Arel::Attributes::Attribute then value
+              else
+                raise ArgumentError, "Unsupported value type: #{value.class}"
+              end
+            end
+
+            # Get the class of the join on arel
+            def arel_join(mode)
+              case mode.to_sym
+              when :inner then ::Arel::Nodes::InnerJoin
+              when :left  then ::Arel::Nodes::OuterJoin
+              when :right then ::Arel::Nodes::RightOuterJoin
+              when :full  then ::Arel::Nodes::FullOuterJoin
+              else
+                raise ArgumentError, <<-MSG.squish
+                  The '#{mode}' is not implemented as a join type.
+                MSG
+              end
+            end
+
+            # Build the join on clause
+            def build_join_on(result, relation, with)
+              raise ArgumentError, <<~MSG.squish if with.nil? && !block_given?
+                missing keyword: :with
+              MSG
+
+              return yield(result, relation.arel_table) if block_given?
+
+              result.eq(with.is_a?(Symbol) ? relation.arel_table[with.to_s] : with)
+            end
+        end
+
+        # Creates a new join based on PG +generate_series()+ function. It is
+        # based on ranges, supports numbers and dates (as per PG documentation),
+        # custom stepping, time zones, and more. This simply coordinates the
+        # initialization of the the proper join
+        def join_series(range, **xargs, &block)
+          spawn.join_series!(range, **xargs, &block)
+        end
+
+        # Like #join_series, but modifies relation in place.
+        def join_series!(range, **xargs, &block)
+          self.joins_values |= [JoinSeries.build(self, range, **xargs, &block)]
+          self
+        end
+
+      end
+    end
+  end
+end

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

@@ -12,6 +12,7 @@ module Torque
           merge_distinct_on
           merge_auxiliary_statements
           merge_inheritance
+          merge_buckets
 
           relation
         end
@@ -26,12 +27,15 @@ module Torque
 
           # Merge distinct on columns
           def merge_distinct_on
+            return unless relation.is_a?(Relation::DistinctOn)
             return if other.distinct_on_values.blank?
+
             relation.distinct_on_values += other.distinct_on_values
           end
 
           # Merge auxiliary statements activated by +with+
           def merge_auxiliary_statements
+            return unless relation.is_a?(Relation::AuxiliaryStatement)
             return if other.auxiliary_statements_values.blank?
 
             current = relation.auxiliary_statements_values.map{ |cte| cte.class }
@@ -44,14 +48,24 @@ module Torque
 
           # Merge settings related to inheritance tables
           def merge_inheritance
+            return unless relation.is_a?(Relation::Inheritance)
+
             relation.itself_only_value = true if other.itself_only_value.present?
 
-            if other.cast_records_value.present?
-              relation.cast_records_value += other.cast_records_value
-              relation.cast_records_value.uniq!
+            if other.cast_records_values.present?
+              relation.cast_records_values += other.cast_records_values
+              relation.cast_records_values.uniq!
             end
           end
 
+          # Merge settings related to buckets
+          def merge_buckets
+            return unless relation.is_a?(Relation::Buckets)
+            return if other.buckets_value.blank?
+
+            relation.buckets_value = other.buckets_value
+          end
+
       end
 
       ActiveRecord::Relation::Merger.prepend Merger

data/lib/torque/postgresql/relation.rb

@@ -13,16 +13,25 @@ module Torque
       include DistinctOn
       include Inheritance
 
-      SINGLE_VALUE_METHODS = [:itself_only]
-      MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records, :select_extra]
+      SINGLE_VALUE_METHODS = %i[itself_only buckets]
+      MULTI_VALUE_METHODS = %i[
+        select_extra distinct_on auxiliary_statements cast_records
+      ]
+
       VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
+      FROZEN_EMPTY_ARRAY = ::ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
 
       ARColumn = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Column
 
       # :nodoc:
-      def select_extra_values; get_value(:select_extra); end
+      def select_extra_values
+        @values.fetch(:select_extra, FROZEN_EMPTY_ARRAY)
+      end
       # :nodoc:
-      def select_extra_values=(value); set_value(:select_extra, value); end
+      def select_extra_values=(value)
+        assert_modifiable!
+        @values[:select_extra] = value
+      end
 
       # Resolve column name when calculating models, allowing the column name to
       # be more complex while keeping the query selection quality
@@ -90,21 +99,6 @@ module Torque
           arel
         end
 
-        # Compatibility method with 5.0
-        unless ActiveRecord::Relation.method_defined?(:get_value)
-          def get_value(name)
-            @values[name] || ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
-          end
-        end
-
-        # Compatibility method with 5.0
-        unless ActiveRecord::Relation.method_defined?(:set_value)
-          def set_value(name, value)
-            assert_mutability! if respond_to?(:assert_mutability!)
-            @values[name] = value
-          end
-        end
-
       class_methods do
         # Easy and storable way to access the name used to get the record table
         # name when using inheritance tables
@@ -145,15 +139,11 @@ module Torque
     ActiveRecord::Relation.include Relation
     ActiveRecord::Relation.prepend Relation::Initializer
 
-    warn_level = $VERBOSE
-    $VERBOSE = nil
-
-    ActiveRecord::Relation::SINGLE_VALUE_METHODS       += Relation::SINGLE_VALUE_METHODS
-    ActiveRecord::Relation::MULTI_VALUE_METHODS        += Relation::MULTI_VALUE_METHODS
-    ActiveRecord::Relation::VALUE_METHODS              += Relation::VALUE_METHODS
-    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += %i[cast_records itself_only
-      distinct_on auxiliary_statements]
+    ActiveRecord::Relation::SINGLE_VALUE_METHODS.concat(Relation::SINGLE_VALUE_METHODS)
+    ActiveRecord::Relation::MULTI_VALUE_METHODS.concat(Relation::MULTI_VALUE_METHODS)
+    ActiveRecord::Relation::VALUE_METHODS.concat(Relation::VALUE_METHODS)
+    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES.merge(%i[cast_records itself_only
+      distinct_on auxiliary_statements buckets])
 
-    $VERBOSE = warn_level
   end
 end

data/lib/torque/postgresql/version.rb

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

data/lib/torque/postgresql/versioned_commands/command_migration.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Migration
+        def initialize(*args)
+          @command = args.pop
+          super(*args)
+        end
+
+        # Prepare the description based on the direction
+        def migrate(direction)
+          @description = description_for(direction)
+          super
+        end
+
+        # Uses the command to execute the proper action
+        def exec_migration(conn, direction)
+          @connection = conn
+          direction == :up ? @command.up : @command.down
+        ensure
+          @connection = nil
+          @execution_strategy = nil
+        end
+
+        # Better formatting of the output
+        def announce(message)
+          action, result = @description
+
+          title = [
+            @command.type.capitalize,
+            @command.object_name,
+            "v#{@command.op_version}"
+          ].join(' ')
+
+          timing = message.split(' ', 2).second
+          action = "#{result} #{timing}" if timing.present?
+          text = "#{@command.version} #{title}: #{action}"
+          length = [0, 75 - text.length].max
+
+          write "== %s %s" % [text, "=" * length]
+        end
+
+        # Produces a nice description of what is being done
+        def description_for(direction)
+          base = @command.op.chomp('e') if direction == :up
+          base ||=
+            case @command.op
+            when 'create' then 'dropp'
+            when 'update' then 'revert'
+            when 'remove' then 're-creat'
+            end
+
+          ["#{base}ing", "#{base}ed"]
+        end
+
+        # Print the command and then execute it
+        def execute(command)
+          write "-- #{command.gsub(/(?<!\A)^/, '   ').gsub(/[\s\n]*\z/, '')}"
+          execution_strategy.execute(command)
+        end
+      end
+
+      CommandMigration = Struct.new(*%i[filename version op type object_name op_version scope]) do
+        delegate :execute, to: '@migration'
+
+        def initialize(filename, *args)
+          super(File.expand_path(filename), *args)
+          @migration = nil
+        end
+
+        # Rails uses this to avoid duplicate migrations
+        def name
+          "#{op}_#{type}_#{object_name}_v#{op_version}"
+        end
+
+        # There is no way to setup this, so it is always false
+        def disable_ddl_transaction
+          false
+        end
+
+        # Down is more complicated, then this just starts separating the logic
+        def migrate(direction)
+          @migration = ActiveRecord::Migration.allocate
+          @migration.extend(Migration)
+          @migration.send(:initialize, name, version, self)
+          @migration.migrate(direction)
+        ensure
+          @migration = nil
+        end
+
+        # Simply executes the underlying command
+        def up
+          content = File.read(filename)
+          VersionedCommands.validate!(type, content, object_name)
+          execute content
+        end
+
+        # Find the previous command and executes it
+        def down
+          return drop if op_version == 1
+          dirs = @migration.pool.migrations_paths
+          version = op_version - (op == 'remove' ? 0 : 1)
+          execute VersionedCommands.fetch_command(dirs, type, object_name, version)
+        end
+
+        # Drops the type created
+        def drop
+          method_name = :"drop_#{type}"
+          return send(method_name) if VersionedCommands.valid_type?(type)
+          raise ArgumentError, "Unknown versioned command type: #{type}"
+        end
+
+        private
+
+          # Drop all functions all at once
+          def drop_function
+            definitions = File.read(filename).scan(Regexp.new([
+              "FUNCTION\\s+#{NAME_MATCH}",
+              '\s*(\([_a-z0-9 ,]*\))?',
+            ].join, 'mi'))
+
+            functions = definitions.map(&:join).join(', ')
+            execute "DROP FUNCTION #{functions};"
+          end
+
+          # Drop the type
+          def drop_type
+            name = File.read(filename).scan(Regexp.new("TYPE\\s+#{NAME_MATCH}", 'mi'))
+            execute "DROP TYPE #{name.first.first};"
+          end
+
+          # Drop view or materialized view
+          def drop_view
+            mat, name = File.read(filename).scan(Regexp.new([
+              '(MATERIALIZED)?\s+(?:RECURSIVE\s+)?',
+              "VIEW\\s+#{NAME_MATCH}",
+            ].join, 'mi')).first
+
+            execute "DROP#{' MATERIALIZED' if mat.present?} VIEW #{name};"
+          end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/versioned_commands/generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+require 'rails/generators/active_record/migration'
+
+module Torque
+  module PostgreSQL
+    module VersionedCommands
+      module Generator
+        TEMPLATES_PATH = '../../../generators/torque/templates'
+
+        attr_reader :file_name
+
+        def self.included(base)
+          type = base.name.demodulize.chomp('Generator').underscore
+
+          base.send(:source_root, File.expand_path(TEMPLATES_PATH, __dir__))
+          base.include(ActiveRecord::Generators::Migration)
+
+          base.instance_variable_set(:@type, type)
+          base.instance_variable_set(:@desc, <<~DESC.squish)
+            Generates a migration for creating, updating, or removing a #{type}.
+          DESC
+
+          base.class_option :operation, type: :string, aliases: %i(--op),
+            desc: 'The name for the operation'
+
+          base.argument :name, type: :string,
+            desc: "The name of the #{type}"
+        end
+
+        def type
+          self.class.instance_variable_get(:@type)
+        end
+
+        def create_migration_file
+          version = count_object_entries
+          operation = options[:operation] || (version == 0 ? 'create' : 'update')
+          @file_name = "#{operation}_#{type}_#{name.underscore}_v#{version + 1}"
+
+          validate_file_name!
+          migration_template "#{type}.sql.erb", File.join(db_migrate_path, "#{file_name}.sql")
+        end
+
+        def count_object_entries
+          Dir.glob("#{db_migrate_path}/*_#{type}_#{name.underscore}_v*.sql").size
+        end
+
+        def validate_file_name!
+          unless /^[_a-z0-9]+$/.match?(file_name)
+            raise ActiveRecord::IllegalMigrationNameError.new(file_name)
+          end
+        end
+      end
+    end
+  end
+end