click_house-client 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 321e868b4cca95b643f90153b5ae1912f1960b13f5dafda79aea4056e130edc8
-  data.tar.gz: c89e9e47c42a8550d6a7e899a7c30a6807ca7c8119f66cbb573a9cfc082ab175
+  metadata.gz: 8edcd5e208b1ff934725bac130c092bfd27bcfb213aff1f13024ee9eef412136
+  data.tar.gz: a2d0ce00dad6847e1bcfbae4be2a722a2e2f5fb01cb8d3e52a45227156c89dc6
 SHA512:
-  metadata.gz: 54aecdd0475745b881b40074122a06cee33f4d6d7dcb2c38c2622dfc484ffaa364bc57260ce8858277d524c62b62ce83dd3ea19711ff1f94c5df5852ef57b1c0
-  data.tar.gz: 3416500a2e4b09074e421c99f363323d79af92fbc6a14e015f52c5ae0eb5a4dd86142bc3a913eef3879a5f12255f9e0435a556b3f5a9375bf6b2b1eca9a8d392
+  metadata.gz: 158006bf24437df41df318858b09dedff7a4d3cf4be7d855c8427aa803bb0e660282debeadaa5dca2b80279d6625864166d775fcc5cb5c5c089c3751b908a282
+  data.tar.gz: f18f54a08a89ad7df547d36c572c106940849e7f360878a82a259faeb6e8cd59e5b699b64ca8edc3a62b3665de08509c2ba5307ca004931c1e973328b028b9d8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    click_house-client (0.7.1)
+    click_house-client (0.8.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.7.1)
+  click_house-client (0.8.1)
   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

@@ -23,7 +23,10 @@ module ClickHouse
         Arel::Nodes::Or,
         Arel::Nodes::Grouping,
         Arel::Nodes::Matches,
-        Arel::Nodes::DoesNotMatch
+        Arel::Nodes::DoesNotMatch,
+        Arel::Nodes::Division,
+        Arel::Nodes::Multiplication,
+        Arel::Nodes::As
       ].freeze
 
       def initialize(table_name)
@@ -178,6 +181,134 @@ module ClickHouse
         end
       end
 
