babik 0.1.0

data/Rakefile

@@ -0,0 +1,18 @@
+# inside tasks/test.rake
+require 'rake/testtask'
+
+desc 'Run tests'
+Rake::TestTask.new(:test) do |t|
+  t.libs.push 'test'
+  t.test_files = FileList['test/enable_coverage.rb', 'test/**/*_test.rb']
+  t.warning = ENV['warning']
+  t.verbose = ENV['verbose']
+end
+
+desc 'Generates a coverage report'
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['test'].execute
+end
+
+task default: :test

data/lib/babik.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require_relative 'babik/queryset'
+
+# Babik module
+module Babik
+
+  # @!method included(base)
+  # Inject both class methods and instance methods to classes that include this mixin
+  # @param [Class] base Class to be extended by mixin.
+  def self.included(base)
+    base.send :include, InstanceMethods
+    base.extend ClassMethods
+  end
+
+  # All instance methods that are injected to ActiveRecord models
+  module InstanceMethods
+
+    # @!method objects(selection_path = nil)
+    # Get a queryset that contains the foreign model filtered by the current instance
+    # @param [String] selection_path Association name whose objects we want to return.
+    # @return [QuerySet] QuerySet with the foreign objects filtered by this instance.
+    def objects(selection_path = nil)
+      # Instance based deep association
+      instance_based_queryset = _objects_with_selection_path(selection_path)
+      return instance_based_queryset if instance_based_queryset
+
+      # Basic association to one (belongs_to and has_one)
+      to_one_result = self._objects_to_one(selection_path)
+      return to_one_result if to_one_result
+
+      # has_many direct relationship (default case)
+      self._objects_direct_has_many(selection_path)
+    end
+
+    # @!method _objects_with_selection_path(selection_path = nil)
+    # Return a QuerySet following the passed selection path.
+    # @param [String, Symbol, nil] selection_path Path of relationships that will be used as filter.
+    #   If nil, a QuerySet with the current object selected will be returned. Otherwise, a QuerySet with the selection
+    #   described by the __ and :: operators.
+    # @return [QuerySet] QuerySet for the selection_path passed as parameter.
+    def _objects_with_selection_path(selection_path = nil)
+      # By default, a nil selection_path means the caller object wants to return a QuerySet with only itself
+      return self.class.objects.filter(id: self.id) unless selection_path
+
+      selection_path = selection_path.to_s
+      is_a_selection_path = selection_path.include?(Babik::Selection::Config::RELATIONSHIP_SEPARATOR)
+      return nil unless is_a_selection_path
+
+      # If the selection path has more than one level deep, we have to build an instance-based query
+      selection_path_parts = selection_path.split(Babik::Selection::Config::RELATIONSHIP_SEPARATOR)
+      model_i = self.class
+
+      # The aim is to reverse the selection_path both
+      # - Relationships will come from target to source.
+      # - Direction: the instance will become the filter.
+
+      instance_selection_path_parts = []
+
+      # For each selection path part, invert the association and construct a
+      # new selection path for our instance-based query.
+      selection_path_parts.each do |association_name_i|
+        association_i = model_i.reflect_on_association(association_name_i.to_sym)
+        inverse_association_name_i = association_i.options.fetch(:inverse_of)
+        instance_selection_path_parts = [inverse_association_name_i] + instance_selection_path_parts
+        model_i = association_i.klass
+      end
+
+      # Construct a new selection path for our instance-based query
+      instance_selection_path = instance_selection_path_parts.join(Babik::Selection::Config::RELATIONSHIP_SEPARATOR)
+      model_i.objects.filter("#{instance_selection_path}::id": self.id)
+    end
+
+    # @!method _objects_to_one(association_name)
+    # Return a QuerySet with the relationship to one
+    # @param [String, Symbol] association_name Association name that identifies a relationship with other object.
+    # @return [QuerySet, nil] QuerySet based on the association_name, nil if the relationship is not found.
+    def _objects_to_one(association_name)
+      association_name_to_sym = association_name.to_sym
+      association = self.class.reflect_on_association(association_name_to_sym)
+      return nil unless association
+      # If the relationship is belongs_to or has_one, return a lone ActiveRecord model
+      return self.send(association_name_to_sym) if association.belongs_to? || association.has_one?
+      nil
+    end
+
+    # @!method _objects_direct_has_many(association_name)
+    # Return a QuerySet with a direct relationship to many
+    # @param [String, Symbol] association_name Association name that identifies a relationship with other objects.
+    # @return [QuerySet, nil] QuerySet based on the association_name, nil if the relationship is not found.
+    def _objects_direct_has_many(association_name)
+      association = self.class.reflect_on_association(association_name.to_sym)
+      return nil unless association
+      target = Object.const_get(association.class_name)
+      begin
+        inverse_relationship = association.options.fetch(:inverse_of)
+      rescue KeyError => _exception
+        raise "Relationship #{association.name} of model #{self.class} has no inverse_of option."
+      end
+      target.objects.filter("#{inverse_relationship}#{Babik::Selection::Config::RELATIONSHIP_SEPARATOR}id": self.id)
+    end
+  end
+
+  # All class methods that are injected to ActiveRecord models
+  module ClassMethods
+
+    # @!method objects
+    # QuerySet for the current model.
+    # @return [QuerySet] queryset for the current model.
+    def objects
+      Babik::QuerySet::Base.new(self)
+    end
+
+  end
+
+end
+
+
+# Include mixin into parent of all active record models (ActiveRecord::Base)
+ActiveRecord::Base.send(:include, Babik)
+ActiveRecord::Base.send(:include, ActiveModel::AttributeAssignment)

