active_house 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7200836f06d8f9970958725e34d7114396628bfc
-  data.tar.gz: 5af9fe43759f8bfec281614e90d1ddb77d03bbbe
+  metadata.gz: 460006ab1e148781921648c680e33a79790e35cd
+  data.tar.gz: eb9ee437906deca34b1c6bb3bb172dc4bfcdab7b
 SHA512:
-  metadata.gz: b2b52863ddcbb884f18cdaaccd9c48562f470c5a06fe6b66863cbe28befdfc009419159b559a22796044c3bc35cec6bcfe564c79dbed123bb982a8f6158cfc8c
-  data.tar.gz: 88331b558031b0e5f6b3418b666127c81ba7378216693c84b976885fc726301e8c5334efee9c0b3d63e681353600083cbfbbeb3ac5da16f3099a04ef9ccd1572
+  metadata.gz: 190813fb7b150e48c7c75c1a53ef12e5dc589ab60b109cf65463644ba3e4c17dd0c94b6fd927e778811dd1e631c0163ec5e6ef7fa5b72425aa34fd68eaca89fc
+  data.tar.gz: 16fdecaf5792d2641aca7cd2b3e777d195894cbabe593b2ef1719ad16f83313fc547b3863829bcf764896b75b6721e77f90a08a420574f6d5ca46eb8d7c757f7

data/.rubocop.yml

@@ -37,3 +37,12 @@ Layout/IndentArray:
 
 Layout/IndentHash:
   IndentationWidth: 4
+
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/AccessModifierDeclarations:
+  Enabled: false

data/active_house.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activemodel'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'clickhouse', '~> 0.1.10'
+  spec.add_dependency 'plain_model', '~> 0.2'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'minitest', '~> 5.0'

data/lib/active_house.rb

@@ -1,6 +1,6 @@
 require 'active_house/version'
 require 'active_house/configuration'
-require 'active_house/query'
+require 'active_house/query_builder'
 require 'active_house/model'
 
 module ActiveHouse

data/lib/active_house/connection.rb

@@ -1,7 +1,7 @@
-require_relative 'connection_error'
-require_relative 'prepared_statement'
 require 'clickhouse/cluster'
 require 'clickhouse/connection'
+require_relative 'exceptions'
+require_relative 'prepared_statement'
 
 module ActiveHouse
   class Connection
@@ -72,7 +72,7 @@ module ActiveHouse
 
     def ensure_connected!
       @connection = establish_connection unless connection_alive?
-      raise ActiveHouse::ConnectionError unless connection_alive?
+      raise ActiveHouse::Exceptions::ConnectionError unless connection_alive?
     end
 
     def establish_connection

data/lib/active_house/exceptions.rb

@@ -0,0 +1,9 @@
+module ActiveHouse
+  module Exceptions
+    class Error < ::StandardError
+    end
+
+    class ConnectionError < Error
+    end
+  end
+end

data/lib/active_house/{logger.rb → logging.rb}

@@ -1,7 +1,7 @@
 require 'active_support/concern'
 
 module ActiveHouse
-  module Logger
+  module Logging
     extend ActiveSupport::Concern
 
     class_methods do

data/lib/active_house/model.rb

@@ -1,20 +1,22 @@
-require_relative 'scoping'
-require_relative 'querying'
-require_relative 'modeling'
-require_relative 'connecting'
-require_relative 'logger'
 require 'active_model/conversion'
 require 'active_model/naming'
+require 'plain_model/modeling/base'
+require 'plain_model/modeling/queryable'
+require_relative 'modeling/scope'
+require_relative 'modeling/query'
+require_relative 'modeling/attributes'
+require_relative 'modeling/connection'
+require_relative 'logging'
 
 module ActiveHouse
   class Model
-    include ActiveHouse::Scoping
-    include ActiveHouse::Querying
-    include ActiveHouse::Modeling
-    include ActiveHouse::Connecting
-    include ActiveHouse::Logger
-    include ActiveModel::Conversion
-    extend ActiveModel::Naming
+    extend PlainModel::Modeling::Queryable
+    include PlainModel::Modeling::Base
+    include ActiveHouse::Modeling::Scope
+    include ActiveHouse::Modeling::Query
+    include ActiveHouse::Modeling::Attributes
+    include ActiveHouse::Modeling::Connection
+    include ActiveHouse::Logging
 
     class_attribute :_table_name, instance_accessor: false
 

data/lib/active_house/modeling/attributes.rb

