babik 0.1.0

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Babik
+  # QuerySet module
+  module QuerySet
+    # Manages the limit of the QuerySet
+    class Limit
+      attr_reader :size, :offset
+
+      # Construct a limit for QuerySet
+      # @param size [Integer] Size to be selected
+      # @param offset [Integer] Offset from the selection will begin. By default is 0.
+      def initialize(size, offset = 0)
+        @size = size.to_i
+        @offset = offset.to_i
+      end
+
+    end
+  end
+end
+
+

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/selection'
+
+module Babik
+  # QuerySet module
+  module QuerySet
+    # Manages the order of the QuerySet
+    class Order
+
+      attr_reader :order_fields
+
+      # Construct the order manager
+      # @param model [ActiveRecord::Base] base model.
+      # @param ordering [Array, String, Hash] ordering that will be applied to the QuerySet.
+      #        Each item of the array represents an order:
+      #        - field1: field1 ASC
+      #        - -field1: field1 DESC
+      #        - [field1, :ASC]: field1 ASC
+      #        - [field1, :DESC]: field1 DESC
+      #        - {field1, :ASC}: field1 ASC
+      #        - {field1, :DESC}: field1 DESC
+      # @raise [RuntimeError] Invalid type of order
+      def initialize(model, *ordering)
+        @model = model
+        # Convert the types of each order field
+        order_as_array_or_pairs = ordering.map do |order|
+          if [Hash, String, Symbol].include?(order.class)
+            self.send("_order_from_#{order.class.to_s.downcase}", order)
+          elsif order.class == Array
+            order
+          else
+            raise "Invalid type of order: #{order}"
+          end
+        end
+        _initialize_field_orders(order_as_array_or_pairs)
+      end
+
+      # Get order from string
+      # @param order [String] The string of the form 'field1'
+      # @api private
+      # @return [Array] Conversion of order as string to array.
+      def _order_from_string(order)
+        return [order, :ASC] if order[0] != '-'
+        [order[1..-1], :DESC]
+      end
+
+      # Get order from symbol
+      # @param order [Symbol] The symbol of the form :field1
+      # @api private
+      # @return [Array] Conversion of order as symbol to array.
+      def _order_from_symbol(order)
+        _order_from_string(order.to_s)
+      end
+
+      # Get order from a hash
+      # @param order [Hash] The string of the form <field>: <ORD> (where <ORD> is :ASC or :DESC)
+      # @return [Array] Conversion of order as hash to array.
+      def _order_from_hash(order)
+        raise "More than one key found in order by for class #{self.class}" if order.keys.length > 1
+        order_field = order.keys[0]
+        order_value = order[order_field]
+        [order_field, order_value]
+      end
+
+      # Initialize the order paths
+      # @api private
+      # @return [Array] Conversion of order as hash to array.
+      def _initialize_field_orders(order)
+        # Check
+        @order_fields = []
+        order.each_with_index do |order_field_direction, _order_field_index|
+          order_field_path = order_field_direction[0]
+          order_direction = order_field_direction[1]
+          @order_fields << OrderField.new(@model, order_field_path, order_direction)
+        end
+      end
+
+      # Return an direction inversion of this order
+      # e.g.
+      #   User, first_name, ASC => invert => User, first_name, DESC
+      # @return [Array<OrderField>] Inverted order.
+      def invert
+        @order_fields.map(&:invert)
+      end
+
+      # Invert actual order direction
+      def invert!
+        @order_fields = self.invert
+      end
+
+      # Return the left joins this order include, grouped by alias
+      # @return [Hash] Hash with the key equal to alias and the value equals to a Join.
+      def left_joins_by_alias
+        left_joins_by_alias = {}
+        @order_fields.each do |order_field|
+          left_joins_by_alias.merge!(order_field.left_joins_by_alias)
+        end
+        left_joins_by_alias
+      end
+
+      # Return sql of the fields to order.
+      # Does not include ORDER BY.
+      # @return [SQL] SQL code for fields to order.
+      def sql
+        @order_fields.map(&:sql).join(', ')
+      end
+    end
+
+    # Each one of the fields that appear in the order statement
+    class OrderField
+      attr_reader :selection, :direction, :model
+
+      delegate :left_joins_by_alias, to: :selection
+
+      # Construct the OrderField
+      # @param model [ActiveRecord::Base] base model.
+      # @param field_path [String, Symbol, Selection] field path. If local, it will be one of the attributes,
+      #        otherwise will be an association path.
+      # @param direction [String, Symbol] :ASC or :DESC (a string will be converted to symbol).
+      def initialize(model, field_path, direction)
+        direction_sym = direction.to_sym
+        unless %i[ASC DESC].include?(direction_sym)
+          raise "Invalid order type #{direction} in #{field_path}: Expecting :ASC or :DESC"
+        end
+        @model = model
+        if [String, Symbol].include?(field_path.class)
+          @selection = Babik::Selection::Path::Factory.build(@model, field_path)
+        elsif [Babik::Selection::Path::LocalPath, Babik::Selection::Path::ForeignPath].include?(field_path.class)
+          @selection = field_path
+        else
+          raise "field_path of class #{field_path.class} not valid. A Symbol/String/Babik::Selection::Base expected"
+        end
+        @direction = direction_sym
+      end
+
+      # Return a new OrderField with the direction inverted
+      # @return [OrderField] Order field with inverted direction.
+      def invert
+        inverted_direction = if @direction.to_sym == :ASC
+                               :DESC
+                             else
+                               :ASC
+                             end
+        OrderField.new(@model, @selection, inverted_direction)
+      end
+
+      # Return sql of the field to order.
+      # i.e. something like this:
+      #   <table_alias>.<field> ASC
+      #   <table_alias>.<field> DESC
+      # e.g.
+      #   users_0.first_name ASC
+      #   posts_0.title DESC
+      # @return [SQL] SQL code for field to order.
+      def sql
+        "#{@selection.target_alias}.#{@selection.selected_field} #{@direction}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/path/path'
+
+module Babik
+  # QuerySet module
+  module QuerySet
+
+    # Manages the projection of a SELECT QuerySet
+    class Projection
+
+      # Constructs a projection
+      # @param model [ActiveRecord::Base] model the projection is based on.
+      # @param fields [Array] array of fields that will be projected.
+      def initialize(model, fields)
+        @fields = []
+        @fields_hash = {}
+        fields.each do |field|
+          new_field = ProjectedField.new(model, field)
+          @fields << new_field
+          @fields_hash[new_field.alias.to_sym] = new_field
+        end
+      end
+
+      def apply_transforms(result_set)
+        result_set.map do |record|
+          record.symbolize_keys!
+          transformed_record = {}
+          record.each do |field, value|
+            transform = @fields_hash[field].transform
+            transformed_record[field] = if transform
+                                          transform.call(value)
+                                        else
+                                          value
+                                        end
+          end
+          transformed_record
+        end
+      end
+
+      # Return sql of the fields to project.
+      # Does not include SELECT.
+      # @return [SQL] SQL code for fields to select in SELECT.
+      def sql
+        @fields.map(&:sql).join(', ')
+      end
+    end
+
+    # Each one of the fields that will be returned by SELECT clause
+    class ProjectedField
+      attr_reader :model, :alias, :transform, :selection
+
+      # Construct a projected field from a model and its field.
+      # @param model [ActiveRecord::Base] model whose field will be returned in the SELECT query.
+      # @param field [Array, String]
+      #   if Array, it must be [field_name, alias, transform] where
+      #   - field_name is the name of the field (the column name). It is mandatory and must be the first
+      #   item of the array.
+      #   - alias if present, it will be used to name the field instead of its name.
+      #   - transform, if present, a lambda function with the transformation each value of that column it must suffer.
+      # e.g.:
+      #   [:created_at, :birth_date]
+      #   [:stars, ->(stars) { [stars, 5].min } ]
+      #   Otherwise, a field of the local table or foreign tables.
+      #
+      def initialize(model, field)
+        @model = model
+        method_name = "initialize_from_#{field.class.to_s.downcase}"
+        unless self.respond_to?(method_name)
+          raise "No other parameter type is permitted in #{self.class}.new than Array, String and Symbol."
+        end
+        self.send(method_name, field)
+        @selection = Babik::Selection::Path::Factory.build(model, @name)
+      end
+
+      # Initialize from Array
+      def initialize_from_array(field)
+        @name = field[0]
+        @alias = @name
+        [1, 2].each do |field_index|
+          next unless field[field_index]
+          field_i = field[field_index]
+          if [Symbol, String].include?(field_i.class)
+            @alias = field_i
+          elsif field_i.class == Proc
+            @transform = field_i
+          else
+            raise "#{self.class}.new only accepts String/Symbol or Proc. Passed a #{field_i.class}."
+          end
+        end
+      end
+
+      # Initialize from String
+      def initialize_from_string(field)
+        @name = field.to_sym
+        @alias = field.to_sym
+        @transform = nil
+      end
+
+      # Initialize from Symbol
+      def initialize_from_symbol(field)
+        initialize_from_string(field)
+      end
+
+      # Return sql of the field to project.
+      # i.e. something like this:
+      #   <table_alias>.<field>
+      #   <table_alias>.<field> AS <field_alias>
+      # e.g.
+      #   users_0.first_name
+      #   posts_0.title AS post_title
+      # @return [SQL] SQL code for field to appear in SELECT.
+      def sql
+        "#{@selection.target_alias}.#{@selection.selected_field} AS #{@alias}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/select_related_selection'
+
+module Babik
+  # QuerySet module
+  module QuerySet
+    # Delegate object that must deals with all the select_related particularities.
+    class SelectRelated
+
+      attr_reader :model, :associations
+
+      # Creates a new SelectRelated
+      def initialize(model, selection_paths)
+        @model = model
+        @associations = []
+        selection_paths = [selection_paths] if selection_paths.class != Array
+        selection_paths.each do |selection_path|
+          @associations << Babik::Selection::SelectRelatedSelection.new(@model, selection_path)
+        end
+      end
+
+      # Return the joins that are needed according to the associated path
+      # @return [Hash{table_alias: String}] Left joins by table alias.
+      def left_joins_by_alias
+        left_joins_by_alias = {}
+        @associations.each do |association|
+          left_joins_by_alias.merge!(association.left_joins_by_alias)
+        end
+        left_joins_by_alias
+      end
+
+      # Return the next object and its related objects
+      # Requires a result set of the query that selects all object attributes and the rest
+      # of attributes of the associated objects.
+      # @param result_set [ResultSet] Result with the query that loads all the required objects
+      #        (main and related ones).
+      # @return [ActiveRecord::Base, Hash{selection_path: ActiveRecord::Base}]
+      #         Return and object with its associated objects.
+      def all_with_related(result_set)
+        result_set.map do |record|
+          object = instantiate_model_object(record)
+          associated_objects = @associations.map do |association|
+            [association.selection_path, instantiate_associated_object(record, association)]
+          end
+          [object, associated_objects.to_h.symbolize_keys]
+        end
+      end
+
+      private
+
+      # Construct a model object
+      def instantiate_model_object(record)
+        object = @model.new
+        object.assign_attributes(record.select { |attribute| @model.column_names.include?(attribute) })
+        object
+      end
+
+      # Construct an associated object
+      def instantiate_associated_object(record, association)
+        target_model = association.target_model
+        target_object = target_model.new
+
+        # First, get the attributes that have the desired prefix (the association path)
+        target_attributes_with_prefix = record.select { |attr, value| attr.start_with?("#{association.id}__") }
+
+        # Second, convert it to a hash
+        target_attributes = (target_attributes_with_prefix.map do |attribute, value|
+          [attribute.split('__')[1], value]
+        end).to_h
+
+        # Last, assign it to the associated object
+        target_object.assign_attributes(target_attributes)
+        target_object
+      end
+    end
+    end
+  end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'babik/database'
+
+module Babik
+  module QuerySet
+    # SQL renderer
+    class SQLRenderer
+
+      attr_reader :queryset
+
+      # Where the SQL templates are
+      TEMPLATE_PATH = "#{__dir__}/../templates"
+
+      # Construct a new SQL rendered for a QuerySet
+      # @param queryset [QuerySet] QuerySet to be rendered.
+      def initialize(queryset)
+        @queryset = queryset
+      end
+
+      # Render the SELECT statement
+      # @return [String] SQL SELECT statement for this QuerySet.
+      def select
+        _render('select/main.sql.erb')
+      end
+
+      # Render the UPDATE statement
+      # @param update_command [Hash{field: value}] Runs the update query.
+      # @return [String] SQL UPDATE statement for this QuerySet.
+      def update(update_command)
+        @queryset.project!(['id'])
+        sql = _render('update/main.sql.erb', {update_command: update_command})
+        @queryset.unproject!
+        sql
+      end
+
+      # Render the DELETE statement
+      # @return [String] SQL DELETE statement for this QuerySet.
+      def delete
+        @queryset.project(['id'])
+        sql = _render('delete/main.sql.erb')
+        @queryset.unproject
+        sql
+      end
+
+      # Return the SQL representation of all joins of the QuerySet
+      # @return [String] A String with all LEFT JOIN statements required for this QuerySet.
+      def left_joins
+        # Join all left joins and return a string with the SQL code
+        @queryset.left_joins_by_alias.values.map(&:sql).join("\n")
+      end
+
+      private
+
+      # Render a file in a path
+      # @api private
+      # @param template_path [String] Relative (to {SQLRenderer::TEMPLATE_PATH}) path of the template file.
+      # @param extra_replacements [Hash] Hash with the replacements. By default is an empty hash.
+      # @return [String] Rendered SQL with QuerySet replacements completed
+      def _render(template_path, extra_replacements = {})
+        render = lambda do |partial_template_path, replacements|
+          replacements[:render] = render
+          _base_render(partial_template_path, **replacements)
+        end
+        replacements = extra_replacements.clone
+        replacements[:queryset] = @queryset
+        replacements[:render] = render
+        _base_render(template_path, **replacements)
+      end
+
+      # Render a file
+      # It first search in the dbms_adapter directory and if the file exists, uses that as template.
+      # Otherwise, load the one placed in the default directory.
+      # @api private
+      # @param template_path [String] Relative (to {SQLRenderer::TEMPLATE_PATH}) path of the template file.
+      # @param replacements [Hash] Hash with the replacements.
+      # @return [String] Rendered SQL with QuerySet replacements completed
+      def _base_render(template_path, replacements)
+        dbms_adapter = _dbms_adapter
+        dbms_adapter_template_path = "#{TEMPLATE_PATH}/#{dbms_adapter}/#{template_path}"
+        template_path = if File.exist?(dbms_adapter_template_path)
+                          dbms_adapter_template_path
+                        else
+                          "#{TEMPLATE_PATH}/default/#{template_path}"
+                        end
+        template_content = File.read(template_path)
+        ::ERB.new(template_content).result_with_hash(**replacements).gsub(/[ ]+/, ' ').gsub(/[\n ]{2,}/, "\n")
+      end
+
+      # Return the DBMS adapter.
+      # @return [String] DBMS adapter (sqlite3, postgre, mysql, mariadb, oracle or mssql).
+      def _dbms_adapter
+        Babik::Database.config[:adapter]
+      end
+
+    end
+  end
+end