b_b 0.1.0

data/lib/b_b/builder.rb

@@ -0,0 +1,81 @@
+module BB
+  class Builder
+    attr_reader :from, :group, :group_each, :limit, :omit_record_if,
+                :order, :select, :having, :where, :joins
+
+    attr_accessor :options
+
+    def initialize
+      @joins   = []
+      @options = {}
+    end
+
+    def build
+      structure.flatten.compact.map(&:build).join(" ")
+    end
+
+    def assign(name)
+      get_factory_ivar(name).tap do |factory|
+        append_options!(factory)
+      end
+    end
+
+    def append_joins(name)
+      register_factory(name).tap do |factory|
+        append_options!(factory)
+        joins << factory
+      end
+    end
+
+    def add_option_to_just_before_join(rel)
+      return if joins.empty?
+
+      joins.last.options[:rel] = rel
+    end
+
+    def add_offset_to_limit(offset)
+      return if limit.nil?
+
+      limit.options[:offset] = offset
+    end
+
+    private
+
+    def structure
+      [select_clause, from, joins, omit_record_if, where, group_clause, having, order, limit]
+    end
+
+    def select_clause
+      select || unless from.nil?
+                  get_factory_ivar(:select).tap do |factory|
+                    factory.append_formatted_filters(%w(*))
+                  end
+                end
+    end
+
+    def group_clause
+      group || group_each
+    end
+
+    def get_factory_ivar(name)
+      instance_variable_get("@#{name}") || set_factory_ivar(name)
+    end
+
+    def set_factory_ivar(name)
+      register_factory(name).tap do |factory|
+        instance_variable_set("@#{name}", factory)
+      end
+    end
+
+    def append_options!(factory)
+      return if options.empty?
+
+      factory.options.merge!(options)
+      options.clear
+    end
+
+    def register_factory(name)
+      Factory.build(name)
+    end
+  end
+end

data/lib/b_b/component.rb

@@ -0,0 +1,81 @@
+module BB
+  class Component
+    TEMPLATE = {
+      cross_join:                "CROSS JOIN %s AS %s",
+      from:                      "FROM %s",
+      from_union_all_with_alias: "FROM (SELECT * FROM %s) AS %s",
+      from_with_alias:           "FROM %s AS %s",
+      full_outer_join_each:      "FULL OUTER JOIN EACH %s AS %s ON %s",
+      group:                     "GROUP BY %s",
+      group_each:                "GROUP EACH BY %s",
+      having:                    "HAVING %s",
+      inner_join:                "INNER JOIN %s AS %s ON %s",
+      inner_join_each:           "INNER JOIN EACH %s AS %s ON %s",
+      join:                      "JOIN %s AS %s ON %s",
+      join_each:                 "JOIN EACH %s AS %s ON %s",
+      left_join:                 "LEFT JOIN %s AS %s ON %s",
+      left_join_each:            "LEFT JOIN EACH %s AS %s ON %s",
+      left_outer_join:           "LEFT OUTER JOIN %s AS %s ON %s",
+      left_outer_join_each:      "LEFT OUTER JOIN EACH %s AS %s ON %s",
+      limit:                     "LIMIT %d",
+      limit_with_offset:         "LIMIT %d OFFSET %d",
+      omit_record_if:            "OMIT RECORD IF %s",
+      order:                     "ORDER BY %s",
+      right_join:                "RIGHT JOIN EACH %s AS %s ON %s",
+      right_join_each:           "RIGHT JOIN EACH %s AS %s ON %s",
+      right_outer_join:          "RIGHT OUTER JOIN EACH %s AS %s ON %s",
+      right_outer_join_each:     "RIGHT OUTER JOIN EACH %s AS %s ON %s",
+      select:                    "SELECT %s",
+      where:                     "WHERE %s"
+    }.freeze
+
+    attr_accessor :filters, :options, :type
+
+    def initialize
+      @filters = []
+      @options = {}
+    end
+
+    def build
+      type && send("to_#{type}")
+    end
+
+    private
+
+    (API[:joins] - [:to_cross_join]).each do |name|
+      define_method("to_#{name}") do
+        format(TEMPLATE[name.to_sym], filters[0], options[:as], options[:rel])
+      end
+    end
+
+    %i(cross_join from_with_alias).each do |name|
+      define_method("to_#{name}") do
+        format(TEMPLATE[name.to_sym], filters[0], options[:as])
+      end
+    end
+
+    %i(from group group_each order select).each do |name|
+      define_method("to_#{name}") do
+        format(TEMPLATE[name.to_sym], filters.join(", "))
+      end
+    end
+
+    %i(having omit_record_if where).each do |name|
+      define_method("to_#{name}") do
+        format(TEMPLATE[name.to_sym], filters.join(" "))
+      end
+    end
+
+    def to_from_union_all_with_alias
+      format(TEMPLATE[:from_union_all_with_alias], filters.join(", "), options[:as])
+    end
+
+    def to_limit
+      format(TEMPLATE[:limit], filters.last)
+    end
+
+    def to_limit_with_offset
+      format(TEMPLATE[:limit_with_offset], filters.last, options[:offset])
+    end
+  end
+end

