torque-postgresql 0.1.7 → 0.2.1

data/lib/torque/postgresql/coder.rb

@@ -0,0 +1,132 @@
+module Torque
+  module PostgreSQL
+    module Coder
+
+      # This class represents an Record to be encoded, instead of a literal Array
+      class Record < Array
+      end
+
+      class << self
+
+        NEED_QUOTE_FOR = /[\\"(){}, \t\n\r\v\f]/m
+        DELIMITER = ','.freeze
+
+        # This method replace the +read_array+ method from PG gem
+        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_decoder.c#L177
+        # for more information
+        def decode(value)
+          # TODO: Use StringScanner
+          # See http://ruby-doc.org/stdlib-1.9.3/libdoc/strscan/rdoc/StringScanner.html
+          _decode(::StringIO.new(value))
+        end
+
+        # This method replace the ++ method from PG gem
+        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_encoder.c#L398
+        # for more information
+        def encode(value)
+          _encode(value)
+        end
+
+        private
+
+          def _decode(stream)
+            quoted = 0
+            escaped = false
+            result = []
+            part = ''
+
+            # Always start getting the non-collection character, the second char
+            stream.getc if stream.pos == 0
+
+            # Check for an empty list
+            return result if %w[} )].include?(stream.getc)
+
+            # If it's not an empty list, return one position before iterating
+            stream.pos -= 1
+            stream.each_char do |c|
+
+              case
+              when quoted < 1
+                case
+                when c == DELIMITER, c == '}', c == ')'
+
+                  unless escaped
+                    # Non-quoted empty string or NULL as extense
+                    part = nil if quoted == 0 && ( part.length == 0 || part == 'NULL' )
+                    result << part
+                  end
+
+                  return result unless c == DELIMITER
+
+                  escaped = false
+                  quoted = 0
+                  part = ''
+
+                when c == '"'
+                  quoted = 1
+                when c == '{', c == '('
+                  result << _decode(stream)
+                  escaped = true
+                else
+                  part << c
+                end
+              when escaped
+                escaped = false
+                part << c
+              when c == '\\'
+                escaped = true
+              when c == '"'
+                if stream.getc == '"'
+                  part << c
+                else
+                  stream.pos -= 1
+                  quoted = -1
+                end
+              else
+                if ( c == '"' || c == "'" ) && stream.getc != c
+                  stream.pos -= 1
+                  quoted = -1
+                else
+                  part << c
+                end
+              end
+
+            end
+          end
+
+          def _encode(list)
+            is_record = list.is_a?(Record)
+            list.map! do |part|
+              case part
+              when NilClass
+                is_record ? '' : 'NULL'
+              when Array
+                _encode(part)
+              else
+                _quote(part.to_s)
+              end
+            end
+
+            result = is_record ? '(%s)' : '{%s}'
+            result % list.join(DELIMITER)
+          end
+
+          def _quote(string)
+            len = string.length
+
+            # Fast results
+            return '""' if len == 0
+            return '"NULL"' if len == 4 && string == 'NULL'
+
+            # Check if the string don't need quotes
+            return string unless string =~ NEED_QUOTE_FOR
+
+            # Use the original string escape function
+            PG::Connection.escape_string(string).inspect
+          end
+
+      end
+
+    end
+  end
+end

data/lib/torque/postgresql/collector.rb

@@ -2,6 +2,8 @@ module Torque
   module PostgreSQL
     module Collector
 
+      # This classe helps to collect data in different ways. Used to configure
+      # auxiliary statements
       def self.new(*args)
         klass = Class.new
 

data/lib/torque/postgresql/config.rb

@@ -3,12 +3,26 @@ module Torque
     include ActiveSupport::Configurable
 
     # Allow nested configurations
+    # :TODO: Rely on +inheritable_copy+ to make nested configurations
     config.define_singleton_method(:nested) do |name, &block|
       klass = Class.new(ActiveSupport::Configurable::Configuration).new
       block.call(klass) if block
       send("#{name}=", klass)
     end
 
+    # Set if any information that requires querying and searching or collectiong
+    # information shuld be eager loaded. This automatically changes when rails
+    # same configuration is set to true
+    config.eager_load = false
+
+    # Set a list of irregular model name when associated with table names
+    config.irregular_models = {}
+    def config.irregular_models=(hash)
+      PostgreSQL.config[:irregular_models] = hash.map do |(table, model)|
+        [table.to_s, model.to_s]
+      end.to_h
+    end
+
     # Configure ENUM features
     config.nested(:enum) do |enum|
 
@@ -51,7 +65,27 @@ module Torque
 
       # Define the key that is used on auxiliary statements to send extra
       # arguments to format string or send on a proc
