active_house 0.4.0 → 0.5.0

data/lib/active_house/querying/collect.rb

@@ -0,0 +1,80 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string/filters'
+require 'active_support/core_ext/module/delegation'
+
+module ActiveHouse
+  module Querying
+    module Collect
+      extend ActiveSupport::Concern
+
+      included do
+        private :collection, :fetch_collection, :query_parts, :build_query
+        instance_delegate [
+            :each,
+            :size,
+            :count,
+            :map,
+            :collect,
+            :detect,
+            :filter,
+            :reject,
+            :inject,
+            :reduce,
+            :all?,
+            :any?
+        ] => :to_a
+      end
+
+      def initialize(*)
+        @collection = nil
+        super
+      end
+
+      def to_a
+        collection
+      end
+
+      def reset
+        @collection = nil
+      end
+
+      def loaded?
+        !@collection.nil?
+      end
+
+      def to_hashes
+        connection.select_rows(build_query.squish)
+      end
+
+      def to_query
+        build_query
+      end
+
+      def collection
+        @collection ||= fetch_collection
+      end
+
+      def fetch_collection
+        to_hashes.map { |row| model_class.load!(row) }
+      end
+
+      def query_parts
+        [
+            build_select_query_part,
+            build_from_query_part,
+            build_array_join_query_part,
+            build_where_query_part,
+            build_group_by_query_part,
+            build_having_query_part,
+            build_order_by_query_part,
+            build_limit_query_part,
+            build_union_query_part
+        ]
+      end
+
+      def build_query
+        query_parts.reject(&:nil?).join("\n")
+      end
+    end
+  end
+end

data/lib/active_house/querying/from.rb

@@ -0,0 +1,30 @@
+module ActiveHouse
+  module Querying
+    module From
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_from_query_part, :from_subquery
+      end
+
+      def from_subquery
+        return model_class._table_name if values[:subquery].nil?
+        query = values[:subquery].is_a?(ActiveHouse::QueryBuilder) ? values[:subquery].to_query : values[:subquery].to_s
+        "( #{query} )"
+      end
+
+      def build_from_query_part
+        "FROM #{from_subquery}"
+      end
+
+      def from!(table_or_subquery)
+        values[:subquery] = table_or_subquery.dup
+        self
+      end
+
+      def from(table_or_subquery)
+        dup.from!(table_or_subquery)
+      end
+    end
+  end
+end

data/lib/active_house/querying/group_by.rb

@@ -0,0 +1,30 @@
+module ActiveHouse
+  module Querying
+    module GroupBy
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_group_by_query_part
+      end
+
+      def build_group_by_query_part
+        "GROUP BY #{values[:group_by].join(', ')}" unless values[:group_by].empty?
+      end
+
+      def initial_values
+        super.merge group_by: []
+      end
+
+      def group_by!(*fields)
+        raise ArgumentError, 'wrong number of arguments' if fields.empty?
+        formatted_fields = fields.map(&:to_s)
+        values[:group_by] = (values[:group_by] + formatted_fields).uniq
+        self
+      end
+
+      def group_by(*fields)
+        dup.group_by!(*fields)
+      end
+    end
+  end
+end

data/lib/active_house/querying/having.rb

@@ -0,0 +1,41 @@
+require_relative '../prepared_statement'
+require 'active_support/core_ext/array/wrap'
+
+module ActiveHouse
+  module Querying
+    module Having
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_having_query_part, :format_having
+      end
+
+      def build_having_query_part
+        "HAVING\n" + values[:having].join(" AND\n") unless values[:having].empty?
+      end
+
+      def initial_values
+        super.merge having: []
+      end
+
+      def having!(*conditions)
+        formatted_conditions = format_having(conditions)
+        values[:having] = (values[:having] + formatted_conditions).uniq
+        self
+      end
+
+      def having(*conditions)
+        dup.having!(*conditions)
+      end
+
+      def format_having(conditions)
+        raise ArgumentError, 'wrong number of arguments' if conditions.empty?
+        raise ArgumentError, 'wrong number of arguments' if conditions.empty?
+
+        return [ActiveHouse::PreparedStatement.prepare_sql(*conditions)] if conditions.size > 1
+
+        ActiveHouse::PreparedStatement.build_condition(conditions.first)
+      end
+    end
+  end
+end