data/lib/babik/database.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Babik
+  # Database configuration
+  class Database
+    # Return database configuration
+    # @return [Hash{adapter:}] Database configuration as a Hash.
+    def self.config
+      ActiveRecord::Base.connection_config
+    end
+
+    def self.escape(string)
+      ActiveRecord::Base.connection.quote(string)
+    end
+  end
+end

data/lib/babik/queryset.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/mixins/aggregatable'
+require 'babik/queryset/mixins/bounded'
+require 'babik/queryset/mixins/clonable'
+require 'babik/queryset/mixins/countable'
+require 'babik/queryset/mixins/deletable'
+require 'babik/queryset/mixins/distinguishable'
+require 'babik/queryset/mixins/none'
+require 'babik/queryset/mixins/filterable'
+require 'babik/queryset/mixins/limitable'
+require 'babik/queryset/mixins/lockable'
+require 'babik/queryset/mixins/projectable'
+require 'babik/queryset/mixins/related_selector'
+require 'babik/queryset/mixins/set_operations'
+require 'babik/queryset/mixins/sql_renderizable'
+require 'babik/queryset/mixins/sortable'
+require 'babik/queryset/mixins/updatable'
+
+require 'babik/queryset/components/aggregation'
+require 'babik/queryset/components/limit'
+require 'babik/queryset/components/order'
+require 'babik/queryset/components/projection'
+require 'babik/queryset/components/select_related'
+require 'babik/queryset/components/sql_renderer'
+require 'babik/queryset/components/where'
+
+require 'babik/queryset/lib/condition'
+require 'babik/queryset/lib/selection/config'
+require 'babik/queryset/lib/selection/local_selection'
+require 'babik/queryset/lib/selection/foreign_selection'
+require 'babik/queryset/lib/field'
+require 'babik/queryset/lib/update/assignment'
+
+# Represents a new type of query result set
+module Babik
+  module QuerySet
+    # Abstract Base class for QuerySet, implements a container for database results.
+    class AbstractBase
+      include Enumerable
+      include Babik::QuerySet::Aggregatable
+      include Babik::QuerySet::Bounded
+      include Babik::QuerySet::Clonable
+      include Babik::QuerySet::Countable
+      include Babik::QuerySet::Deletable
+      include Babik::QuerySet::NoneQuerySet
+      include Babik::QuerySet::Distinguishable
+      include Babik::QuerySet::Filterable
+      include Babik::QuerySet::Limitable
+      include Babik::QuerySet::Lockable
+      include Babik::QuerySet::Projectable
+      include Babik::QuerySet::SQLRenderizable
+      include Babik::QuerySet::RelatedSelector
+      include Babik::QuerySet::SetOperations
+      include Babik::QuerySet::Sortable
+      include Babik::QuerySet::Updatable
+
+      attr_reader :model, :_aggregation, :_count, :_distinct, :_limit, :_lock_type, :_order, :_projection,
+                  :_where, :_select_related
+
+      alias aggregation? _aggregation
+      alias count? _count
+      alias distinct? _distinct
+      alias select_related? _select_related
+      alias reverse! invert_order!
+      alias select_for_update! for_update!
+      alias exist? exists?
+
+      def initialize(model_class)
+        @model = model_class
+        @_count = false
+        @_distinct = false
+        @_order = nil
+        @_lock_type = nil
+        @_where = Babik::QuerySet::Where.new(@model)
+        @_aggregation = nil
+        @_limit = nil
+        @_projection = nil
+        @_select_related = nil
+      end
+
+      # Return a ResultSet with the ActiveRecord objects that match the condition given by the filters.
+      # @return [ResultSet] ActiveRecord objects that match the condition given by the filters.
+      def all
+        sql_select = self.sql.select
+        return @_projection.apply_transforms(self.class._execute_sql(sql_select)) if @_projection
+        return @_select_related.all_with_related(self.class._execute_sql(sql_select)) if @_select_related
+        @model.find_by_sql(sql_select)
+      end
+
+      # Loop through the results with a block
+      # @param block [Proc] Proc that will be applied to each object.
+      def each(&block)
+        self.all.each(&block)
+      end
+
+      # Get the left joins grouped by alias in a hash.
+      # @return [Hash] Return a hash with the format :table_alias => SQL::Join
+      def left_joins_by_alias
+        left_joins_by_alias = {}
+        # Merge where
+        left_joins_by_alias.merge!(@_where.left_joins_by_alias)
+        # Merge order
+        left_joins_by_alias.merge!(@_order.left_joins_by_alias) if @_order
+        # Merge aggregation
+        left_joins_by_alias.merge!(@_aggregation.left_joins_by_alias) if @_aggregation
+        # Merge prefetchs
+        left_joins_by_alias.merge!(@_select_related.left_joins_by_alias) if @_select_related
+        # Return the left joins by alias
+        left_joins_by_alias
+      end
+
+      # Execute SQL code
+      # @param [String] sql SQL code
+      # @return SQL result set.
+      def self._execute_sql(sql)
+        ActiveRecord::Base.connection.exec_query(sql)
+      end
+    end
+
+    class Base < AbstractBase
+
+    end
+
+    # Each one of the set operations that can be executed in SQL
+    class SetOperation < AbstractBase
+
+      attr_reader :left_operand, :right_operand
+
+      def initialize(model, left_operand, right_operand)
+        @left_operand = left_operand
+        @right_operand = right_operand
+        super(model)
+      end
+
+      def operation
+        db_adapter = Babik::Database.config[:adapter]
+        operation_name = self.class.to_s.split('::').last.upcase
+        if %w[postgresql sqlite3].include?(db_adapter) || (%w[mysql2].include?(db_adapter) && operation_name == 'UNION')
+          return operation_name
+        end
+        raise "#{db_adapter} does not support operation #{operation_name}"
+      end
+
+    end
+
+    class Except < SetOperation; end
+
+    class Intersect < SetOperation; end
+
+    class Union < SetOperation; end
+
+  end
+end