data/lib/b_b/converter/formula.rb

@@ -0,0 +1,87 @@
+module BB
+  module Converter
+    class Formula
+      TEMPLATE = {
+        between:      "%s BETWEEN %s",
+        contains:     "%s CONTAINS %s",
+        equals:       "%s = %s",
+        gt:           "%s > %s",
+        gteq:         "%s >= %s",
+        in:           "%s IN %s",
+        is:           "%s IS %s",
+        lt:           "%s < %s",
+        lteq:         "%s <= %s",
+        match:        "REGEXP_MATCH(%s, %s)",
+        not_between:  "NOT %s BETWEEN %s",
+        not_contains: "NOT %s CONTAINS %s",
+        not_equals:   "%s <> %s",
+        not_gt:       "NOT %s > %s",
+        not_gteq:     "NOT %s >= %s",
+        not_in:       "NOT %s IN %s",
+        not_is:       "%s IS NOT %s",
+        not_lt:       "NOT %s < %s",
+        not_lteq:     "NOT %s <= %s",
+        not_match:    "NOT REGEXP_MATCH(%s, %s)"
+      }.freeze
+
+      OPERATORS_DICTIONARY = {
+        cont:         :contains,
+        contains:     :contains,
+        eq:           :equals,
+        eql:          :equals,
+        equals:       :equals,
+        gt:           :gt,
+        gteq:         :gteq,
+        like:         :contains,
+        lt:           :lt,
+        lteq:         :lteq,
+        not_cont:     :not_contains,
+        not_contains: :not_contains,
+        not_eq:       :not_equals,
+        not_eql:      :not_equals,
+        not_equals:   :not_equals,
+        not_gt:       :not_gt,
+        not_gteq:     :not_gteq,
+        not_like:     :not_contains,
+        not_lt:       :not_lt,
+        not_lteq:     :not_lteq
+      }.freeze
+
+      SEARCHABLE_COLUMN_FORMAT = /(?:(\w+)_(not_\w+)|(\w+)_(\w+))/
+
+      attr_reader :column, :operator, :value, :options
+
+      def initialize(column, value, options = {})
+        @column  = format_column(column)
+        @value   = format_value(value)
+        @options = options
+      end
+
+      def convert
+        evaluated_type = Evaluator::Formula.eval_type(value, options.merge(operator: operator))
+        evaluated_type && format(TEMPLATE[evaluated_type], column, value.convert)
+      end
+
+      private
+
+      def format_column(column)
+        scanned_column = column.to_s.scan(SEARCHABLE_COLUMN_FORMAT).flatten.compact
+        !scanned_column.empty? && format_operator(scanned_column[1]) ? scanned_column[0] : column
+      end
+
+      def format_operator(operator)
+        @operator = OPERATORS_DICTIONARY[operator.to_sym]
+      end
+
+      def format_value(value)
+        value.is_a?(Value) ? value : Value.new(value)
+      end
+
+      class << self
+        def convert(column, value, options = {})
+          new(column, value, options).convert
+        end
+      end
+    end
+  end
+end

data/lib/b_b/converter/order.rb

@@ -0,0 +1,30 @@
+module BB
+  module Converter
+    class Order
+      TEMPLATE = "%s %s".freeze
+
+      attr_reader :column, :sort_key
+
+      def initialize(column, options = {})
+        @column   = column
+        @sort_key = format_sort_key(options[:sort_key])
+      end
+
+      def convert
+        format(TEMPLATE, column, sort_key)
+      end
+
+      private
+
+      def format_sort_key(sort_key)
+        sort_key.to_s.casecmp("DESC").zero? ? :DESC : :ASC
+      end
+
+      class << self
+        def convert(column, options = {})
+          new(column, options).convert
+        end
+      end
+    end
+  end
+end

data/lib/b_b/converter/table.rb