-      cte.send_arguments_key = :uses
+      cte.send_arguments_key = :args
+
+    end
+
+    # Configure inheritance features
+    config.nested(:inheritance) do |inheritance|
+
+      # Define the lookup of models from their given name to be inverted, which
+      # means that they are going to be form the last namespaced one to the
+      # most namespaced one
+      inheritance.inverse_lookup = true
+
+      # Determines the name of the column used to collect the table of each
+      # record. When the table has inheritance tables, this column will return
+      # the name of the table that actually holds the record
+      inheritance.record_class_column_name = :_record_class
+
+      # Determines the name of the column used when identifying that the loaded
+      # records should be casted to its correctly model. This will be TRUE for
+      # the records mentioned on `cast_records`
+      inheritance.auto_cast_column_name = :_auto_cast
 
     end
 

data/lib/torque/postgresql/inheritance.rb

@@ -0,0 +1,133 @@
+module Torque
+  module PostgreSQL
+    InheritanceError = Class.new(ArgumentError)
+
+    module Inheritance
+      extend ActiveSupport::Concern
+
+      # Cast the given object to its correct class
+      def cast_record
+        record_class_value = send(self.class._record_class_attribute)
+
+        return self unless self.class.table_name != record_class_value
+        klass = self.class.casted_dependents[record_class_value]
+        self.class.raise_unable_to_cast(record_class_value) if klass.nil?
+
+        # The record need to be re-queried to have its attributes loaded
+        # :TODO: Improve this by only loading the necessary extra columns
+        klass.find(self.id)
+      end
+
+      private
+
+        def using_single_table_inheritance?(record) # :nodoc:
+          self.class.physically_inherited? || super
+        end
+
+      module ClassMethods
+
+        delegate :_auto_cast_attribute, :_record_class_attribute, to: ActiveRecord::Relation
+
+        # Manually set the model name associated with tables name in order to
+        # facilitates the identification of inherited records
+        def inherited(subclass)
+          super
+
+          return unless Torque::PostgreSQL.config.eager_load &&
+            !subclass.abstract_class?
+
+          connection.schema_cache.add_model_name(table_name, subclass)
+        end
+
+        # Get a full list of all attributes from a model and all its dependents
+        def inheritance_merged_attributes
+          @inheritance_merged_attributes ||= begin
+            list = attribute_names
+            list += casted_dependents.values.map(&:attribute_names)
+            list.flatten.to_set.freeze
+          end
+        end
+
+        # Check if the model's table depends on any inheritance
+        def physically_inherited?
+          @physically_inherited ||= connection.schema_cache.dependencies(
+            defined?(@table_name) ? @table_name : decorated_table_name,
+          ).present?
+        end
+
+        # Get the list of all tables directly or indirectly dependent of the
+        # current one
+        def inheritance_dependents
+          connection.schema_cache.associations(table_name) || []
+        end
+
+        # Check whether the model's table has directly or indirectly dependents
+        def physically_inheritances?
+          inheritance_dependents.present?
+        end
+
+        # Get the list of all ActiveRecord classes directly or indirectly
+        # associated by inheritance
+        def casted_dependents
+          @casted_dependents ||= inheritance_dependents.map do |table_name|
+            [table_name, connection.schema_cache.lookup_model(table_name)]
+          end.to_h
+        end
+
+        # Get the final decorated table, regardless of any special condition
+        def decorated_table_name
+          if parent < Base && !parent.abstract_class?
+            contained = parent.table_name
+            contained = contained.singularize if parent.pluralize_table_names
+            contained += "_"
+          end
+
+          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
+        end
+
+        # Add an additional check to return the name of the table even when the
+        # class is inherited, but only if it is a physical inheritance
+        def compute_table_name
+          return super unless physically_inherited?
+          decorated_table_name
+        end
+
+        # Raises an error message saying that the giver record class was not
+        # able to be casted since the model was not identified
+        def raise_unable_to_cast(record_class_value)
+          raise InheritanceError.new(<<~MSG.squish)
+            An record was not able to be casted to type '#{record_class_value}'.
+            If this table name doesn't represent a guessable model,
+            please use 'Torque::PostgreSQL.conf.irregular_models =
+            { '#{record_class_value}' => 'ModelName' }'.
+          MSG
+        end
+
+        private
+
+          def discriminate_class_for_record(record) # :nodoc:
+            auto_cast = _auto_cast_attribute.to_s
+            record_class = _record_class_attribute.to_s
+
+            return super unless record.key?(record_class) &&
+              record[auto_cast] === true && record[record_class] != table_name
+
+            klass = casted_dependents[record[record_class]]
+            raise_unable_to_cast(record[record_class]) if klass.nil?
+            filter_attributes_for_cast(record, klass)
+            klass
+          end
+
+          # Filter the record attributes to be loaded to not included those from
+          # another inherited dependent
+          def filter_attributes_for_cast(record, klass)
+            remove_attrs = (inheritance_merged_attributes - klass.attribute_names)
+            record.reject!{ |attribute| remove_attrs.include?(attribute) }
+          end
+
+      end
+    end
+
+    ActiveRecord::Base.include Inheritance
+  end
+end