@@ -0,0 +1,102 @@
+require 'active_support/concern'
+
+module ActiveHouse
+  module Modeling
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_attribute_opts, instance_writer: false
+        self._attribute_opts = {}
+
+        private
+
+        def parse_attribute_method_name(method_name)
+          name, is_setter = method_name.to_s.match(/\A(.+)?(=)?\z/).captures
+          name = name.to_sym
+          is_setter = !is_setter.nil?
+          [name, is_setter]
+        end
+
+        def attribute_method?(name, is_setter, *args)
+          (_attribute_opts.key?(name) || @_attributes.key?(name)) && (is_setter ? args.size == 1 : true)
+        end
+
+        def get_attribute(name)
+          @_attributes[name]
+        end
+
+        def set_attribute(name, value)
+          opts = _attribute_opts.fetch(name, {})
+          value = opts[:cast].call(value) if opts[:cast]
+          @_attributes[name] = value
+        end
+      end
+
+      class_methods do
+        def attribute(name, options = {})
+          name = name.to_sym
+          self._attribute_opts = _attribute_opts.merge(name => options)
+          define_method(name) do
+            get_attribute(name)
+          end
+          define_method("#{name}=") do |value|
+            set_attribute(name, value)
+          end
+        end
+
+        def attributes(*names)
+          options = names.extract_options!
+          names.each { |name| attribute(name, options.dup) }
+        end
+
+        def load!(params)
+          new.tap do |model|
+            params.each { |name, value| model[name] = value }
+          end
+        end
+      end
+
+      def initialize(params = {})
+        @_attributes = {}
+        assign_attributes(params) unless params.nil?
+      end
+
+      def as_json(*_args)
+        to_h
+      end
+
+      def to_h
+        @_attributes.dup
+      end
+
+      def [](key)
+        get_attribute(key.to_sym)
+      end
+
+      def []=(key, value)
+        set_attribute(key.to_sym, value)
+      end
+
+      def assign_attributes(params)
+        params.each do |key, val|
+          public_send("#{key}=", val)
+        end
+      end
+
+      def respond_to_missing?(method_name, *args)
+        name, is_setter = parse_attribute_method_name(method_name)
+        attribute_method?(name, is_setter, *args)
+      end
+
+      def method_missing(method_name, *args, &block)
+        name, is_setter = parse_attribute_method_name(method_name)
+        if attribute_method?(name, is_setter, *args)
+          is_setter ? set_attribute(name, args.first) : get_attribute(name)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_house/modeling/connection.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/concern'
+require_relative '../connection'
+require_relative '../configuration'
+
+module ActiveHouse
+  module Modeling
+    module Connection
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_connection_class, instance_accessor: false
+        class_attribute :_connection, instance_accessor: false
+        self._connection_class = ActiveHouse::Connection
+      end
+
+      class_methods do
+        def ensure_connection
+          establish_connection if _connection.nil?
+        end
+
+        def establish_connection(name_or_config = nil)
+          config = if name_or_config.is_a?(Hash)
+                     name_or_config.symbolize_keys
+                   else
+                     ActiveHouse.configuration.connection_config_for(name_or_config)
+                   end
+          self._connection = _connection_class.new(config)
+        end
+
+        def connection
+          ensure_connection
+          _connection
+        end
+      end
+    end
+  end
+end

data/lib/active_house/modeling/query.rb

@@ -0,0 +1,29 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
+module ActiveHouse
+  module Modeling
+    module Query
+      extend ActiveSupport::Concern
+
+      class_methods do
+        delegate :select,
+                 :array_join,
+                 :left_array_join,
+                 :group_by,
+                 :limit,
+                 :order_by,
+                 :having,
+                 :from,
+                 :union,
+                 :where,
+                 :where_not,
+                 to: :all
+
+        def _query_builder
+          ::ActiveHouse::QueryBuilder.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/active_house/modeling/scope.rb

