click_house-client 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 321e868b4cca95b643f90153b5ae1912f1960b13f5dafda79aea4056e130edc8
-  data.tar.gz: c89e9e47c42a8550d6a7e899a7c30a6807ca7c8119f66cbb573a9cfc082ab175
+  metadata.gz: 45b65dc2ae8ced88a1129e3fb7e78e3d314bbc5eb41402e430932d7e4c169e98
+  data.tar.gz: 9f25ca4f27d5c0b500339bc682d6de3b5b0ffd97b5484b14707949906064b891
 SHA512:
-  metadata.gz: 54aecdd0475745b881b40074122a06cee33f4d6d7dcb2c38c2622dfc484ffaa364bc57260ce8858277d524c62b62ce83dd3ea19711ff1f94c5df5852ef57b1c0
-  data.tar.gz: 3416500a2e4b09074e421c99f363323d79af92fbc6a14e015f52c5ae0eb5a4dd86142bc3a913eef3879a5f12255f9e0435a556b3f5a9375bf6b2b1eca9a8d392
+  metadata.gz: a50a5010fb3900ec46fc9c84fe4bbe6f3647beee599fd40940ddfa89f7ae6ba6a0eb569021b9f34a0e9f72237277b75b34a4820523fa2413a95b696d16c9a2c5
+  data.tar.gz: 998b97239232786839a7568a8a06aa69090127ae1ba68be5cb30bfb57ad26c599aedfda37a4603b0cdf3464a7dd9209f88793688ed5af81dcd0f4315646ed97c

data/Gemfile.lock

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

@@ -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/version.rb

@@ -2,6 +2,6 @@
 
 module ClickHouse
   module Client
-    VERSION = "0.7.1"
+    VERSION = "0.8.0"
   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.0
 platform: ruby
 authors:
 - group::optimize
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-22 00:00:00.000000000 Z
+date: 2025-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord