click_house-client 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19bdf144d98f858d7e130442d8c16f4e33f5d65b07aba29dd4ae00f3adc91274
-  data.tar.gz: 6bde1d020f70b3ce69a824b37dbd839bb3edf813863c12077e83c770c16efe1e
+  metadata.gz: 4fb73c384094387fbb53365e18a5378aca87148e07e501b25e03f9371cead01e
+  data.tar.gz: f5a179a229a5c9fe115ce03d84d22d14b01c56dfa99694cea5f75d9f9c034f37
 SHA512:
-  metadata.gz: c4abe5f4d0ae9a7859ee7bfc040ac536cb5ce9c29ce2fb4255a4075b51067e938a265f18224a4245dae52fa31b292341bce8086cf6f577d814ce097328379af9
-  data.tar.gz: 76246c442edb0a3eed5347b9d264e7635404211b5568705caad903edc9549f19cc96a94e38839e9f1486aac431fa628ecf6dd3331b7f514e7707a6c9443a8262
+  metadata.gz: 1b3055e3104e139834ac5e3538ac3d0e402c16b8f1456861ed0bca269c03870038c9aadc97ebb1c74e1486a273c6a44867f20a07f423075ab8e8b90f972c2acd
+  data.tar.gz: 9f1e7160de8c0d4ead180e10dfc40b36db5e155d08a1d7d2c62c6225636dc72751c7b1ee68d583ff8653409b8fdddb8e9ce0cd2ff920bd38995e5eab8408e04e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house-client (0.4.1)
+    click_house-client (0.5.0)
       activerecord (>= 7.0, < 9.0)
       activesupport (>= 7.0, < 9.0)
       addressable (~> 2.8)
@@ -136,7 +136,7 @@ CHECKSUMS
   benchmark (0.4.1) sha256=d4ef40037bba27f03b28013e219b950b82bace296549ec15a78016552f8d2cce
   bigdecimal (3.2.2) sha256=39085f76b495eb39a79ce07af716f3a6829bc35eb44f2195e2753749f2fa5adc
   byebug (12.0.0) sha256=d4a150d291cca40b66ec9ca31f754e93fed8aa266a17335f71bb0afa7fca1a1e
-  click_house-client (0.4.1)
+  click_house-client (0.5.0)
   concurrent-ruby (1.3.5) sha256=813b3e37aca6df2a21a3b9f1d497f8cbab24a2b94cab325bffe65ee0f6cbebc6
   connection_pool (2.5.3) sha256=cfd74a82b9b094d1ce30c4f1a346da23ee19dc8a062a16a85f58eab1ced4305b
   diff-lcs (1.5.0) sha256=49b934001c8c6aedb37ba19daec5c634da27b318a7a3c654ae979d6ba1929b67

data/lib/click_house/client/query_builder.rb

@@ -6,7 +6,7 @@ module ClickHouse
   module Client
     class QueryBuilder < QueryLike
       attr_reader :table
-      attr_accessor :conditions, :manager
+      attr_accessor :manager
 
       VALID_NODES = [
         Arel::Nodes::In,
@@ -27,38 +27,39 @@ module ClickHouse
       def initialize(table_name)
         @table = Arel::Table.new(table_name)
         @manager = Arel::SelectManager.new(Arel::Table.engine).from(@table).project(Arel.star)
-        @conditions = []
+      end
+
+      def initialize_copy(other)
+        super
+
+        @manager = other.manager.clone
       end
 
       # The `where` method currently only supports IN and equal to queries along
       # with above listed VALID_NODES.
       # For example, using a range (start_date..end_date) will result in incorrect SQL.
-      # If you need to query a range, use greater than and less than conditions with Arel.
+      # If you need to query a range, use greater than and less than constraints with Arel.
       #
       # Correct usage:
       #   query.where(query.table[:created_at].lteq(Date.today)).to_sql
       #   "SELECT * FROM \"table\" WHERE \"table\".\"created_at\" <= '2023-08-01'"
       #
-      # This also supports array conditions which will result in an IN query.
+      # This also supports array constraints which will result in an IN query.
       #   query.where(entity_id: [1,2,3]).to_sql
       #   "SELECT * FROM \"table\" WHERE \"table\".\"entity_id\" IN (1, 2, 3)"
       #
       # Range support and more `Arel::Nodes` could be considered for future iterations.
       # @return [ClickHouse::QueryBuilder] New instance of query builder.
-      def where(conditions)
-        validate_condition_type!(conditions)
+      def where(constraints)
+        validate_constraint_type!(constraints)
 
-        deep_clone.tap do |new_instance|
-          if conditions.is_a?(Arel::Nodes::Node)
-            new_instance.conditions << conditions
-          else
-            add_conditions_to(new_instance, conditions)
-          end
+        clone.tap do |new_instance|
+          add_constraints_to(new_instance, constraints)
         end
       end
 
       def select(*fields)
-        deep_clone.tap do |new_instance|
+        clone.tap do |new_instance|
           existing_fields = new_instance.manager.projections.filter_map do |projection|
             if projection.respond_to?(:to_s) && projection.to_s == '*'
               nil
@@ -90,7 +91,7 @@ module ClickHouse
       def order(field, direction = :asc)
         validate_order_direction!(direction)
 
-        deep_clone.tap do |new_instance|
+        clone.tap do |new_instance|
           order_node = case field
                        when Arel::Nodes::SqlLiteral, Arel::Nodes::Node, Arel::Attribute
                          field
@@ -104,7 +105,7 @@ module ClickHouse
       end
 
       def group(*columns)
-        deep_clone.tap do |new_instance|
+        clone.tap do |new_instance|
           new_instance.manager.group(*columns)
         end
       end
@@ -120,7 +121,7 @@ module ClickHouse
       end
 
       def from(subquery, alias_name)
-        deep_clone.tap do |new_instance|
+        clone.tap do |new_instance|
           if subquery.is_a?(self.class)
             new_instance.manager.from(subquery.to_arel.as(alias_name))
           else
@@ -129,9 +130,35 @@ module ClickHouse
         end
       end
 
-      def to_sql
-        apply_conditions!
+      def joins(table_name, constraint = nil)
+        clone.tap do |new_instance|
+          join_table = table_name.is_a?(Arel::Table) ? table_name : Arel::Table.new(table_name)
+
+          join_condition = case constraint
+                           when Hash
+                             # Handle hash based constraints like { table1.id: table2.ref_id } or {id: :ref_id}
+                             constraint_conditions = constraint.map do |left, right|
+                               left_field = left.is_a?(Arel::Attributes::Attribute) ? left : new_instance.table[left]
+                               right_field = right.is_a?(Arel::Attributes::Attribute) ? right : join_table[right]
+                               left_field.eq(right_field)
+                             end
+
+                             constraint_conditions.reduce(&:and)
+                           when Proc
+                             constraint.call(new_instance.table, join_table)
+                           when Arel::Nodes::Node
+                             constraint
+                           end
+
+          if join_condition
+            new_instance.manager.join(join_table).on(join_condition)
+          else
+            new_instance.manager.join(join_table)
+          end
+        end
+      end
 
+      def to_sql
         visitor = Arel::Visitors::ToSql.new(ClickHouse::Client::ArelEngine.new)
         visitor.accept(manager.ast, Arel::Collectors::SQLString.new).value
       end
@@ -141,39 +168,43 @@ module ClickHouse
       end
 
       def to_arel
-        apply_conditions!
-
         manager
       end
 
       private
 
-      def validate_condition_type!(condition)
-        return unless condition.is_a?(Arel::Nodes::Node) && VALID_NODES.exclude?(condition.class)
+      def validate_constraint_type!(constraint)
+        return unless constraint.is_a?(Arel::Nodes::Node) && VALID_NODES.exclude?(constraint.class)
 
-        raise ArgumentError, "Unsupported Arel node type for QueryBuilder: #{condition.class.name}"
+        raise ArgumentError, "Unsupported Arel node type for QueryBuilder: #{constraint.class.name}"
       end
 
-      def add_conditions_to(instance, conditions)
-        conditions.each do |key, value|
-          instance.conditions << if value.is_a?(Array)
-                                   instance.table[key].in(value)
-                                 else
-                                   instance.table[key].eq(value)
-                                 end
+      def add_constraints_to(instance, constraints)
+        if constraints.is_a?(Arel::Nodes::Node)
+          instance.manager.where(constraints)
+        else
+          constraints.each do |key, value|
+            if value.is_a?(Hash)
+              # Handle nested hash for joined tables
+              join_table = Arel::Table.new(key)
+              value.each do |nested_key, nested_value|
+                build_arel_constraint(instance, join_table, nested_key, nested_value)
+              end
+            else
+              build_arel_constraint(instance, instance.table, key, value)
+            end
+          end
         end
       end
 
-      def deep_clone
-        self.class.new(table.name).tap do |new_instance|
-          new_instance.manager = manager.clone
-          new_instance.conditions = conditions.map(&:clone)
-        end
-      end
+      def build_arel_constraint(instance, table, key, value)
+        constraint = if value.is_a?(Array)
+                       table[key].in(value)
+                     else
+                       table[key].eq(value)
+                     end
 
-      def apply_conditions!
-        manager.constraints.clear
-        conditions.each { |condition| manager.where(condition) }
+        instance.manager.where(constraint)
       end
 
       def validate_order_direction!(direction)

data/lib/click_house/client/redactor.rb

@@ -3,66 +3,71 @@
 module ClickHouse
   module Client
     module Redactor
-      # Redacts the SQL query represented by the query builder.
-      #
-      # @param query_builder [::ClickHouse::Querybuilder] The query builder object to be redacted.
-      # @return [String] The redacted SQL query as a string.
-      # @raise [ArgumentError] when the condition in the query is of an unsupported type.
-      #
-      # Example:
-      #   query_builder = ClickHouse::QueryBuilder.new('users').where(name: 'John Doe')
-      #   redacted_query = ClickHouse::Redactor.redact(query_builder)
-      #   # The redacted_query will contain the SQL query with values replaced by placeholders.
-      #   output: "SELECT * FROM \"users\" WHERE \"users\".\"name\" = $1"
-      def self.redact(query_builder, bind_manager = ClickHouse::Client::BindIndexManager.new)
-        cloned_query_builder = query_builder.clone
+      class << self
+        # Redacts the SQL query represented by the query builder.
+        #
+        # @param query_builder [::ClickHouse::Querybuilder] The query builder object to be redacted.
+        # @return [String] The redacted SQL query as a string.
+        # @raise [ArgumentError] when the condition in the query is of an unsupported type.
+        #
+        # Example:
+        #   query_builder = ClickHouse::QueryBuilder.new('users').where(name: 'John Doe')
+        #   redacted_query = ClickHouse::Redactor.redact(query_builder)
+        #   # The redacted_query will contain the SQL query with values replaced by placeholders.
+        #   output: "SELECT * FROM \"users\" WHERE \"users\".\"name\" = $1"
+        def redact(query_builder, bind_manager = ClickHouse::Client::BindIndexManager.new)
+          redacted_constraints = query_builder.manager.constraints.map do |constraint|
+            redact_constraint(constraint, bind_manager)
+          end
 
-        cloned_query_builder.conditions = cloned_query_builder.conditions.map do |condition|
-          redact_condition(condition, bind_manager)
-        end
+          cloned_query_builder = query_builder.clone
+
+          cloned_query_builder.manager.constraints.clear
+          redacted_constraints.each do |constraint|
+            cloned_query_builder.manager.where(constraint)
+          end
 
-        cloned_query_builder.manager.constraints.clear
-        cloned_query_builder.conditions.each do |condition|
-          cloned_query_builder.manager.where(condition)
+          cloned_query_builder.to_sql
         end
 
-        visitor = Arel::Visitors::ToSql.new(ClickHouse::Client::ArelEngine.new)
-        visitor.accept(cloned_query_builder.manager.ast, Arel::Collectors::SQLString.new).value
-      end
+        private
 
-      def self.redact_condition(condition, bind_manager)
-        case condition
-        when Arel::Nodes::In
-          condition.left.in(Array.new(condition.right.size) { Arel.sql(bind_manager.next_bind_str) })
-        when Arel::Nodes::Equality
-          condition.left.eq(Arel.sql(bind_manager.next_bind_str))
-        when Arel::Nodes::LessThan
-          condition.left.lt(Arel.sql(bind_manager.next_bind_str))
-        when Arel::Nodes::LessThanOrEqual
-          condition.left.lteq(Arel.sql(bind_manager.next_bind_str))
-        when Arel::Nodes::GreaterThan
-          condition.left.gt(Arel.sql(bind_manager.next_bind_str))
-        when Arel::Nodes::GreaterThanOrEqual
-          condition.left.gteq(Arel.sql(bind_manager.next_bind_str))
-        when Arel::Nodes::NamedFunction
-          redact_named_function(condition, bind_manager)
-        else
-          raise ArgumentError, "Unsupported Arel node type for Redactor: #{condition.class}"
+        def redact_constraint(constraint, bind_manager)
+          case constraint
+          when Arel::Nodes::In
+            constraint.left.in(Array.new(constraint.right.size) { Arel.sql(bind_manager.next_bind_str) })
+          when Arel::Nodes::Equality
+            constraint.left.eq(Arel.sql(bind_manager.next_bind_str))
+          when Arel::Nodes::LessThan
+            constraint.left.lt(Arel.sql(bind_manager.next_bind_str))
+          when Arel::Nodes::LessThanOrEqual
+            constraint.left.lteq(Arel.sql(bind_manager.next_bind_str))
+          when Arel::Nodes::GreaterThan
+            constraint.left.gt(Arel.sql(bind_manager.next_bind_str))
+          when Arel::Nodes::GreaterThanOrEqual
+            constraint.left.gteq(Arel.sql(bind_manager.next_bind_str))
+          when Arel::Nodes::NamedFunction
+            redact_named_function(constraint, bind_manager)
+          else
+            raise ArgumentError, "Unsupported Arel node type for Redactor: #{constraint.class}"
+          end
         end
-      end
 
-      def self.redact_named_function(condition, bind_manager)
-        redacted_condition =
-          Arel::Nodes::NamedFunction.new(condition.name, condition.expressions.dup)
+        def redact_named_function(constraint, bind_manager)
+          redacted_constraint =
+            Arel::Nodes::NamedFunction.new(constraint.name, constraint.expressions.dup)
 
-        case redacted_condition.name
-        when 'startsWith'
-          redacted_condition.expressions[1] = Arel.sql(bind_manager.next_bind_str)
-        else
-          redacted_condition.expressions = redacted_condition.expressions.map { Arel.sql(bind_manager.next_bind_str) }
-        end
+          case redacted_constraint.name
+          when 'startsWith'
+            redacted_constraint.expressions[1] = Arel.sql(bind_manager.next_bind_str)
+          else
+            redacted_constraint.expressions = redacted_constraint.expressions.map do
+              Arel.sql(bind_manager.next_bind_str)
+            end
+          end
 
-        redacted_condition
+          redacted_constraint
+        end
       end
     end
   end

data/lib/click_house/client/version.rb

@@ -2,6 +2,6 @@
 
 module ClickHouse
   module Client
-    VERSION = "0.4.1"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: click_house-client
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - group::optimize
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
+date: 2025-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord