clickhouse-ruby 0.1.0 → 0.2.0

data/lib/clickhouse_ruby/active_record/arel_visitor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'arel/visitors/to_sql'
+require "arel/visitors/to_sql"
 
 module ClickhouseRuby
   module ActiveRecord
@@ -42,18 +42,18 @@ module ClickhouseRuby
         table = o.relation
 
         # Build ClickHouse DELETE syntax
-        collector << 'ALTER TABLE '
+        collector << "ALTER TABLE "
         collector = visit(table, collector)
-        collector << ' DELETE'
+        collector << " DELETE"
 
         # Add WHERE clause (required for ClickHouse DELETE)
         if o.wheres.any?
-          collector << ' WHERE '
-          collector = inject_join(o.wheres, collector, ' AND ')
+          collector << " WHERE "
+          collector = inject_join(o.wheres, collector, " AND ")
         else
           # ClickHouse requires WHERE clause for DELETE
           # Use 1=1 to delete all rows
-          collector << ' WHERE 1=1'
+          collector << " WHERE 1=1"
         end
 
         collector
@@ -70,22 +70,79 @@ module ClickhouseRuby
         table = o.relation
 
         # Build ClickHouse UPDATE syntax
-        collector << 'ALTER TABLE '
+        collector << "ALTER TABLE "
         collector = visit(table, collector)
-        collector << ' UPDATE '
+        collector << " UPDATE "
 
         # Add SET assignments
-        unless o.values.empty?
-          collector = inject_join(o.values, collector, ', ')
-        end
+        collector = inject_join(o.values, collector, ", ") unless o.values.empty?
 
         # Add WHERE clause (required for ClickHouse UPDATE)
         if o.wheres.any?
-          collector << ' WHERE '
-          collector = inject_join(o.wheres, collector, ' AND ')
+          collector << " WHERE "
+          collector = inject_join(o.wheres, collector, " AND ")
         else
           # ClickHouse requires WHERE clause for UPDATE
-          collector << ' WHERE 1=1'
+          collector << " WHERE 1=1"
+        end
+
+        collector
+      end
+
+      # Visit a SELECT statement
+      # Ensures proper ordering of ClickHouse-specific clauses
+      #
+      # Clause ordering for ClickHouse:
+      # SELECT ... FROM table [FINAL] [SAMPLE n] [PREWHERE ...] [WHERE ...] [GROUP BY ...] [ORDER BY ...] [LIMIT n]
+      #
+      # @param o [Arel::Nodes::SelectStatement] the select node
+      # @param collector [Arel::Collectors::SQLString] SQL collector
+      # @return [Arel::Collectors::SQLString] the collector with SQL
+      def visit_Arel_Nodes_SelectStatement(o, collector)
+        collector = visit_Arel_Nodes_SelectCore(o.cores[0], collector)
+
+        # FROM clause
+        collector = visit(o.cores[0].source, collector) if o.cores[0].source
+
+        # Get ClickHouse-specific state from the Arel node (set by RelationExtensions#build_arel)
+        use_final = o.instance_variable_get(:@clickhouse_final)
+        sample_value = o.instance_variable_get(:@clickhouse_sample_value)
+        sample_offset = o.instance_variable_get(:@clickhouse_sample_offset)
+        prewhere_values = o.instance_variable_get(:@clickhouse_prewhere_values)
+        query_settings = o.instance_variable_get(:@clickhouse_query_settings)
+
+        # FINAL clause (if set)
+        collector << " FINAL" if use_final
+
+        # SAMPLE clause (if set)
+        if sample_value
+          collector << " SAMPLE "
+          collector << format_sample_value(sample_value)
+          if sample_offset
+            collector << " OFFSET "
+            collector << sample_offset.to_s
+          end
+        end
+
+        # PREWHERE clause (if set)
+        if prewhere_values&.any?
+          collector << " PREWHERE "
+          collector = visit_prewhere_conditions(prewhere_values, collector)
+        end
+
+        # WHERE clause
+        if o.cores[0].wheres.any?
+          collector << " WHERE "
+          collector = inject_join(o.cores[0].wheres, collector, " AND ")
+        end
+
+        # GROUP BY, HAVING, ORDER BY, LIMIT, OFFSET
+        collector = visit_orders_and_limits(o, collector)
+
+        # SETTINGS clause (at the very end)
+        if query_settings&.any?
+          collector << " "
+          collector << build_settings_clause(query_settings)
         end
 
         collector
@@ -98,7 +155,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Limit(o, collector)
-        collector << 'LIMIT '
+        collector << "LIMIT "
         visit(o.expr, collector)
       end
 
@@ -109,7 +166,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Offset(o, collector)
-        collector << 'OFFSET '
+        collector << "OFFSET "
         visit(o.expr, collector)
       end
 
@@ -119,10 +176,6 @@ module ClickhouseRuby
       # @param o [Arel::Nodes::SelectStatement] the select node
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
-      def visit_Arel_Nodes_SelectStatement(o, collector)
-        # Use default behavior but ensure ClickHouse compatibility
-        super
-      end
 
       # Visit a table alias
       # ClickHouse uses AS keyword for table aliases
@@ -132,7 +185,7 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_TableAlias(o, collector)
         collector = visit(o.relation, collector)
-        collector << ' AS '
+        collector << " AS "
         collector << quote_table_name(o.name)
       end
 
@@ -157,8 +210,8 @@ module ClickhouseRuby
       # @param o [Arel::Nodes::True] the true node
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
-      def visit_Arel_Nodes_True(o, collector)
-        collector << '1'
+      def visit_Arel_Nodes_True(_o, collector)
+        collector << "1"
       end
 
       # Visit a False node
@@ -166,8 +219,8 @@ module ClickhouseRuby
       # @param o [Arel::Nodes::False] the false node
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
-      def visit_Arel_Nodes_False(o, collector)
-        collector << '0'
+      def visit_Arel_Nodes_False(_o, collector)
+        collector << "0"
       end
 
       # Visit a CASE statement
@@ -176,25 +229,25 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Case(o, collector)
-        collector << 'CASE '
+        collector << "CASE "
 
         if o.case
           visit(o.case, collector)
-          collector << ' '
+          collector << " "
         end
 
         o.conditions.each do |condition|
           visit(condition, collector)
-          collector << ' '
+          collector << " "
         end
 
         if o.default
-          collector << 'ELSE '
+          collector << "ELSE "
           visit(o.default, collector)
-          collector << ' '
+          collector << " "
         end
 
-        collector << 'END'
+        collector << "END"
       end
 
       # Handle INSERT statements
@@ -204,23 +257,23 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_InsertStatement(o, collector)
-        collector << 'INSERT INTO '
+        collector << "INSERT INTO "
         collector = visit(o.relation, collector)
 
         if o.columns.any?
-          collector << ' ('
+          collector << " ("
           o.columns.each_with_index do |column, i|
-            collector << ', ' if i > 0
+            collector << ", " if i.positive?
             collector << quote_column_name(column.name)
           end
-          collector << ')'
+          collector << ")"
         end
 
         if o.values
-          collector << ' VALUES '
+          collector << " VALUES "
           collector = visit(o.values, collector)
         elsif o.select
-          collector << ' '
+          collector << " "
           collector = visit(o.select, collector)
         end
 
@@ -233,19 +286,19 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Values(o, collector)
-        collector << '('
+        collector << "("
         o.expressions.each_with_index do |expr, i|
-          collector << ', ' if i > 0
+          collector << ", " if i.positive?
           case expr
           when Arel::Nodes::SqlLiteral
             collector << expr.to_s
           when nil
-            collector << 'NULL'
+            collector << "NULL"
           else
             collector = visit(expr, collector)
           end
         end
-        collector << ')'
+        collector << ")"
       end
 
       # Handle multiple VALUES rows for bulk insert
@@ -255,20 +308,20 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_ValuesList(o, collector)
         o.rows.each_with_index do |row, i|
-          collector << ', ' if i > 0
-          collector << '('
+          collector << ", " if i.positive?
+          collector << "("
           row.each_with_index do |value, j|
-            collector << ', ' if j > 0
+            collector << ", " if j.positive?
             case value
             when Arel::Nodes::SqlLiteral
               collector << value.to_s
             when nil
-              collector << 'NULL'
+              collector << "NULL"
             else
               collector = visit(value, collector)
             end
           end
-          collector << ')'
+          collector << ")"
         end
         collector
       end
@@ -280,19 +333,17 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Assignment(o, collector)
         case o.left
-        when Arel::Nodes::UnqualifiedColumn
-          collector << quote_column_name(o.left.name)
-        when Arel::Attributes::Attribute
+        when Arel::Nodes::UnqualifiedColumn, Arel::Attributes::Attribute
           collector << quote_column_name(o.left.name)
         else
           collector = visit(o.left, collector)
         end
 
-        collector << ' = '
+        collector << " = "
 
         case o.right
         when nil
-          collector << 'NULL'
+          collector << "NULL"
         else
           collector = visit(o.right, collector)
         end
@@ -307,21 +358,19 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_NamedFunction(o, collector)
         collector << o.name
-        collector << '('
+        collector << "("
 
-        if o.distinct
-          collector << 'DISTINCT '
-        end
+        collector << "DISTINCT " if o.distinct
 
         o.expressions.each_with_index do |expr, i|
-          collector << ', ' if i > 0
+          collector << ", " if i.positive?
           collector = visit(expr, collector)
         end
 
-        collector << ')'
+        collector << ")"
 
         if o.alias
-          collector << ' AS '
+          collector << " AS "
           collector << quote_column_name(o.alias)
         end
 
@@ -333,8 +382,8 @@ module ClickhouseRuby
       # @param o [Arel::Nodes::Distinct] the distinct node
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
-      def visit_Arel_Nodes_Distinct(o, collector)
-        collector << 'DISTINCT'
+      def visit_Arel_Nodes_Distinct(_o, collector)
+        collector << "DISTINCT"
       end
 
       # Handle GROUP BY
@@ -352,7 +401,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Having(o, collector)
-        collector << 'HAVING '
+        collector << "HAVING "
         visit(o.expr, collector)
       end
 
@@ -363,7 +412,7 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Ascending(o, collector)
         collector = visit(o.expr, collector)
-        collector << ' ASC'
+        collector << " ASC"
       end
 
       # Handle descending order
@@ -373,7 +422,7 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Descending(o, collector)
         collector = visit(o.expr, collector)
-        collector << ' DESC'
+        collector << " DESC"
       end
 
       # Handle NULLS FIRST
@@ -383,7 +432,7 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_NullsFirst(o, collector)
         collector = visit(o.expr, collector)
-        collector << ' NULLS FIRST'
+        collector << " NULLS FIRST"
       end
 
       # Handle NULLS LAST
@@ -393,7 +442,7 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_NullsLast(o, collector)
         collector = visit(o.expr, collector)
-        collector << ' NULLS LAST'
+        collector << " NULLS LAST"
       end
 
       # Handle COUNT function
@@ -402,7 +451,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Count(o, collector)
-        aggregate('count', o, collector)
+        aggregate("count", o, collector)
       end
 
       # Handle SUM function
@@ -411,7 +460,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Sum(o, collector)
-        aggregate('sum', o, collector)
+        aggregate("sum", o, collector)
       end
 
       # Handle AVG function
@@ -420,7 +469,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Avg(o, collector)
-        aggregate('avg', o, collector)
+        aggregate("avg", o, collector)
       end
 
       # Handle MIN function
@@ -429,7 +478,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Min(o, collector)
-        aggregate('min', o, collector)
+        aggregate("min", o, collector)
       end
 
       # Handle MAX function
@@ -438,7 +487,7 @@ module ClickhouseRuby
       # @param collector [Arel::Collectors::SQLString] SQL collector
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def visit_Arel_Nodes_Max(o, collector)
-        aggregate('max', o, collector)
+        aggregate("max", o, collector)
       end
 
       # Helper to generate aggregate functions
@@ -449,20 +498,100 @@ module ClickhouseRuby
       # @return [Arel::Collectors::SQLString] the collector with SQL
       def aggregate(name, o, collector)
         collector << "#{name}("
-        if o.distinct
-          collector << 'DISTINCT '
-        end
+        collector << "DISTINCT " if o.distinct
         o.expressions.each_with_index do |expr, i|
-          collector << ', ' if i > 0
+          collector << ", " if i.positive?
           collector = visit(expr, collector)
         end
-        collector << ')'
+        collector << ")"
         if o.alias
-          collector << ' AS '
+          collector << " AS "
           collector << quote_column_name(o.alias)
         end
         collector
       end
+
+      # Visit PREWHERE conditions
+      #
+      # @param conditions [Array] array of prewhere condition nodes
+      # @param collector [Arel::Collectors::SQLString] SQL collector
+      # @return [Arel::Collectors::SQLString] the collector with SQL
+      def visit_prewhere_conditions(conditions, collector)
+        conditions.each_with_index do |condition, i|
+          collector << " AND " if i.positive?
+          collector = visit(condition, collector)
+        end
+        collector
+      end
+
+      # Build SETTINGS clause for SQL generation
+      #
+      # @param settings [Hash] the settings hash
+      # @return [String] the SETTINGS clause
+      def build_settings_clause(settings)
+        pairs = settings.map do |key, value|
+          formatted = case value
+                      when String then "'#{value}'"
+                      when true then "1"
+                      when false then "0"
+                      else value.to_s
+                      end
+          "#{key} = #{formatted}"
+        end
+
+        "SETTINGS #{pairs.join(", ")}"
+      end
+
+      # Visit orders and limits
+      #
+      # @param o [Arel::Nodes::SelectStatement] the select node
+      # @param collector [Arel::Collectors::SQLString] SQL collector
+      # @return [Arel::Collectors::SQLString] the collector with SQL
+      def visit_orders_and_limits(o, collector)
+        # GROUP BY
+        if o.cores[0].groups.any?
+          collector << " GROUP BY "
+          collector = inject_join(o.cores[0].groups, collector, ", ")
+        end
+
+        # HAVING
+        if o.cores[0].havings.any?
+          collector << " HAVING "
+          collector = inject_join(o.cores[0].havings, collector, " AND ")
+        end
+
+        # ORDER BY
+        if o.orders.any?
+          collector << " ORDER BY "
+          collector = inject_join(o.orders, collector, ", ")
+        end
+
+        # LIMIT
+        if o.limit
+          collector << " "
+          collector = visit(o.limit, collector)
+        end
+
+        # OFFSET
+        if o.offset
+          collector << " "
+          collector = visit(o.offset, collector)
+        end
+
+        collector
+      end
+
+      # Format a sample value for SQL generation
+      #
+      # Handles differentiation between Integer (absolute row count) and Float (fractional).
+      # Ruby's to_s preserves the distinction: Integer 1 becomes "1", Float 1.0 becomes "1.0"
+      # This matters because SAMPLE 1 means "at least 1 row" while SAMPLE 1.0 means "100% of data".
+      #
+      # @param value [Float, Integer] the sample value
+      # @return [String] the formatted sample value
+      def format_sample_value(value)
+        value.to_s
+      end
     end
   end
 end