babik 0.1.0

data/lib/babik/queryset/lib/selection/foreign_selection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/path/foreign_path'
+
+module Babik
+  module Selection
+    # Foreign selection
+    class ForeignSelection < Babik::Selection::Path::ForeignPath
+
+      attr_reader :model, :selection_path, :selected_field,
+                  :sql_where_condition,
+                  :value, :operator
+
+      # Create a foreign selection, that is, a filter that is based on a foreign field condition.
+      # @param model [ActiveRecord::Base] Model
+      # @param selection_path [String, Symbol] selection path used only to raise errors. e.g.:
+      #        posts::category__in
+      #        author::posts::tags
+      #        creation_at__date__gte
+      # @param value [String, Integer, ActiveRecord::Base] value that will be used in the filter
+      def initialize(model, selection_path, value)
+        super(model, selection_path)
+        # If the value is an ActiveRecord model, get its id
+        @value = value
+        @value = @value.id if @value.is_a?(ActiveRecord::Base)
+        _init_sql_where_condition
+      end
+
+      # Initialize the SQL condition that will be used on the SQL SELECT
+      def _init_sql_where_condition
+        last_association_model = @association_chain.target_model
+        actual_field = Babik::Table::Field.new(last_association_model, @selected_field).real_field
+        @sql_where_condition = Babik::Selection::Operation::Base.factory(
+          "#{target_alias}.#{actual_field}", @operator, @value
+        )
+      end
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/local_selection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/selection'
+require 'babik/queryset/lib/selection/operation/operations'
+require 'babik/queryset/lib/selection/path/local_path'
+
+module Babik
+  module Selection
+    # Selection by a local field
+    class LocalSelection < Babik::Selection::Path::LocalPath
+
+      attr_reader :model, :selection_path, :selected_field, :operator, :secondary_operator, :value
+
+      # Construct a local field selector
+      # @param model [ActiveRecord::Base] model whose field will be used.
+      # @param selection_path [String] selection path. Of the form <field>__<operator>. e.g. first_name__equal, stars__gt
+      #        If no operator is given (first_name), 'equal' will be used.
+      # @param value [String,Integer,Float,ActiveRecord::Base,Babik::QuerySet::Base] anything that can be used
+      #        to select objects.
+      def initialize(model, selection_path, value)
+        super(model, selection_path)
+        @value = value
+      end
+
+      # Return the SQL where condition
+      # @return [Babik::Selection::Operation::Base] Condition obtained from the selection path and value.
+      def sql_where_condition
+        actual_field = Babik::Table::Field.new(model, @selected_field).real_field
+        # Return the condition
+        operator = if @secondary_operator
+                     [@operator, @secondary_operator]
+                   else
+                     @operator
+                   end
+        Babik::Selection::Operation::Base.factory("#{self.target_alias}.#{actual_field}", operator, @value)
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/operation/base.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Babik
+  module Selection
+    # SQL operation module
+    module Operation
+      # Base class
+      class Base
+
+        attr_reader :field, :value, :sql_operation, :sql_operation_template
+
+        # Construct a SQL operation
+        # @param field [String] Name of the field. Prefixed with the table or table alias.
+        # @param sql_operation [String] Template string with the SQL code or the operation.
+        #        Something like ?field = ?value.
+        def initialize(field, sql_operation, value)
+          @field = field
+          @value = value
+          @sql_operation_template = sql_operation.dup
+          @sql_operation = sql_operation.dup
+          _init_sql_operation
+        end
+
+        # Replace the SQL operation template and store the result in sql_operation attribute
+        def _init_sql_operation
+          @sql_operation = @sql_operation_template.sub('?field', @field).sub('?value', '?')
+          # Use Rails SQL escaping and avoid possible SQL-injection issues
+          # and also several DB-related issues (like MySQL escaping quotes by \' instead of '')
+          # Only if it has not been already replaced
+          @sql_operation = ActiveRecord::Base.sanitize_sql([@sql_operation, @value]) if @sql_operation.include?('?')
+        end
+
+        # Convert the operation to string
+        # @return [String] Return the replaced SQL operation.
+        def to_s
+          @sql_operation
+        end
+
+        # Return the database engine: sqlite3, mysql, postgres, mssql, etc.
+        def db_engine
+          Babik::Database.config[:adapter]
+        end
+
+        # Operation factory
+        def self.factory(field, operator, value)
+          # Some operators can have a secondary operator, like the year lookup that can be followed by
+          # a gt, lt, equal, etc. Check this case, and get it to prepare its passing to the operation.
+          raw_main_operator, secondary_operator = self.initialize_operators(operator)
+          # The field, operator or value can change in some special cases, e.g. if operator is equals and the value
+          # is an array, the operator should be 'in' actually.
+          field, main_operator, value = self.special_cases(field, raw_main_operator, value)
+          # At last, initialize operation
+          self.initialize_operation(field, main_operator, secondary_operator, value)
+        end
+
+        # Inform if the operation has a operator
+        # @return [Boolean] True if the operation needs an operator, false otherwise.
+        def self.operator?
+          self.const_defined?('HAS_OPERATOR') && self.const_get('HAS_OPERATOR')
+        end
+
+        # Initialize the operators (both main and secondary)
+        # When the operator is an Array, it means it actually is two different operators. The first one will be applied
+        # to the main operation, and the second one, to the lookup.
+        # e.g. selector 'created_at__time__gt' contains two operators, 'time' and 'gt'.
+        # @return [Array<String>] Array with both operations.
+        #         First element will be the main operation, the second one will be
+        #         the secondary operation. If there is no secondary operation, the second item will be nil.
+        def self.initialize_operators(operator)
+          secondary_operator = nil
+          if operator.class == Array
+            secondary_operator = operator[1]
+            operator = operator[0]
+          end
+          [operator, secondary_operator]
+        end
+
+        # Initialize the operation
+        # @param field [String] Field name that takes part in the selection operation.
+        # @param operator [Symbol] Operator name that defines which operation will be used.
+        # @param secondary_operator [Symbol] Some operations have a particular operation that's it.
+        # @param value [String, Integer] Value used in the selection.
+        # @return [Babik::Selection::Operation::Base] A SQL selection operation.
+        def self.initialize_operation(field, operator, secondary_operator, value)
+          operation_class_name = Babik::Selection::Operation::CORRESPONDENCE[operator.to_sym]
+          raise "Unknown lookup #{operator}" unless operation_class_name
+          operation_class = Object.const_get("Babik::Selection::Operation::#{operation_class_name}")
+          # If there is a secondary operator, pass it to the operation
+          if secondary_operator || operation_class.operator?
+            return operation_class.new(field, secondary_operator, value)
+          end
+          # Otherwise, return the operation
+          operation_class.new(field, value)
+        end
+
+        # Special conversion of operations
+        def self.special_cases(field, operator, value)
+          return field, 'in', value if operator == 'equal' && [Babik::QuerySet::Base, Array].include?(value.class)
+          self.date_special_cases(field, operator, value)
+        end
+
+        # Special conversion of operations for date lookup
+        def self.date_special_cases(field, operator, value)
+          return field, 'between', [value.beginning_of_day, value.end_of_day] if operator == 'date' && value.is_a?(::Date)
+          return field, 'between', [Time(value.year, 1, 1).beginning_of_day, Time(value.year, 12, 31).end_of_day] if operator == 'year' && value.is_a?(::Date)
+          [field, operator, value]
+        end
+
+        # Escape a string
+        def self.escape(str)
+          Babik::Database.escape(str)
+        end
+      end
+
+      # Binary operation
+      # That's it ?field <operator> ?value
+      # Most operations will have this format
+      class BinaryOperation < Base
+        def initialize(field, value)
+          super(field, "?field #{self.class::SQL_OPERATOR} ?value", value)
+        end
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/operation/date.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/operation/base'
+
+module Babik
+  module Selection
+    # SQL operation module
+    module Operation
+
+      # Check the DBMS is one of the supported ones
+      module ValidDBMS
+        SUPPORTED_DB_ADAPTERS = %i[mariadb mysql2 postgresql sqlite3].freeze
+        def assert_dbms
+          dbms = db_engine.to_sym
+          raise "Invalid dbms #{db_engine}. Only mysql, postgresql, and sqlite3 are accepted" unless SUPPORTED_DB_ADAPTERS.include?(dbms)
+        end
+      end
+
+      # Each one of the operations over date fields (date, year, month, day, etc.)
+      class DateOperation < Base
+        include ValidDBMS
+
+        HAS_OPERATOR = true
+        def initialize(field, operator, value)
+          assert_dbms
+          operator ||= 'equal'
+          @operator = operator
+          # In the left-hand of the main operator lies the sql_function
+          # that will extract the desired part of the datetime
+          # This function represents the field as #field, not as ?field
+          # to avoid having replacement issues
+          code_for_sql_function = sql_function
+          main_operation = Base.factory(code_for_sql_function, operator, value)
+          # Replacement mechanism only understand ?field and not #field,
+          # so replace #field for ?field and let it work
+          main_operation_sql_code = main_operation.sql_operation.sub('#field', '?field')
+          super(field, main_operation_sql_code, value)
+        end
+
+        def sql_function
+          raise NotImplementedError
+        end
+      end
+
+      # Year date operation
+      class Year < DateOperation
+        def sql_function
+          dbms_adapter = db_engine
+          return 'YEAR(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(YEAR FROM #field)' if dbms_adapter == 'postgresql'
+          return 'strftime(\'%Y\', #field)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Quarter where the date is operation
+      class Quarter < DateOperation
+        def sql_function
+          dbms_adapter = db_engine
+          return 'QUARTER(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(QUARTER FROM #field)' if dbms_adapter == 'postgresql'
+          return '(CAST(strftime(\'%m\', #field) AS INTEGER) + 2) / 3' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Month date operation
+      class Month < DateOperation
+        def initialize(field, operator, value)
+          value = format('%02d', value) if db_engine == 'sqlite3'
+          super(field, operator, value)
+        end
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'MONTH(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(MONTH FROM #field)' if dbms_adapter == 'postgresql'
+          return 'strftime(\'%m\', #field)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Day of month date operation
+      class Day < DateOperation
+        def initialize(field, operator, value)
+          value = format('%02d', value) if db_engine == 'sqlite3'
+          super(field, operator, value)
+        end
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'DAYOFMONTH(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(DAY FROM #field)' if dbms_adapter == 'postgresql'
+          return 'strftime(\'%d\', #field)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # WeekDay (1-7, sunday to monday) date operation
+      class WeekDay < DateOperation
+
+        def initialize(field, operator, value)
+          value = format('%d', value) if db_engine == 'sqlite3'
+          super(field, operator, value)
+        end
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'DAYOFWEEK(#field) -  1' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(DOW FROM #field)' if dbms_adapter == 'postgresql'
+          return 'strftime(\'%w\', #field)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # ISO Week of year (1-52/53) from date operation
+      #
+      class Week < DateOperation
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'WEEK(#field, 3)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(WEEK FROM #field)' if dbms_adapter == 'postgresql'
+          return '(strftime(\'%j\', date(#field, \'-3 days\', \'weekday 4\')) - 1) / 7 + 1' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Hour date operation
+      class Hour < DateOperation
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'HOUR(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(HOUR FROM #field)' if dbms_adapter == 'postgresql'
+          return 'CAST(strftime(\'%H\', #field) AS INTEGER)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Minute date operation
+      class Minute < DateOperation
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'MINUTE(#field)' if dbms_adapter == 'mysql2'
+          return 'EXTRACT(MINUTE FROM #field)' if dbms_adapter == 'postgresql'
+          return 'CAST(strftime(\'%M\', #field) AS INTEGER)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Second date operation
+      class Second < DateOperation
+
+        def sql_function
+          dbms_adapter = db_engine
+          return 'SECOND(#field)' if dbms_adapter == 'mysql2'
+          return 'FLOOR(EXTRACT(SECOND FROM #field))' if dbms_adapter == 'postgresql'
+          return 'CAST(strftime(\'%S\', #field) AS INTEGER)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+      # Time date operation
+      class Time < DateOperation
+        def sql_function
+          dbms_adapter = db_engine
+          return 'DATE_FORMAT(#field, \'%H:%i:%s\')' if dbms_adapter == 'mysql2'
+          return 'date_trunc(\'second\', #field::time)' if dbms_adapter == 'postgresql'
+          return 'strftime(\'%H:%M:%S\', #field)' if dbms_adapter == 'sqlite3'
+          raise NotImplementedError, "#{self.class} lookup not implemented for #{dbms_adapter}"
+        end
+      end
+
+    end
+  end
+end

data/lib/babik/queryset/lib/selection/operation/operations.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'babik/queryset/lib/selection/operation/base'
+require 'babik/queryset/lib/selection/operation/date'
+require 'babik/queryset/lib/selection/operation/regex'
+
+module Babik
+  module Selection
+    # SQL operation module
+    module Operation
+
+      # When two values are not equal
+      class Different < BinaryOperation
+        SQL_OPERATOR = '<>'
+      end
+
+      # Operations that in case a nil is passed will convert the equality comparison to IS NULL
+      class IfNotNullOperation < Base
+        SQL_OPERATOR = '='
+        def initialize(field, value)
+          if value.nil?
+            super(field, '?field IS NULL', value)
+          else
+            super(field, "?field #{SQL_OPERATOR} ?value", value)
+          end
+        end
+      end
+
+      # Equal operation
+      class Equal < IfNotNullOperation
+        SQL_OPERATOR = '='
+      end
+
+      # Exact operation
+      class Exact < IfNotNullOperation
+        SQL_OPERATOR = 'LIKE'
+      end
+
+      # Exact case-insensitive operation
+      class IExact < Exact
+        SQL_OPERATOR = 'ILIKE'
+      end
+
+      # IN operation
+      class In < Base
+        def initialize(field, value)
+          _init_value(value)
+          super(field, '?field IN ?value', @value)
+        end
+
+        def _init_value(value)
+          if value.class == Array
+            values = value.map do |value_i|
+              if value_i.is_a?(String)
+                self.class.escape(value_i)
+              elsif value_i.is_a?(ActiveRecord::Base)
+                value_i.id
+              else
+                value_i
+              end
+            end
+            @value = "(#{values.join(', ')})"
+          elsif value.class == Babik::QuerySet::Base
+            @value = "(#{value.sql.select})"
+          elsif value.class == String
+            @value = "('#{self.class.escape(value)}')"
+          else
+            @value = "(#{value})"
+          end
+        end
+
+        def _init_sql_operation
+          @sql_operation = @sql_operation_template.sub('?field', @field).sub('?value', @value)
+        end
+      end
+
+      # IS NULL operation
+      class IsNull < Base
+        def initialize(field, value)
+          sql_operation = value ? '?field IS NULL' : '?field IS NOT NULL'
+          super(field, sql_operation, value)
+        end
+      end
+
+      # Less than comparison
+      class LessThan < BinaryOperation
+        SQL_OPERATOR = '<'
+      end
+
+      # Less than or equal comparison
+      class LessThanOrEqual < BinaryOperation
+        SQL_OPERATOR = '<='
+      end
+
+      # Greater than comparison
+      class GreaterThan < BinaryOperation
+        SQL_OPERATOR = '>'
+      end
+
+      # Greater than or equal comparison
+      class GreaterThanOrEqual < BinaryOperation
+        SQL_OPERATOR = '>='
+      end
+
+      # Between comparison (check the value is between two different values)
+      class Between < Base
+        def initialize(field, value)
+          super(field, '?field BETWEEN ?value1 AND ?value2', value)
+        end
+
+        def _init_sql_operation
+          if @value.class == Array
+            if [@value[0], @value[1]].map { |v| [DateTime, Date, Time].include?(v.class) } == [true, true]
+              value1 = "'#{@value[0].utc.to_s(:db)}'"
+              value2 = "'#{@value[1].utc.to_s(:db)}'"
+            else
+              value1 = self.class.escape(@value[0])
+              value2 = self.class.escape(@value[1])
+            end
+            @sql_operation = @sql_operation_template.sub('?field', @field).sub('?value1', value1).sub('?value2', value2)
+          else
+            raise 'Array is needed if operator is between'
+          end
+        end
+      end
+
+      class StartsWith < BinaryOperation
+        SQL_OPERATOR = 'LIKE'
+        def _init_sql_operation
+          escaped_value = self.class.escape("#{@value}%")
+          @sql_operation = @sql_operation_template.sub('?field', @field).sub('?value', escaped_value)
+        end
+      end
+
+      class IStartsWith < StartsWith
+        SQL_OPERATOR = 'ILIKE'
+      end
+
+      class EndsWith < BinaryOperation
+        SQL_OPERATOR = 'LIKE'
+        def _init_sql_operation
+          escaped_value = self.class.escape("%#{@value}")
+          @sql_operation = @sql_operation.sub('?field', @field).sub('?value', escaped_value)
+        end
+      end
+
+      class IEndsWith < StartsWith
+        SQL_OPERATOR = 'ILIKE'
+      end
+
+      class Contains < BinaryOperation
+        SQL_OPERATOR = 'LIKE'
+        def _init_sql_operation
+          escaped_value = self.class.escape("%#{@value}%")
+          @sql_operation = @sql_operation_template.sub('?field', @field).sub('?value', escaped_value)
+        end
+      end
+
+      class IContains < Contains
+        SQL_OPERATOR = 'ILIKE'
+      end
+
+      CORRESPONDENCE = {
+        default: Equal,
+        equal: Equal,
+        equals: Equal,
+        equals_to: Equal,
+        exact: Exact,
+        iexact: IExact,
+        different: Different,
+        in: In,
+        isnull: IsNull,
+        lt: LessThan,
+        lte: LessThanOrEqual,
+        gt: GreaterThan,
+        gte: GreaterThanOrEqual,
+        between: Between,
+        range: Between,
+        startswith: StartsWith,
+        endswith: EndsWith,
+        contains: Contains,
+        istartswith: IStartsWith,
+        iendswith: IEndsWith,
+        icontains: IContains,
+        regex: Babik::Selection::Operation::Regex,
+        iregex: IRegex,
+        year: Year,
+        quarter: Quarter,
+        month: Month,
+        day: Day,
+        week_day: WeekDay,
+        week: Week,
+        hour: Hour,
+        minute: Minute,
+        second: Second,
+        time: Babik::Selection::Operation::Time
+      }.freeze
+
+    end
+  end
+end