data/lib/active_house/querying/limit.rb

@@ -0,0 +1,35 @@
+module ActiveHouse
+  module Querying
+    module Limit
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_limit_query_part
+      end
+
+      def build_limit_query_part
+        return if values[:limit].nil?
+        if values[:offset]
+          "LIMIT #{values[:limit]}, #{values[:offset]}"
+        else
+          "LIMIT #{values[:limit]}"
+        end
+      end
+
+      def initial_values
+        super.merge offset: nil, limit: nil
+        super
+      end
+
+      def limit!(limit_value, offset_value = nil)
+        values[:limit] = limit_value
+        values[:offset] = offset_value unless offset_value.nil?
+        self
+      end
+
+      def limit(limit_value, offset_value = nil)
+        dup.limit!(limit_value, offset_value)
+      end
+    end
+  end
+end

data/lib/active_house/querying/order_by.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/object/try'
+
+module ActiveHouse
+  module Querying
+    module OrderBy
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_order_by_query_part
+      end
+
+      def build_order_by_query_part
+        "ORDER BY #{values[:order_by].join(', ')}" unless values[:order_by].empty?
+      end
+
+      def initial_values
+        super.merge order_by: []
+      end
+
+      def order_by!(*clauses)
+        formatter_clauses = format_order_clauses(clauses)
+        values[:order_by] = (values[:order_by] + formatter_clauses).uniq
+        self
+      end
+
+      def order_by(*clauses)
+        dup.order_by!(*clauses)
+      end
+
+      def format_order_clauses(clauses)
+        raise ArgumentError, 'wrong number of arguments' if clauses.empty?
+
+        clauses.map do |clause|
+          if clause.is_a?(Hash)
+            format_order_hash(clause)
+          else
+            clause.to_s
+          end
+        end
+      end
+
+      def format_order_hash(clause)
+        if clause.keys.one?
+          direction = clause.values.first
+          raise ArgumentError, 'direction must be asc or desc' unless [:asc, :desc].include?(direction.try!(:to_sym))
+          "#{clause.keys.first} #{direction.to_s.upcase}"
+        else
+          clause.assert_valid_keys(:field, :direction, :collate)
+          [
+              clause.fetch(:field),
+              clause[:direction].try!(:to_s).try!(:upcase),
+              clause.key?(:collate) ? "COLLATE '#{clause[:collate]}'" : nil
+          ].reject(&:nil?).join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/active_house/querying/scope.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+
+module ActiveHouse
+  module Querying
+    module Scope
+      extend ActiveSupport::Concern
+
+      included do
+        private :apply_scope, :scope?
+      end
+
+      class_methods do
+        def new(*)
+          super._apply_default_scope
+        end
+      end
+
+      def _apply_default_scope
+        return self if model_class._default_scope.nil?
+        apply_scope(model_class._default_scope)
+      end
+
+      def respond_to_missing?(method_name, *_args)
+        scope?(method_name) || super
+      end
+
+      def method_missing(method_name, *args, &_block)
+        if scope?(method_name)
+          apply_scope(method_name, *args)
+        else
+          super
+        end
+      end
+
+      def apply_scope(name, *args)
+        scope = model_class._scopes.fetch(name)
+        instance_exec(*args, &scope)
+      end
+
+      def scope?(name)
+        model_class.scope?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/active_house/querying/select.rb