@@ -0,0 +1,42 @@
+require 'active_support/concern'
+
+module ActiveHouse
+  module Modeling
+    module Scope
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_default_scope, instance_accessor: false
+        class_attribute :_scopes, instance_accessor: false
+        self._scopes = {}
+      end
+
+      class_methods do
+        def default_scope(name)
+          self._default_scope = name.to_sym
+        end
+
+        def scope(name, block)
+          self._scopes = _scopes.merge(name.to_sym => block)
+        end
+
+        def respond_to_missing?(method_name, *_args)
+          scope?(method_name) || super
+        end
+
+        def method_missing(method_name, *args, &_block)
+          if scope?(method_name)
+            scope = _scopes.fetch(method_name.to_sym)
+            all.instance_exec(*args, &scope)
+          else
+            super
+          end
+        end
+
+        def scope?(name)
+          _scopes.key?(name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/active_house/prepared_statement.rb

@@ -18,9 +18,9 @@ module ActiveHouse
         "'#{value.gsub("'", "\\'")}'"
       elsif value.is_a?(Time)
         if value.respond_to?(:zone)
-          "toDateTime('#{value.strftime('%Y-%m-%d %H:%M:%S')}', '#{value.zone}')"
+          "toDateTime('#{value.strftime('%F %T')}', '#{value.zone}')"
         else
-          "toDateTime('#{value.strftime('%Y-%m-%d %H:%M:%S')}')"
+          "toDateTime('#{value.strftime('%F %T')}')"
         end
       else
         value.to_s
@@ -33,5 +33,37 @@ module ActiveHouse
       parts.push('') if sql.end_with?('?')
       parts
     end
+
+    # @param condition [Hash]
+    def self.build_condition(condition)
+      return [condition.to_s] unless condition.is_a?(Hash)
+
+      condition.map do |field, value|
+        "#{field} #{sign_for_condition(value)} #{format_value(value)}"
+      end
+    end
+
+    def self.sign_for_condition(value)
+      if value.is_a?(Array)
+        'IN'
+      elsif value.nil?
+        'IS'
+      else
+        '='
+      end
+    end
+
+    def self.format_fields(model_class, fields)
+      raise ArgumentError, 'wrong number of arguments' if fields.empty?
+
+      fields.map do |field|
+        if field.is_a?(Symbol) && model_class._attribute_opts.key?(field)
+          opts = model_class._attribute_opts.fetch(field)
+          opts.key?(:select) ? "#{opts[:select]} AS #{field}" : field.to_s
+        else
+          field.to_s
+        end
+      end
+    end
   end
 end

data/lib/active_house/query_builder.rb

@@ -0,0 +1,38 @@
+require 'plain_model/querying/base'
+require 'plain_model/querying/except'
+require 'plain_model/querying/with_model'
+require_relative 'querying/select'
+require_relative 'querying/from'
+require_relative 'querying/where'
+require_relative 'querying/order_by'
+require_relative 'querying/group_by'
+require_relative 'querying/having'
+require_relative 'querying/limit'
+require_relative 'querying/union'
+require_relative 'querying/array_join'
+require_relative 'querying/scope'
+require_relative 'querying/collect'
+
+module ActiveHouse
+  class QueryBuilder
+    include PlainModel::Querying::Base
+    include PlainModel::Querying::Except
+    include PlainModel::Querying::WithModel
+
+    include ActiveHouse::Querying::Select
+    include ActiveHouse::Querying::From
+    include ActiveHouse::Querying::Where
+    include ActiveHouse::Querying::OrderBy
+    include ActiveHouse::Querying::GroupBy
+    include ActiveHouse::Querying::Having
+    include ActiveHouse::Querying::Limit
+    include ActiveHouse::Querying::Union
+    include ActiveHouse::Querying::ArrayJoin
+    include ActiveHouse::Querying::Scope
+    include ActiveHouse::Querying::Collect
+
+    def initialize(model_class = nil)
+      super(model_class || ActiveHouse::Model)
+    end
+  end
+end

data/lib/active_house/querying/array_join.rb

@@ -0,0 +1,42 @@
+module ActiveHouse
+  module Querying
+    module ArrayJoin
+      extend ActiveSupport::Concern
+
+      included do
+        private :build_array_join_query_part
+      end
+
+      def build_array_join_query_part
+        parts = []
+        parts << "ARRAY JOIN #{values[:array_join].join(', ')}" unless values[:array_join].empty?
+        parts << "LEFT ARRAY JOIN #{values[:array_join].join(', ')}" unless values[:left_array_join].empty?
+        parts.join("\n")
+      end
+
+      def initial_values
+        super.merge array_join: [], left_array_join: []
+      end
+
+      def array_join!(*fields)
+        formatted_fields = ActiveHouse::PreparedStatement.format_fields(model_class, fields)
+        values[:array_join] = (values[:array_join] + formatted_fields).uniq
+        self
+      end
+
+      def array_join(*fields)
+        dup.array_join!(*fields)
+      end
+
+      def left_array_join!(*fields)
+        formatted_fields = ActiveHouse::PreparedStatement.format_fields(model_class, fields)
+        values[:left_array_join] = (values[:left_array_join] + formatted_fields).uniq
+        self
+      end
+
+      def left_array_join(*fields)
+        dup.left_array_join!(*fields)
+      end
+    end
+  end
+end