rubydb 0.1.0

data/lib/rubydb/sql/ast/expression.rb

@@ -0,0 +1,604 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # Base class for all expression nodes
+      class Expression < Node
+        # Type of expression result (set by type checker)
+        attr_accessor :type
+
+        def initialize(location: nil)
+          super(location: location)
+          @type = nil
+        end
+
+        # Is this expression a literal value?
+        def literal?
+          false
+        end
+
+        # Is this expression a column reference?
+        def column?
+          false
+        end
+
+        # Is this expression NULL?
+        def null?
+          false
+        end
+
+        # Does this expression contain a subquery?
+        def contains_subquery?
+          false
+        end
+      end
+
+      # Literal value
+      class Literal < Expression
+        attr_reader :value, :token_type
+
+        def initialize(value, token_type, location: nil)
+          super(location: location)
+          @value = value
+          @token_type = token_type
+        end
+
+        def literal?
+          true
+        end
+
+        def null?
+          @value.nil?
+        end
+
+        def accept(visitor)
+          visitor.visit_literal(self)
+        end
+
+        def clone
+          Literal.new(@value, @token_type, location: @location)
+        end
+
+        def to_sql
+          case @token_type
+          when Token::Type::STRING
+            "'#{@value.to_s.gsub("'", "''")}'"
+          when Token::Type::NUMBER
+            @value.to_s
+          when Token::Type::NULL
+            "NULL"
+          when Token::Type::TRUE
+            "TRUE"
+          when Token::Type::FALSE
+            "FALSE"
+          else
+            @value.to_s
+          end
+        end
+
+        def inspect
+          "Literal(#{@value})"
+        end
+      end
+
+      # NULL literal
+      class NullLiteral < Literal
+        def initialize(location: nil)
+          super(nil, Token::Type::NULL, location: location)
+        end
+
+        def null?
+          true
+        end
+
+        def to_sql
+          "NULL"
+        end
+
+        def inspect
+          "NULL"
+        end
+      end
+
+      # Column reference
+      class Identifier < Expression
+        attr_reader :name, :table
+
+        def initialize(name, table: nil, location: nil)
+          super(location: location)
+          @name = name
+          @table = table
+        end
+
+        def column?
+          true
+        end
+
+        def accept(visitor)
+          visitor.visit_identifier(self)
+        end
+
+        def clone
+          Identifier.new(@name, table: @table, location: @location)
+        end
+
+        def to_sql
+          if @table
+            "#{@table}.#{@name}"
+          else
+            @name
+          end
+        end
+
+        def inspect
+          if @table
+            "Identifier(#{@table}.#{@name})"
+          else
+            "Identifier(#{@name})"
+          end
+        end
+      end
+
+      # Unary operator expression
+      class UnaryOp < Expression
+        attr_reader :operator, :operand
+
+        def initialize(operator, operand, location: nil)
+          super(location: location)
+          @operator = operator
+          @operand = operand
+        end
+
+        def accept(visitor)
+          visitor.visit_unary_op(self)
+        end
+
+        def clone
+          UnaryOp.new(@operator, @operand.clone, location: @location)
+        end
+
+        def to_sql
+          "#{operator_string(@operator)}#{@operand.to_sql}"
+        end
+
+        def inspect
+          "UnaryOp(#{@operator}, #{@operand.inspect})"
+        end
+
+        private
+
+        def operator_string(op)
+          case op
+          when Token::Type::PLUS then "+"
+          when Token::Type::MINUS then "-"
+          when Token::Type::TILDE then "~"
+          when Token::Type::NOT then "NOT "
+          else op.to_s
+          end
+        end
+      end
+
+      # Binary operator expression
+      class BinaryOp < Expression
+        attr_reader :operator, :left, :right
+
+        def initialize(operator, left, right, location: nil)
+          super(location: location)
+          @operator = operator
+          @left = left
+          @right = right
+        end
+
+        def accept(visitor)
+          visitor.visit_binary_op(self)
+        end
+
+        def clone
+          BinaryOp.new(@operator, @left.clone, @right.clone, location: @location)
+        end
+
+        def to_sql
+          "#{@left.to_sql} #{operator_string(@operator)} #{@right.to_sql}"
+        end
+
+        def inspect
+          "BinaryOp(#{@operator}, #{@left.inspect}, #{@right.inspect})"
+        end
+
+        private
+
+        def operator_string(op)
+          case op
+          when Token::Type::EQ then "="
+          when Token::Type::NE then "!="
+          when Token::Type::LT then "<"
+          when Token::Type::LTE then "<="
+          when Token::Type::GT then ">"
+          when Token::Type::GTE then ">="
+          when Token::Type::PLUS then "+"
+          when Token::Type::MINUS then "-"
+          when Token::Type::STAR then "*"
+          when Token::Type::SLASH then "/"
+          when Token::Type::PERCENT then "%"
+          when Token::Type::AND then "AND"
+          when Token::Type::OR then "OR"
+          when Token::Type::LIKE then "LIKE"
+          when Token::Type::ILIKE then "ILIKE"
+          else op.to_s
+          end
+        end
+      end
+
+      # BETWEEN expression
+      class Between < Expression
+        attr_reader :expression, :low, :high
+
+        def initialize(expression, low, high, location: nil)
+          super(location: location)
+          @expression = expression
+          @low = low
+          @high = high
+        end
+
+        def accept(visitor)
+          visitor.visit_between(self)
+        end
+
+        def clone
+          Between.new(@expression.clone, @low.clone, @high.clone, location: @location)
+        end
+
+        def to_sql
+          "#{@expression.to_sql} BETWEEN #{@low.to_sql} AND #{@high.to_sql}"
+        end
+
+        def inspect
+          "Between(#{@expression.inspect}, #{@low.inspect}, #{@high.inspect})"
+        end
+      end
+
+      # IN expression
+      class In < Expression
+        attr_reader :expression, :values
+
+        def initialize(expression, values, location: nil)
+          super(location: location)
+          @expression = expression
+          @values = values
+        end
+
+        def accept(visitor)
+          visitor.visit_in(self)
+        end
+
+        def clone
+          In.new(@expression.clone, @values.map(&:clone), location: @location)
+        end
+
+        def to_sql
+          values_sql = @values.map(&:to_sql).join(", ")
+          "#{@expression.to_sql} IN (#{values_sql})"
+        end
+
+        def inspect
+          "In(#{@expression.inspect}, #{@values.map(&:inspect).join(", ")})"
+        end
+      end
+
+      class Subquery < Expression
+        attr_reader :query
+        def initialize(query, location: nil) = (super(location: location); @query = query)
+        def contains_subquery? = true
+        def accept(visitor) = visitor.visit_subquery(self)
+        def clone = Subquery.new(@query.clone, location: @location)
+        def to_sql = "(#{@query.to_sql})"
+      end
+
+      class Exists < Expression
+        attr_reader :query
+        def initialize(query, location: nil) = (super(location: location); @query = query)
+        def accept(visitor) = visitor.visit_exists(self)
+        def clone = Exists.new(@query.clone, location: @location)
+        def to_sql = "EXISTS (#{@query.to_sql})"
+      end
+
+      # IS NULL expression
+      class IsNull < Expression
+        attr_reader :expression, :negated
+
+        def initialize(expression, negated = false, location: nil)
+          super(location: location)
+          @expression = expression
+          @negated = negated
+        end
+
+        def accept(visitor)
+          visitor.visit_is_null(self)
+        end
+
+        def clone
+          IsNull.new(@expression.clone, @negated, location: @location)
+        end
+
+        def to_sql
+          if @negated
+            "#{@expression.to_sql} IS NOT NULL"
+          else
+            "#{@expression.to_sql} IS NULL"
+          end
+        end
+
+        def inspect
+          if @negated
+            "IsNull(#{@expression.inspect}, negated: true)"
+          else
+            "IsNull(#{@expression.inspect})"
+          end
+        end
+      end
+
+      # Function call
+      class FunctionCall < Expression
+        attr_reader :name, :arguments, :distinct, :window
+
+        def initialize(name, arguments = [], distinct: false, window: nil, location: nil)
+          super(location: location)
+          @name = name
+          @arguments = arguments
+          @distinct = distinct
+          @window = window
+        end
+
+        def accept(visitor)
+          visitor.visit_function_call(self)
+        end
+
+        def clone
+          cloned_window = if @window
+            {
+              partition_by: @window[:partition_by].map(&:clone),
+              order_by: @window[:order_by].map(&:clone),
+              frame: @window[:frame]&.transform_values { |value| value.is_a?(Hash) ? value.dup : value }
+            }
+          end
+          FunctionCall.new(@name, @arguments.map(&:clone), distinct: @distinct, window: cloned_window, location: @location)
+        end
+
+        def to_sql
+          args = @arguments.map(&:to_sql).join(", ")
+          args = "DISTINCT #{args}" if @distinct
+          sql = "#{@name}(#{args})"
+          if @window
+            partition = @window[:partition_by]
+            ordering = @window[:order_by]
+            parts = []
+            parts << "PARTITION BY #{partition.map(&:to_sql).join(', ')}" unless partition.empty?
+            parts << "ORDER BY #{ordering.map(&:to_sql).join(', ')}" unless ordering.empty?
+            parts << "ROWS #{window_frame_sql(@window[:frame])}" if @window[:frame]
+            sql << " OVER (#{parts.join(' ')})"
+          end
+          sql
+        end
+
+        def window_frame_sql(frame)
+          boundary = lambda do |value|
+            case value[:kind]
+            when :unbounded_preceding then "UNBOUNDED PRECEDING"
+            when :unbounded_following then "UNBOUNDED FOLLOWING"
+            when :current_row then "CURRENT ROW"
+            when :preceding then "#{value[:value]} PRECEDING"
+            when :following then "#{value[:value]} FOLLOWING"
+            else raise ArgumentError, "Unknown window frame boundary: #{value[:kind]}"
+            end
+          end
+          if frame[:start] && frame[:finish]
+            "BETWEEN #{boundary.call(frame[:start])} AND #{boundary.call(frame[:finish])}"
+          else
+            boundary.call(frame[:start])
+          end
+        end
+
+        def inspect
+          "FunctionCall(#{@name}, #{@arguments.map(&:inspect).join(", ")})"
+        end
+      end
+
+      # Parameter (placeholder) for prepared statements
+      class Parameter < Expression
+        attr_reader :index
+
+        def initialize(index = nil, location: nil)
+          super(location: location)
+          @index = index
+        end
+
+        def accept(visitor)
+          visitor.visit_parameter(self)
+        end
+
+        def clone
+          Parameter.new(@index, location: @location)
+        end
+
+        def to_sql
+          if @index
+            "$#{@index}"
+          else
+            "?"
+          end
+        end
+
+        def inspect
+          if @index
+            "Parameter($#{@index})"
+          else
+            "Parameter(?)"
+          end
+        end
+      end
+
+      # Star (*) in SELECT
+      class Star < Expression
+        attr_reader :table
+
+        def initialize(table: nil, location: nil)
+          super(location: location)
+          @table = table
+        end
+
+        def accept(visitor)
+          visitor.visit_star(self)
+        end
+
+        def clone
+          Star.new(table: @table, location: @location)
+        end
+
+        def to_sql
+          @table ? "#{@table}.*" : "*"
+        end
+
+        def inspect
+          @table ? "Star(#{@table}.*)" : "Star"
+        end
+      end
+
+      # SELECT column with optional alias
+      class SelectColumn < Node
+        attr_reader :expression, :alias_name
+
+        def initialize(expression, alias_name = nil, location: nil)
+          super(location: location)
+          @expression = expression
+          @alias_name = alias_name
+        end
+
+        def accept(visitor)
+          visitor.visit_select_column(self)
+        end
+
+        def clone
+          SelectColumn.new(@expression.clone, @alias_name, location: @location)
+        end
+
+        def to_sql
+          if @alias_name
+            "#{@expression.to_sql} AS #{@alias_name}"
+          else
+            @expression.to_sql
+          end
+        end
+
+        def inspect
+          if @alias_name
+            "SelectColumn(#{@expression.inspect}, AS #{@alias_name})"
+          else
+            "SelectColumn(#{@expression.inspect})"
+          end
+        end
+      end
+
+      # Table reference with optional alias
+      class TableRef < Node
+        attr_reader :name, :alias_name
+
+        def initialize(name, alias_name = nil, location: nil)
+          super(location: location)
+          @name = name
+          @alias_name = alias_name
+        end
+
+        def accept(visitor)
+          visitor.visit_table_ref(self)
+        end
+
+        def clone
+          TableRef.new(@name, @alias_name, location: @location)
+        end
+
+        def to_sql
+          if @alias_name
+            "#{@name} AS #{@alias_name}"
+          else
+            @name
+          end
+        end
+
+        def inspect
+          if @alias_name
+            "TableRef(#{@name} AS #{@alias_name})"
+          else
+            "TableRef(#{@name})"
+          end
+        end
+      end
+
+      # A joined table and its ON predicate. JOIN support is intentionally
+      # represented in the regular SELECT AST so parser, planner and executor
+      # all agree on table aliases and qualified identifiers.
+      class Join < Node
+        attr_reader :type, :table, :condition
+
+        def initialize(type, table, condition = nil, location: nil)
+          super(location: location)
+          @type = type
+          @table = table
+          @condition = condition
+        end
+
+        def accept(visitor)
+          visitor.visit_join(self)
+        end
+
+        def clone
+          Join.new(@type, @table.clone, @condition&.clone, location: @location)
+        end
+
+        def to_sql
+          keyword = {
+            left: "LEFT JOIN",
+            right: "RIGHT JOIN",
+            full: "FULL JOIN",
+            cross: "CROSS JOIN"
+          }.fetch(@type, "INNER JOIN")
+          sql = "#{keyword} #{@table.to_sql}"
+          sql << " ON #{@condition.to_sql}" if @condition
+          sql
+        end
+
+        def inspect
+          "Join(#{@type}, #{@table.inspect}, #{@condition.inspect})"
+        end
+      end
+
+      # ORDER BY item
+      class OrderItem < Node
+        attr_reader :expression, :direction
+
+        def initialize(expression, direction = :asc, location: nil)
+          super(location: location)
+          @expression = expression
+          @direction = direction
+        end
+
+        def accept(visitor)
+          visitor.visit_order_item(self)
+        end
+
+        def clone
+          OrderItem.new(@expression.clone, @direction, location: @location)
+        end
+
+        def to_sql
+          dir = @direction == :asc ? "ASC" : "DESC"
+          "#{@expression.to_sql} #{dir}"
+        end
+
+        def inspect
+          "OrderItem(#{@expression.inspect}, #{@direction})"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/insert.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # INSERT statement AST node
+      class Insert < Node
+        attr_reader :table, :columns, :values, :rows, :on_conflict
+
+        def initialize(table, columns = [], values = [], rows: nil, on_conflict: nil, location: nil)
+          super(location: location)
+          @table = table
+          @columns = columns
+          @rows = rows || [values]
+          @values = @rows.first || []
+          @on_conflict = on_conflict
+        end
+
+        def accept(visitor)
+          visitor.visit_insert(self)
+        end
+
+        def clone
+          Insert.new(
+            @table,
+            @columns.dup,
+            @values.map(&:clone), rows: @rows.map { |row| row.map(&:clone) }, on_conflict: @on_conflict,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "INSERT INTO #{@table}"
+
+          if @columns.any?
+            parts << "(#{@columns.join(", ")})"
+          end
+
+          parts << "VALUES"
+          parts << @rows.map { |row| "(#{row.map(&:to_sql).join(", ")})" }.join(", ")
+          parts << "ON CONFLICT DO NOTHING" if @on_conflict == :nothing
+          if @on_conflict.is_a?(Hash) && @on_conflict[:action] == :update
+            target = @on_conflict[:target].any? ? " (#{@on_conflict[:target].join(', ')})" : ""
+            assignments = @on_conflict[:assignments].map(&:to_sql).join(", ")
+            parts << "ON CONFLICT#{target} DO UPDATE SET #{assignments}"
+          end
+
+          parts.join(" ")
+        end
+
+        def inspect
+          cols = @columns.any? ? @columns.join(", ") : "ALL"
+          vals = @rows.map { |row| "(#{row.map(&:inspect).join(", ")})" }.join(", ")
+          "Insert(table: #{@table}, columns: [#{cols}], values: [#{vals}])"
+        end
+
+        # Helper methods
+        def has_columns?
+          @columns.any?
+        end
+
+        def value_count
+          @values.size
+        end
+
+        def row_count
+          @rows.size
+        end
+
+        def column_count
+          @columns.size
+        end
+
+        # Get column index by name
+        def column_index(name)
+          @columns.index(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/ast/node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # Base class for all AST nodes
+      class Node
+        attr_reader :location
+
+        def initialize(location: nil)
+          @location = location
+        end
+
+        # Accept a visitor for traversal
+        def accept(visitor)
+          raise NotImplementedError, "#{self.class} must implement #accept"
+        end
+
+        # Deep clone of the node
+        def clone
+          raise NotImplementedError, "#{self.class} must implement #clone"
+        end
+
+        # Convert to SQL string
+        def to_sql
+          raise NotImplementedError, "#{self.class} must implement #to_sql"
+        end
+
+        # Compare two nodes for equality
+        def ==(other)
+          self.class == other.class && instance_variables.all? do |ivar|
+            instance_variable_get(ivar) == other.instance_variable_get(ivar)
+          end
+        end
+
+        def inspect
+          "#<#{self.class}>"
+        end
+      end
+    end
+  end
+end