@@ -0,0 +1,49 @@
+module BB
+  module Converter
+    class Table
+      TEMPLATE = {
+        subquery: "(%s)",
+        table_date_range: "TABLE_DATE_RANGE(%s, %s, %s)"
+      }.freeze
+
+      attr_reader :value, :options
+
+      def initialize(value, options = {})
+        @value   = value
+        @options = options
+      end
+
+      def convert
+        evaluated_type = Evaluator::Table.eval_type(value, options)
+        evaluated_type && send("to_#{evaluated_type}")
+      end
+
+      private
+
+      def to_subquery
+        format(TEMPLATE[:subquery], value.to_sql)
+      end
+
+      def to_table_date
+        options[:on].strftime("#{value}%Y%m%d")
+      end
+
+      def to_table_date_range
+        from = Value.convert(options[:from], type: :timestamp)
+        to   = Value.convert(options[:to],   type: :timestamp)
+
+        format(TEMPLATE[:table_date_range], value, from, to)
+      end
+
+      def to_plain
+        value.to_s
+      end
+
+      class << self
+        def convert(value, options = {})
+          new(value, options).convert
+        end
+      end
+    end
+  end
+end

data/lib/b_b/converter/value.rb

@@ -0,0 +1,99 @@
+module BB
+  module Converter
+    class Value
+      TEMPLATE = {
+        array:     "(%s)",
+        date:      "DATE('%Y-%m-%d')",
+        null:      "NULL",
+        range:     "%s AND %s",
+        regexp:    "r'%s'",
+        string:    "'%s'",
+        subquery:  "(%s)",
+        time:      "TIMESTAMP('%Y-%m-%d %H:%M:%S')",
+        timestamp: "TIMESTAMP('%Y-%m-%d')"
+      }.freeze
+
+      attr_reader :value, :options, :type
+
+      def initialize(value, options = {})
+        @value   = value
+        @options = options
+        @type    = format_type
+      end
+
+      def convert
+        send("to_#{type}")
+      end
+
+      private
+
+      def format_type
+        options[:type] || Evaluator::Value.eval_type(value, options)
+      end
+
+      def to_array
+        format(TEMPLATE[:array], value.map(&method(:convert_member_value)).join(", "))
+      end
+
+      def to_boolean
+        value.to_s
+      end
+
+      alias_method(:to_numeric, :to_boolean)
+
+      def to_date
+        value.strftime(TEMPLATE[:date])
+      end
+
+      def to_time
+        value.strftime(TEMPLATE[:time])
+      end
+
+      def to_timestamp
+        value.strftime(TEMPLATE[:timestamp])
+      end
+
+      def to_null
+        TEMPLATE[:null]
+      end
+
+      def to_range
+        range_values = extract_range_values(value).map(&method(:convert_member_value))
+        format(TEMPLATE[:range], range_values[0], range_values[1])
+      end
+
+      def to_regexp
+        format(TEMPLATE[:regexp], value.inspect[1..-2])
+      end
+
+      def to_string
+        format(TEMPLATE[:string], value)
+      end
+
+      def to_subquery
+        format(TEMPLATE[:subquery], value.to_sql)
+      end
+
+      def convert_member_value(value)
+        self.class.convert(value, eval_types: %i(boolean date null numeric string time))
+      end
+
+      def extract_range_values(value)
+        [].tap do |arr|
+          arr << value.begin
+          arr << if value.exclude_end?
+                   (!value.end.is_a?(Time) ? value.last(1)[0] : value.last - 1)
+                 else
+                   value.end
+                 end
+        end
+      end
+
+      class << self
+        def convert(value, options = {})
+          new(value, options).convert
+        end
+      end
+    end
+  end
+end

data/lib/b_b/converter.rb

@@ -0,0 +1,8 @@
+module BB
+  module Converter
+    autoload :Formula, "b_b/converter/formula"
+    autoload :Order,   "b_b/converter/order"
+    autoload :Table,   "b_b/converter/table"
+    autoload :Value,   "b_b/converter/value"
+  end
+end

data/lib/b_b/evaluator/formula.rb