@@ -0,0 +1,35 @@
+require_relative '../prepared_statement'
+
+module ActiveHouse
+  module Querying
+    module Select
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_select_query_part
+      end
+
+      def build_select_query_part
+        if !values[:fields].empty?
+          "SELECT\n#{values[:fields].join(",\n")}"
+        else
+          'SELECT *'
+        end
+      end
+
+      def initial_values
+        super.merge fields: []
+      end
+
+      def select(*fields)
+        dup.select!(*fields)
+      end
+
+      def select!(*fields)
+        formatted_fields = ActiveHouse::PreparedStatement.format_fields(model_class, fields)
+        values[:fields] = (values[:fields] + formatted_fields).uniq
+        self
+      end
+    end
+  end
+end

data/lib/active_house/querying/union.rb

@@ -0,0 +1,67 @@
+module ActiveHouse
+  module Querying
+    module Union
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_union_query_part, :format_unions
+      end
+
+      def build_union_query_part
+        return if values[:union].values.empty?
+
+        "UNION ALL\n#{values[:union].values.map(&:to_query).join("\n")}"
+      end
+
+      def initial_values
+        super.merge union: {}
+      end
+
+      # @param queries [Hash] - hash where key is union name and value is a query
+      # key needed for possibility to update/replace union query
+      def union!(queries)
+        formatted_queries = format_unions(queries)
+        values[:union] = formatted_queries
+        self
+      end
+
+      # @param queries [Hash] - hash where key is union name and value is a query
+      # key needed for possibility to update/replace union query
+      def union(queries)
+        dup.union!(queries)
+      end
+
+      def update_union(name)
+        name = name.to_sym
+        raise ArgumentError, "can't find union by name #{name}" unless values[:union].key?(name)
+        new_union = yield values[:union][name.to_sym]
+        union(name.to_sym => new_union)
+      end
+
+      def except_union!(name)
+        new_unions = values[:union].map { |n, q| [n, q.dup] }.to_h
+        new_unions.delete(name.to_sym)
+        values[:union] = new_unions
+        self
+      end
+
+      def except_union(name)
+        dup.except_union!(name)
+      end
+
+      def format_unions(queries)
+        raise ArgumentError, 'unions must be a Hash' unless queries.is_a?(Hash)
+        raise ArgumentError, 'unions hash is empty' if queries.empty?
+
+        new_unions = values[:union].map { |n, q| [n, q.dup] }.to_h
+
+        queries.each do |name, query|
+          query = query.all if query.is_a?(ActiveHouse::Model)
+          new_unions[name.to_sym] = query.dup
+        end
+
+        new_unions
+      end
+    end
+  end
+end

data/lib/active_house/querying/where.rb

@@ -0,0 +1,50 @@
+require_relative '../prepared_statement'
+
+module ActiveHouse
+  module Querying
+    module Where
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_where_query_part
+      end
+
+      def initial_values
+        super.merge where: []
+      end
+
+      def build_where_query_part
+        "WHERE\n" + values[:where].join(" AND\n") unless values[:where].empty?
+      end
+
+      def where!(*conditions)
+        formatted_conditions = format_where_clauses(conditions)
+        values[:where] = (values[:where] + formatted_conditions).uniq
+        self
+      end
+
+      def where_not!(*conditions)
+        formatted_conditions = format_where_clauses(conditions)
+        negative_condition = "NOT (#{formatted_conditions.join(' AND ')})"
+        values[:where] = (values[:where] + [negative_condition]).uniq
+        self
+      end
+
+      def where(*conditions)
+        dup.where!(*conditions)
+      end
+
+      def where_not(*conditions)
+        dup.where_not!(*conditions)
+      end
+
+      def format_where_clauses(conditions)
+        raise ArgumentError, 'wrong number of arguments' if conditions.empty?
+
+        return [ActiveHouse::PreparedStatement.prepare_sql(*conditions)] if conditions.size > 1
+
+        ActiveHouse::PreparedStatement.build_condition(conditions.first)
+      end
+    end
+  end
+end