data/lib/torque/postgresql/railtie.rb

@@ -0,0 +1,16 @@
+module Torque
+  module PostgreSQL
+    # = Torque PostgreSQL Railtie
+    class Railtie < Rails::Railtie # :nodoc:
+
+      # Eger load PostgreSQL namespace
+      config.eager_load_namespaces << Torque::PostgreSQL
+
+      # Get information from the running rails app
+      runner do |app|
+        Torque::PostgreSQL.config.eager_load = app.config.eager_load
+      end
+
+    end
+  end
+end

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

@@ -3,7 +3,10 @@ module Torque
     module Relation
       module AuxiliaryStatement
 
-        attr_accessor :auxiliary_statements
+        # :nodoc:
+        def auxiliary_statements_values; get_value(:auxiliary_statements); end
+        # :nodoc:
+        def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
 
         # Set use of an auxiliary statement already configurated on the model
         def with(*args)
@@ -13,46 +16,50 @@ module Torque
         # Like #with, but modifies relation in place.
         def with!(*args)
           options = args.extract_options!
-          self.auxiliary_statements ||= {}
           args.each do |table|
-            instance = instantiate(table, self, options)
+            instance = table.is_a?(PostgreSQL::AuxiliaryStatement) \
+              ? table.class.new(options) \
+              : PostgreSQL::AuxiliaryStatement.instantiate(table, self, options)
             instance.ensure_dependencies!(self)
-            self.auxiliary_statements[table] = instance
+            self.auxiliary_statements_values |= [instance]
           end
 
           self
         end
 
+        alias_method :auxiliary_statements, :with
+        alias_method :auxiliary_statements!, :with!
+
         # Get all auxiliary statements bound attributes and the base bound
         # attributes as well
         def bound_attributes
-          return super unless self.auxiliary_statements.present?
-          bindings = self.auxiliary_statements.values.map(&:bound_attributes)
+          return super unless self.auxiliary_statements_values.present?
+          bindings = self.auxiliary_statements_values.map(&:bound_attributes)
           (bindings + super).flatten
         end
 
         private
-          delegate :instantiate, to: PostgreSQL::AuxiliaryStatement
 
           # Hook arel build to add the distinct on clause
           def build_arel
             arel = super
+            build_auxiliary_statements(arel)
+            arel
+          end
 
-            if self.auxiliary_statements.present?
-              columns = []
-              subqueries = self.auxiliary_statements.values.map do |klass|
-                columns << klass.columns
-                klass.build_arel(arel, self)
-              end
+          # Build all necessary data for auxiliary statements
+          def build_auxiliary_statements(arel)
+            return unless self.auxiliary_statements_values.present?
 
-              arel.with(subqueries.flatten)
-              if select_values.empty? && columns.any?
-                columns.unshift table[::Arel.star]
-                arel.projections = columns
-              end
+            columns = []
+            subqueries = self.auxiliary_statements_values.map do |klass|
+              columns << klass.columns
+              klass.build_arel(arel, self)
             end
 
-            arel
+            columns.flatten!
+            arel.with(subqueries.flatten)
+            arel.project(*columns) if columns.any?
           end
 
           # Throw an error showing that an auxiliary statement of the given

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

@@ -3,10 +3,13 @@ module Torque
     module Relation
       module DistinctOn
 
-        attr_accessor :distinct_on_value
+        # :nodoc:
+        def distinct_on_values; get_value(:distinct_on); end
+        # :nodoc:
+        def distinct_on_values=(value); set_value(:distinct_on, value); end
 
-        # Specifies whether the records should be unique or not by a given set of fields.
-        # For example:
+        # Specifies whether the records should be unique or not by a given set
+        # of fields. For example:
         #
         #   User.distinct_on(:name)
         #   # Returns 1 record per distinct name
@@ -22,7 +25,7 @@ module Torque
 
         # Like #distinct_on, but modifies relation in place.
         def distinct_on!(*value)
-          self.distinct_on_value = value
+          self.distinct_on_values = value
           self
         end
 
@@ -31,9 +34,8 @@ module Torque
           # Hook arel build to add the distinct on clause
           def build_arel
             arel = super
-
-            value = self.distinct_on_value
-            arel.distinct_on(resolve_column(value)) unless value.nil?
+            value = self.distinct_on_values
+            arel.distinct_on(resolve_column(value)) if value.present?
             arel
           end
 

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

@@ -0,0 +1,112 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Inheritance
+
+        # :nodoc:
+        def cast_records_value; get_value(:cast_records); end
+        # :nodoc:
+        def cast_records_value=(value); set_value(:cast_records, value); end
+
+        # :nodoc:
+        def itself_only_value; get_value(:itself_only); end
+        # :nodoc:
+        def itself_only_value=(value); set_value(:itself_only, value); end
+
+        delegate :quote_table_name, :quote_column_name, to: :connection
+
+        # Specify that the results should come only from the table that the
+        # entries were created on. For example:
+        #
+        #   Activity.itself_only
+        #   # Does not return entries for inherited tables
+        def itself_only
+          spawn.itself_only!
+        end
+
+        # Like #itself_only, but modifies relation in place.
+        def itself_only!(*)
+          self.itself_only_value = true
+          self
+        end
+
+        # Enables the casting of all returned records. The result will include
+        # all the information needed to instantiate the inherited models
+        #
+        #   Activity.cast_records
+        #   # The result list will have many different classes, for all
+        #   # inherited models of activities
+        def cast_records(*types, **options)
+          spawn.cast_records!(*types, **options)
+        end
+
+        # Like #cast_records, but modifies relation in place
+        def cast_records!(*types, **options)
+          record_class = self.class._record_class_attribute
+
+          with!(record_class)
+          where!(record_class => types.map(&:table_name)) if options[:filter]
+
+          self.cast_records_value = (types.present? ? types : model.casted_dependents.values)
+          self
+        end
+
+        private
+
+          # Hook arel build to add any necessary table
+          def build_arel
+            arel = super
+            arel.only if self.itself_only_value === true
+            build_inheritances(arel)
+            arel
+          end
+
+          # Build all necessary data for inheritances
+          def build_inheritances(arel)
+            return unless self.cast_records_value.present?
+
+            columns = build_inheritances_joins(arel, self.cast_records_value)
+            columns = columns.map do |column, arel_tables|
+              next arel_tables.first[column] if arel_tables.size == 1
+              list = arel_tables.each_with_object(column).map(&:[])
+              ::Arel::Nodes::NamedFunction.new('COALESCE', list).as(column)
+            end
+
+            columns.push(build_auto_caster_marker(arel, self.cast_records_value))
+            arel.project(*columns) if columns.any?
+          end
+
+          # Build as many left outer join as necessary for each dependent table
+          def build_inheritances_joins(arel, types)
+            columns = Hash.new{ |h, k| h[k] = [] }
+            primary_key = quoted_primary_key
+            base_attributes = model.attribute_names
+
+            # Iterate over each casted dependent calculating the columns
+            types.each.with_index do |model, idx|
+              join_table = model.arel_table.alias("\"i_#{idx}\"")
+              arel.outer_join(join_table).using(primary_key)
+              (model.attribute_names - base_attributes).each do |column|
+                columns[column] << join_table
+              end
+            end
+
+            # Return the list of needed columns
+            columns.default_proc = nil
+            columns
+          end
+
+          def build_auto_caster_marker(arel, types)
+            types = types.map(&:table_name)
+            type_attribute = self.class._record_class_attribute.to_s
+            auto_cast_attribute = self.class._auto_cast_attribute.to_s
+
+            table = ::Arel::Table.new(type_attribute.camelize.underscore)
+            column = table[type_attribute].in(types)
+            ::Arel::Nodes::SqlLiteral.new(column.to_sql).as(auto_cast_attribute)
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Torque
+  module PostgreSQL
+    module Relation
+      module Merger
+
+        def merge # :nodoc:
+          super
+
+          merge_distinct_on
+          merge_auxiliary_statements
+          merge_inheritance
+
+          relation
+        end
+
+        private
+
+          # Merge distinct on columns
+          def merge_distinct_on
+            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 if other.auxiliary_statements_values.blank?
+
+            current = relation.auxiliary_statements_values.map{ |cte| cte.class }
+            other.auxiliary_statements_values.each do |other|
+              next if current.include?(other.class)
+              relation.auxiliary_statements_values += [other]
+              current << other.class
+            end
+          end
+
+          # Merge settings related to inheritance tables
+          def merge_inheritance
+            relation.itself_only_value = true if other.itself_only_value
+            relation.cast_records_value.concat(other.cast_records_value).uniq! \
+              if other.cast_records_value.present?
+          end
+
+      end
+
+      ActiveRecord::Relation::Merger.prepend Merger
+    end
+  end
+end