+      # Aggregation helper methods
+
+      # Creates an AVG aggregate function node
+      # @param column [Symbol, String, Arel::Expressions] The column to average
+      # @return [Arel::Nodes::NamedFunction] The AVG function node
+      # @example Basic average
+      #   query.select(query.avg(:duration)).to_sql
+      #   # => "SELECT avg(`table`.`duration`) FROM `table`"
+      # @example Average with alias
+      #   query.select(query.avg(:price).as('average_price')).to_sql
+      #   # => "SELECT avg(`table`.`price`) AS average_price FROM `table`"
+      def avg(column)
+        column_node = normalize_operand(column)
+        Arel::Nodes::NamedFunction.new('avg', [column_node])
+      end
+
+      # Creates a quantile aggregate function node
+      # @param level [Float] The quantile level (e.g., 0.5 for median)
+      # @param column [Symbol, String, Arel::Expressions] The column to calculate quantile for
+      # @return [Arel::Nodes::NamedFunction] The quantile function node
+      # @example Calculate median (50th percentile)
+      #   query.select(query.quantile(0.5, :response_time)).to_sql
+      #   # => "SELECT quantile(0.5)(`table`.`response_time`) FROM `table`"
+      # @example Calculate 95th percentile with alias
+      #   query.select(query.quantile(0.95, :latency).as('p95')).to_sql
+      #   # => "SELECT quantile(0.95)(`table`.`latency`) AS p95 FROM `table`"
+      def quantile(level, column)
+        column_node = normalize_operand(column)
+        Arel::Nodes::NamedFunction.new("quantile(#{level})", [column_node])
+      end
+
+      # Creates a COUNT aggregate function node
+      # @param column [Symbol, String, Arel::Expressions, nil] The column to count, or nil for COUNT(*)
+      # @return [Arel::Nodes::NamedFunction] The COUNT function node
+      # @example Count all rows
+      #   query.select(query.count).to_sql
+      #   # => "SELECT count() FROM `table`"
+      # @example Count specific column
+      #   query.select(query.count(:id)).to_sql
+      #   # => "SELECT count(`table`.`id`) FROM `table`"
+      def count(column = nil)
+        if column.nil?
+          Arel::Nodes::NamedFunction.new('count', [])
+        else
+          column_node = normalize_operand(column)
+          Arel::Nodes::NamedFunction.new('count', [column_node])
+        end
+      end
+
+      # Creates a countIf aggregate function node
+      # @param condition [Arel::Nodes::Node] The condition to count
+      # @return [Arel::Nodes::NamedFunction] The countIf function node
+      # @raise [ArgumentError] if condition is not an Arel node
+      # @example Count rows matching a condition
+      #   query.select(query.count_if(query.table[:status].eq('active'))).to_sql
+      #   # => "SELECT countIf(`table`.`status` = 'active') FROM `table`"
+      def count_if(condition)
+        raise ArgumentError, "countIf requires an Arel node as condition" unless condition.is_a?(Arel::Nodes::Node)
+
+        Arel::Nodes::NamedFunction.new('countIf', [condition])
+      end
+
+      # Creates a division node with grouping
+      # @param left [Arel::Expressions, Symbol, String, Numeric] The dividend
+      # @param right [Arel::Expressions, Symbol, String, Numeric] The divisor
+      # @return [Arel::Nodes::Grouping] The grouped division node for proper precedence
+      # @example Simple division
+      #   query.select(query.division(:completed, :total)).to_sql
+      #   # => "SELECT (`table`.`completed` / `table`.`total`) FROM `table`"
+      # @example Calculate percentage
+      #   rate = query.division(:success_count, :total_count)
+      #   query.select(query.multiply(rate, 100).as('success_rate')).to_sql
+      #   # => "SELECT ((`table`.`success_count` / `table`.`total_count`) * 100) AS success_rate FROM `table`"
+      def division(left, right)
+        left_node = normalize_operand(left)
+        right_node = normalize_operand(right)
+
+        Arel::Nodes::Grouping.new(Arel::Nodes::Division.new(left_node, right_node))
+      end
+
+      # Creates a multiplication node with grouping
+      # @param left [Arel::Expressions, Symbol, String, Numeric] The left operand
+      # @param right [Arel::Expressions, Symbol, String, Numeric] The right operand
+      # @return [Arel::Nodes::Grouping] The grouped multiplication node for proper precedence
+      # @example Multiply columns
+      #   query.select(query.multiply(:quantity, :unit_price)).to_sql
+      #   # => "SELECT (`table`.`quantity` * `table`.`unit_price`) FROM `table`"
+      # @example Convert to percentage
+      #   query.select(query.multiply(:rate, 100).as('percentage')).to_sql
+      #   # => "SELECT (`table`.`rate` * 100) AS percentage FROM `table`"
+      def multiply(left, right)
+        left_node = normalize_operand(left)
+        right_node = normalize_operand(right)
+
+        Arel::Nodes::Grouping.new(Arel::Nodes::Multiplication.new(left_node, right_node))
+      end
+
+      # Creates an equality node
+      # @param left [Arel::Expressions, Symbol, String] The left side of the comparison
+      # @param right [Arel::Expressions, Symbol, String, Numeric, Boolean] The right side of the comparison
+      # @return [Arel::Nodes::Equality] The equality node
+      # @example Use in WHERE clause
+      #   query.where(query.equality(:status, 'active')).to_sql
+      #   # => "SELECT * FROM `table` WHERE `table`.`status` = 'active'"
+      # @example Use with countIf
+      #   query.select(query.count_if(query.equality(:type, 'premium'))).to_sql
+      #   # => "SELECT countIf(`table`.`type` = 'premium') FROM `table`"
+      def equality(left, right)
+        left_node = normalize_operand(left)
+        right_node = normalize_operand(right)
+        Arel::Nodes::Equality.new(left_node, right_node)
+      end
+
+      # Creates an alias for a node
+      # @param node [Arel::Nodes::Node] The node to alias
+      # @param alias_name [String, Symbol] The alias name
+      # @return [Arel::Nodes::As] The aliased node
+      # @raise [ArgumentError] if node is not an Arel Expression
+      # @example Alias an aggregate function
+      #   avg_node = query.avg(:price)
+      #   query.select(query.as(avg_node, 'average_price')).to_sql
+      #   # => "SELECT avg(`table`.`price`) AS average_price FROM `table`"
+      def as(node, alias_name)
+        raise ArgumentError, "as requires an Arel node" unless node.is_a?(Arel::Expressions)
+
+        node.as(alias_name.to_s)
+      end
+
       def to_sql
         visitor = ClickHouse::Client::ArelVisitor.new(ClickHouse::Client::ArelEngine.new)
         visitor.accept(manager.ast, Arel::Collectors::SQLString.new).value
@@ -193,6 +324,17 @@ module ClickHouse
 
       private
 
+      def normalize_operand(operand)
+        case operand
+        when Arel::Expressions
+          operand
+        when Symbol, String
+          table[operand.to_s]
+        else
+          Arel::Nodes.build_quoted(operand)
+        end
+      end
+
       def validate_constraint_type!(constraint)
         return unless constraint.is_a?(Arel::Nodes::Node) && VALID_NODES.exclude?(constraint.class)
 

data/lib/click_house/client/redactor.rb

@@ -35,7 +35,11 @@ module ClickHouse
         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) })
+            if constraint.right.is_a? Arel::Nodes::SelectStatement
+              constraint.left.in(redact_select_statement(constraint.right, bind_manager))
+            else
+              constraint.left.in(Array.new(constraint.right.size) { Arel.sql(bind_manager.next_bind_str) })
+            end
           when Arel::Nodes::Equality
             constraint.left.eq(Arel.sql(bind_manager.next_bind_str))
           when Arel::Nodes::LessThan
@@ -68,6 +72,19 @@ module ClickHouse
 
           redacted_constraint
         end
+
+        def redact_select_statement(select_statement, bind_manager)
+          cloned_statement = select_statement.clone
+          cloned_statement.cores.map! do |select_core|
+            select_core.wheres = select_core.wheres.map do |where|
+              redact_constraint(where, bind_manager)
+            end
+
+            select_core
+          end
+
+          cloned_statement
+        end
       end
     end
   end

data/lib/click_house/client/version.rb

@@ -2,6 +2,6 @@
 
 module ClickHouse
   module Client
-    VERSION = "0.7.1"
+    VERSION = "0.8.1"
   end
 end

metadata

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