data/lib/babik/queryset/components/aggregation.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# Common module for Babik library
+module Babik
+  # QuerySet module
+  module QuerySet
+    # A set of aggregation operations
+    class Aggregation
+
+      attr_reader :model, :functions
+
+      # Construct a new aggregation
+      # @param model [Class] class that inherits from ActiveRecord::Base.
+      # @param functions [Array<Avg, Max, Min, Sum>] array of aggregation functions.
+      def initialize(model, functions)
+        @model = model
+        @functions = []
+        functions.each do |field_name, function|
+          @functions << function.prepare(@model, field_name)
+        end
+      end
+
+      # Return the joins grouped by alias
+      # @return [Hash{alias: Babik::QuerySet::Join}] Hash where the value is the alias of the table and the value is a Babik::Join
+      def left_joins_by_alias
+        left_joins_by_alias = {}
+        @functions.each do |function|
+          left_joins_by_alias.merge!(function.left_joins_by_alias)
+        end
+        left_joins_by_alias
+      end
+
+      # Return aggregation SQL
+      # @return [String] Aggregation SQL
+      def sql
+        @functions.map(&:sql).join(', ')
+      end
+    end
+
+    # Abstract aggregation function. Do not use
+    class AbstractAggregationFunction
+      attr_reader :model, :selection, :field_name
+
+      # Construct a aggregation function for a field
+      # @param aggregation_path [String] Field or foreign field path.
+      def initialize(aggregation_path)
+        @aggregation_path = aggregation_path
+      end
+
+      # Prepare the aggregation function for a model class and a field
+      # @param model [ActiveRecord::Base] model that will be used as origin for association paths.
+      # @param field_name [String, nil] Name that will take the computed aggregation operation.
+      #        If nil, it will take the value <table_alias>__<agg_function>.
+      def prepare(model, field_name = nil)
+        @model = model
+        @selection = Babik::Selection::Path::Factory.build(model, @aggregation_path)
+        @field_name = field_name || "#{self.table_alias}__#{SQL_OPERATION.downcase}"
+        self
+      end
+
+      # Return aggregation function SQL
+      # @return [String] Aggregation function SQL
+      def sql
+        selected_field_path = "#{@selection.target_alias}.#{@selection.selected_field}"
+        operation = self.sql_operation.sub('?field', selected_field_path)
+        "#{operation} AS #{@field_name}"
+      end
+
+      # Return the joins grouped by alias
+      # @return [Hash{alias: Babik::QuerySet::Join}] Hash where the value is the alias of the table and the value is a Babik::Join
+      def left_joins_by_alias
+        @selection.left_joins_by_alias
+      end
+
+      # Return the database adapter
+      # @return [String] Database adapter: 'mysql2', 'postgres' o 'sqlite'
+      def self.db_adapter
+        Babik::Database.config[:adapter]
+      end
+
+    end
+
+    # Class method utility method
+    # @param operation [String] Function that will be executed in the aggregation.
+    # @param aggregation_path [String]
+    # @return [Class < AbstractAggregationFunction] aggregation function object.
+    def self.agg(operation, aggregation_path)
+      operation_class_name = operation.to_s.camelize
+      operation_class = Object.const_get("Babik::QuerySet::#{operation_class_name}")
+      operation_class.new(aggregation_path)
+    end
+
+    # Mixin that injects the sql_operation method in aggregations with the same SQL syntax
+    # independently of the database adapter (SUM, MAX, MIN, etc.)
+    module StandardSqlOperation
+      def sql_operation
+        self.class::SQL_OPERATION
+      end
+    end
+
+    # Average operation. Compute the mean of a set of values.
+    class Avg < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'AVG(?field)'
+    end
+
+    # Count operation. Compute the count of a set of values.
+    class Count < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'COUNT(?field)'
+    end
+
+    # Count distinct operation. Compute the count distinct of a set of values.
+    class CountDistinct < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'COUNT(DISTINCT(?field))'
+    end
+
+    # Max operation. Compute the maximum of a set of values.
+    class Max < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'MAX(?field)'
+    end
+
+    # Min operation. Compute the minimum of a set of values.
+    class Min < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'MIN(?field)'
+    end
+
+    # Sum operation. Compute the sum of a set of values.
+    class Sum < AbstractAggregationFunction
+      include StandardSqlOperation
+      SQL_OPERATION = 'SUM(?field)'
+    end
+
+    # When a aggregation function is in PostgreSQL and MySQL (main supported databases)
+    class PostgresMySQLAggregationFunction < AbstractAggregationFunction
+      # Return the SQL code operation for this aggregation, e.g.:
+      #   - STDDEV_POP(?field)
+      #   - VAR_POP(?field)
+      # @raise [RuntimeException] if database has no support for this operation.
+      # @return [String] SQL code for the aggregation
+      def sql_operation
+        db_adapter = self.class.db_adapter
+        return self.class::SQL_OPERATION if %w[postgresql mysql2].include?(db_adapter)
+        raise "#{db_adapter} has no support for #{self.class} aggregation"
+      end
+    end
+
+    # Standard deviation of a set of values
+    class StdDev < PostgresMySQLAggregationFunction
+      SQL_OPERATION = 'STDDEV_POP(?field)'
+    end
+
+    # Standard deviation (sample) of a set of values
+    class StdDevSample < PostgresMySQLAggregationFunction
+      SQL_OPERATION = 'STDDEV_SAMP(?field)'
+    end
+
+    # Variance of a set of values
+    class Var < PostgresMySQLAggregationFunction
+      SQL_OPERATION = 'VAR_POP(?field)'
+    end
+
+    # Variance (sample) of a set of values
+    class VarSample < PostgresMySQLAggregationFunction
+      SQL_OPERATION = 'VAR_SAMP(?field)'
+    end
+
+  end
+end