click_house-client 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19bdf144d98f858d7e130442d8c16f4e33f5d65b07aba29dd4ae00f3adc91274
-  data.tar.gz: 6bde1d020f70b3ce69a824b37dbd839bb3edf813863c12077e83c770c16efe1e
+  metadata.gz: 55b79507a43d0c64c35ed2a024c4314e6d8d1f4daf227aee3db84947d34e2a2a
+  data.tar.gz: 6673504ba4ffe2b790064529600e3e66e5e7c4d687cc82f15fb9237cd5661c94
 SHA512:
-  metadata.gz: c4abe5f4d0ae9a7859ee7bfc040ac536cb5ce9c29ce2fb4255a4075b51067e938a265f18224a4245dae52fa31b292341bce8086cf6f577d814ce097328379af9
-  data.tar.gz: 76246c442edb0a3eed5347b9d264e7635404211b5568705caad903edc9549f19cc96a94e38839e9f1486aac431fa628ecf6dd3331b7f514e7707a6c9443a8262
+  metadata.gz: 41b0de769672003cd9ab1e8d755419191ba53f47786f555f12c018c8a41cc101f0196f48ea7f2f7ad1f0f0390eb1be04e14bb7d0c0f5d351b8b712b1b7dcfae3
+  data.tar.gz: 3cd5e7948eb80aedf7f75b4470d067b4ef7e1a70b987b349786700d5aa07b981439d8baa75fc399def7a4f2ed80e8ba47f0c8779cf12fc06771626e2f0ebc605

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house-client (0.4.1)
+    click_house-client (0.5.1)
       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.1)
   concurrent-ruby (1.3.5) sha256=813b3e37aca6df2a21a3b9f1d497f8cbab24a2b94cab325bffe65ee0f6cbebc6
   connection_pool (2.5.3) sha256=cfd74a82b9b094d1ce30c4f1a346da23ee19dc8a062a16a85f58eab1ced4305b
   diff-lcs (1.5.0) sha256=49b934001c8c6aedb37ba19daec5c634da27b318a7a3c654ae979d6ba1929b67

data/README.md

@@ -22,10 +22,13 @@ ClickHouse::Client.configure do |config|
 
   # Use any HTTP client to build the POST request, here we use Net::HTTP
   config.http_post_proc = ->(url, headers, body) do
-    # Query placeholders go to the URI
-    params = URI.encode_www_form(body.except("query"))
+    uri = URI.parse(url)
+
+    unless body.is_a?(IO)
+      # Append placeholders to URI's query
+      uri.query = [uri.query, URI.encode_www_form(body.except("query"))].compact.join('&')
+    end
 
-    uri = URI.parse("#{url}&#{params}")
     request = Net::HTTP::Post.new(uri)
 
     headers.each do |header, value|
@@ -33,9 +36,14 @@ ClickHouse::Client.configure do |config|
     end
 
     request['Content-type'] = 'application/x-www-form-urlencoded'
-    request.body = body["query"]
 
-    response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+    if body.is_a?(IO)
+      request.body_stream = body
+    else
+      request.body = body['query']
+    end
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
       http.request(request)
     end
 

data/lib/click_house/client/formatter.rb

@@ -6,6 +6,9 @@ module ClickHouse
       DEFAULT = ->(value) { value }
 
       BASIC_TYPE_CASTERS = {
+        'Int32' => ->(value) { Integer(value) },
+        'UInt32' => ->(value) { Integer(value) },
+        'Int64' => ->(value) { Integer(value) },
         'UInt64' => ->(value) { Integer(value) },
         "DateTime64(6, 'UTC')" => ->(value) { ActiveSupport::TimeZone['UTC'].parse(value) },
         "IntervalSecond" => ->(value) { ActiveSupport::Duration.build(value.to_i) },

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.1"
   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.1
 platform: ruby
 authors:
 - group::optimize
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
+date: 2025-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord