Remove unused methods

Author: zetter

lib/aggregate_evaluator.rb

@@ -71,15 +71,6 @@ def validate_aggregate_types(expression, row_data = {})
     end
   end
 
-  def get_aggregate_type(expression, row_data = {})
-    case expression[:type]
-    when :aggregate_function
-      get_aggregate_function_type(expression, row_data)
-    else
-      @evaluator.get_expression_type(expression, row_data)
-    end
-  end
-  
   private
 
   def evaluate_expression_with_aggregates(expression, group_rows)

lib/aggregate_function_registry.rb

@@ -9,13 +9,6 @@ def initialize(name:, requires_argument:, argument_type: nil, return_type:, defa
       @return_type = return_type
       @default_value = default_value
     end
-    
-    def validate_argument(arg_type)
-      return true unless @requires_argument
-      return true if @argument_type.nil?
-      
-      arg_type == @argument_type
-    end
   end
 
   def self.instance
@@ -39,28 +32,6 @@ def exists?(name)
     @functions.key?(name)
   end
 
-  def validate_function(name, arg_type = nil)
-    function = get(name)
-    return false unless function
-    
-    function.validate_argument(arg_type)
-  end
-  
-  def get_return_type(name)
-    function = get(name)
-    function&.return_type
-  end
-  
-  def get_default_value(name)
-    function = get(name)
-    function&.default_value
-  end
-  
-  def requires_argument?(name)
-    function = get(name)
-    function&.requires_argument
-  end
-  
   private
 
   def register_default_functions

lib/expression_visitor.rb

@@ -105,197 +105,4 @@ def visit_column(expr)
   def visit_qualified_column(expr)
     @columns << expr
   end
-end
-
-class ExpressionValidatorVisitor < ExpressionVisitor
-  def initialize(table_context, evaluator)
-    @table_context = table_context
-    @evaluator = evaluator
-    @errors = []
-  end
-  
-  def errors
-    @errors
-  end
-  
-  def valid?
-    @errors.empty?
-  end
-  
-  protected
-  
-  def visit_column(expr)
-    column_name = expr[:name]
-    found = false
-    count = 0
-    
-    table_context_hash = @table_context.is_a?(Hash) ? @table_context : @table_context.to_hash
-    
-    table_context_hash[:aliases].each do |alias_name, table_name|
-      table_info = table_context_hash[:tables][table_name]
-      if table_info[:columns].any? { |col| col[:name] == column_name }
-        found = true
-        count += 1
-      end
-    end
-    
-    unless found
-      @errors << "Unknown column: #{column_name}"
-    end
-    
-    if count > 1
-      @errors << "Ambiguous column: #{column_name}"
-    end
-  end
-  
-  def visit_qualified_column(expr)
-    table_ref = expr[:table]
-    column_name = expr[:column]
-    
-    table_context_hash = @table_context.is_a?(Hash) ? @table_context : @table_context.to_hash
-    
-    actual_table = table_context_hash[:aliases][table_ref]
-    unless actual_table
-      @errors << "Unknown table: #{table_ref}"
-      return
-    end
-    
-    table_info = table_context_hash[:tables][actual_table]
-    unless table_info[:columns].any? { |col| col[:name] == column_name }
-      @errors << "Unknown column: #{table_ref}.#{column_name}"
-    end
-  end
-  
-  def visit_binary_op(expr)
-    super
-    
-    # Type validation for comparison operators
-    if expr[:operator] == :equal || expr[:operator] == :not_equal
-      left_type = get_expression_type(expr[:left])
-      right_type = get_expression_type(expr[:right])
-      
-      if (left_type == :integer && right_type == :boolean) ||
-         (left_type == :boolean && right_type == :integer)
-        @errors << "Type mismatch in comparison"
-      end
-    end
-  end
-  
-  private
-  
-  def get_expression_type(expr)
-    # Simplified type inference
-    case expr[:type]
-    when :literal
-      if expr[:value].nil?
-        nil
-      elsif expr[:value] == true || expr[:value] == false
-        :boolean
-      else
-        :integer
-      end
-    when :column, :qualified_column
-      # Would need to look up column type in table context
-      :unknown
-    when :binary_op
-      case expr[:operator]
-      when :plus, :minus, :star, :slash
-        :integer
-      when :lt, :gt, :lte, :gte, :equal, :not_equal, :and, :or
-        :boolean
-      end
-    else
-      :unknown
-    end
-  end
-end
-
-class ExpressionTransformVisitor < ExpressionVisitor
-  def visit(expression)
-    return nil unless expression
-    
-    case expression[:type]
-    when :literal
-      transform_literal(expression)
-    when :column
-      transform_column(expression)
-    when :qualified_column
-      transform_qualified_column(expression)
-    when :binary_op
-      transform_binary_op(expression)
-    when :unary_op
-      transform_unary_op(expression)
-    when :function
-      transform_function(expression)
-    when :aggregate_function
-      transform_aggregate_function(expression)
-    when :is_null
-      transform_is_null(expression)
-    when :is_not_null
-      transform_is_not_null(expression)
-    else
-      expression
-    end
-  end
-  
-  protected
-  
-  def transform_literal(expr)
-    expr
-  end
-  
-  def transform_column(expr)
-    expr
-  end
-  
-  def transform_qualified_column(expr)
-    expr
-  end
-  
-  def transform_binary_op(expr)
-    {
-      type: :binary_op,
-      operator: expr[:operator],
-      left: visit(expr[:left]),
-      right: visit(expr[:right])
-    }
-  end
-  
-  def transform_unary_op(expr)
-    {
-      type: :unary_op,
-      operator: expr[:operator],
-      operand: visit(expr[:operand])
-    }
-  end
-  
-  def transform_function(expr)
-    {
-      type: :function,
-      name: expr[:name],
-      args: expr[:args]&.map { |arg| visit(arg) }
-    }
-  end
-  
-  def transform_aggregate_function(expr)
-    {
-      type: :aggregate_function,
-      name: expr[:name],
-      args: expr[:args]&.map { |arg| visit(arg) }
-    }
-  end
-  
-  def transform_is_null(expr)
-    {
-      type: :is_null,
-      operand: visit(expr[:operand])
-    }
-  end
-  
-  def transform_is_not_null(expr)
-    {
-      type: :is_not_null,
-      operand: visit(expr[:operand])
-    }
-  end
 end

lib/query_planner.rb

@@ -4,46 +4,6 @@ def initialize(validator, evaluator)
     @evaluator = evaluator
   end
 
-  def validate_query(parsed_sql, table_info, alias_mapping)
-    table_name = parsed_sql[:table_name]
-    expressions = parsed_sql[:expressions]
-    where_clause = parsed_sql[:where]
-    order_by = parsed_sql[:order_by]
-    limit = parsed_sql[:limit]
-    offset = parsed_sql[:offset]
-    
-    # Create a dummy row with appropriate types for validation
-    dummy_row_data = create_dummy_row_data(table_info[:columns])
-    
-    # Validate SELECT expressions
-    @validator.validate_select_expressions(expressions, dummy_row_data, table_name)
-    
-    # Validate WHERE clause if present
-    if where_clause
-      @validator.validate_qualified_columns(where_clause, table_name)
-      return false unless @validator.validate_where_clause(where_clause, dummy_row_data)
-    end
-    
-    # Validate ORDER BY if present
-    if order_by
-      unless validate_order_by(order_by, alias_mapping, table_name, dummy_row_data)
-        return false
-      end
-    end
-    
-    # Validate LIMIT if present
-    if limit
-      return false unless @validator.validate_limit_offset_expression(limit)
-    end
-    
-    # Validate OFFSET if present
-    if offset
-      return false unless @validator.validate_limit_offset_expression(offset)
-    end
-    
-    true
-  end
-  
   def build_alias_mapping(expressions)
     mapping = {}
     expressions.each do |expr_info|
@@ -67,38 +27,4 @@ def extract_column_names(expressions)
       end
     end
   end
-  
-  private
-  
-  def validate_order_by(order_by, alias_mapping, table_name, dummy_row_data)
-    # First check if it's a simple alias reference
-    if order_by[:expression][:type] == :column && alias_mapping[order_by[:expression][:name]]
-      # It's an alias - this is allowed for simple references
-      true
-    else
-      # For expressions containing aliases, they're not allowed
-      if @validator.contains_alias_in_expression?(order_by[:expression], alias_mapping)
-        return false
-      end
-      # Validate the ORDER BY expression normally
-      @validator.validate_qualified_columns(order_by[:expression], table_name)
-      @evaluator.validate_types(order_by[:expression], dummy_row_data)
-      true
-    end
-  end
-  
-  def create_dummy_row_data(columns)
-    dummy_row_data = {}
-    columns.each do |col|
-      case col[:type]
-      when 'BOOLEAN'
-        dummy_row_data[col[:name]] = true
-      when 'INTEGER'
-        dummy_row_data[col[:name]] = 0
-      else
-        dummy_row_data[col[:name]] = nil
-      end
-    end
-    dummy_row_data
-  end
 end

lib/row_context_builder.rb

@@ -30,12 +30,4 @@ def build_join_context(left_context, join_row, join_table_info, join_table_name,
 
     context
   end
-  
-  def extract_row_data(row_context, table_info)
-    row_data = {}
-    table_info[:columns].each do |col|
-      row_data[col[:name]] = row_context[col[:name]]
-    end
-    row_data
-  end
 end