@@ -0,0 +1,81 @@
+module BB
+  module Evaluator
+    class Formula
+      EVALUATE_TYPES = %i(between contains equals gt gteq in is lt lteq match).freeze
+
+      attr_reader :value, :operator, :negation
+
+      def initialize(value, options = {})
+        @value    = value
+        @operator = options[:operator]
+        @negation = options[:negation]
+      end
+
+      def eval_type
+        evaluated_type = EVALUATE_TYPES.detect { |type| send("#{type}?") }
+
+        if !evaluated_type.nil? && negative? && !double_negative?
+          :"not_#{evaluated_type}"
+        else
+          evaluated_type
+        end
+      end
+
+      private
+
+      def negative?
+        negation || operator.to_s.start_with?("not")
+      end
+
+      def double_negative?
+        negation && operator.to_s.start_with?("not")
+      end
+
+      def between?
+        value.type == :range
+      end
+
+      def contains?
+        %i(contains not_contains).include?(operator)
+      end
+
+      def equals?
+        %i(date numeric string time).include?(value.type) && (operator.nil? || %i(equals not_equals).include?(operator))
+      end
+
+      def gt?
+        %i(gt not_gt).include?(operator)
+      end
+
+      def gteq?
+        %i(gteq not_gteq).include?(operator)
+      end
+
+      def in?
+        %i(array subquery).include?(value.type)
+      end
+
+      def is?
+        %i(boolean null).include?(value.type)
+      end
+
+      def lt?
+        %i(lt not_lt).include?(operator)
+      end
+
+      def lteq?
+        %i(lteq not_lteq).include?(operator)
+      end
+
+      def match?
+        value.type == :regexp
+      end
+
+      class << self
+        def eval_type(value, options = {})
+          new(value, options).eval_type
+        end
+      end
+    end
+  end
+end

data/lib/b_b/evaluator/table.rb

@@ -0,0 +1,42 @@
+module BB
+  module Evaluator
+    class Table
+      EVALUATE_TYPES = %i(subquery table_date table_date_range plain).freeze
+
+      attr_reader :value, :options
+
+      def initialize(value, options = {})
+        @value   = value
+        @options = options
+      end
+
+      def eval_type
+        EVALUATE_TYPES.detect { |type| send("#{type}?") }
+      end
+
+      private
+
+      def subquery?
+        value.respond_to?(:to_sql)
+      end
+
+      def table_date?
+        !value.to_s.empty? && options[:on].respond_to?(:strftime)
+      end
+
+      def table_date_range?
+        !value.to_s.empty? && options[:from].respond_to?(:strftime) && options[:to].respond_to?(:strftime)
+      end
+
+      def plain?
+        !value.to_s.empty? && !table_date? && !table_date_range? && !subquery?
+      end
+
+      class << self
+        def eval_type(value, options = {})
+          new(value, options).eval_type
+        end
+      end
+    end
+  end
+end

data/lib/b_b/evaluator/value.rb

@@ -0,0 +1,72 @@
+module BB
+  module Evaluator
+    class Value
+      EVALUATE_TYPES = %i(array boolean date null numeric range regexp string subquery time).freeze
+
+      attr_reader :value, :options
+
+      def initialize(value, options = {})
+        @value   = value
+        @options = options
+      end
+
+      def eval_type
+        eval_types.detect { |type| send("#{type}?") }.tap do |type|
+          raise UnevaluableTypeError, "unevaluable type of value: #{value} (#{value.class})" if type.nil?
+        end
+      end
+
+      private
+
+      def eval_types
+        options[:eval_types] || EVALUATE_TYPES
+      end
+
+      def array?
+        value.is_a?(Array) && !value.empty?
+      end
+
+      def boolean?
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      def date?
+        value.respond_to?(:strftime) && !value.respond_to?(:hour)
+      end
+
+      def null?
+        value.nil?
+      end
+
+      def numeric?
+        value.is_a?(Numeric)
+      end
+
+      def range?
+        value.is_a?(Range) && !value.size.is_a?(Float)
+      end
+
+      def regexp?
+        value.is_a?(Regexp)
+      end
+
+      def string?
+        value.is_a?(String) || value.is_a?(Symbol)
+      end
+
+      def subquery?
+        value.respond_to?(:to_sql)
+      end
+
+      def time?
+        value.respond_to?(:strftime) && value.respond_to?(:hour)
+      end
+
+      class << self
+        def eval_type(value, options = {})
+          new(value, options).eval_type
+        end
+      end
+    end
+  end
+end

data/lib/b_b/evaluator.rb

@@ -0,0 +1,7 @@
+module BB
+  module Evaluator
+    autoload :Formula, "b_b/evaluator/formula"
+    autoload :Table,   "b_b/evaluator/table"
+    autoload :Value,   "b_b/evaluator/value"
+  end
+end

data/lib/b_b/exception.rb

@@ -0,0 +1,13 @@
+module BB
+  # A general BB exception
+  class Error < StandardError; end
+
+  # Raised when using relation methods without calling required arguments.
+  class ArgumentError < Error; end
+
+  # Raised when behavior is not implemented, usually used in an abstract class.
+  class NotImplementedError < Error; end
+
+  # Raised when using evaluation methods
+  class UnevaluableTypeError < Error; end
+end