rubydb 0.1.0

data/lib/rubydb/sql/lexer.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "../errors/error"
+require_relative "../errors/parser_error"
+
+module RubyDB
+  module SQL
+    # SQL Lexer - converts SQL text into tokens
+    class Lexer
+      attr_reader :tokens, :current_position
+
+      def initialize(text)
+        @text = text
+        @scanner = StringScanner.new(text)
+        @tokens = []
+        @current_position = { line: 1, column: 1 }
+        @line_start = 0
+        @current_position[:line] = 1
+        @current_position[:column] = 1
+      end
+
+      def tokenize
+        @tokens = []
+        until @scanner.eos?
+          skip_whitespace
+          break if @scanner.eos?
+
+          token = scan_token
+          @tokens << token if token
+        end
+        @tokens << Token.new(Token::Type::EOF, line: @current_position[:line], column: @current_position[:column])
+        @tokens
+      end
+
+      private
+
+      def skip_whitespace
+        while true
+          case
+          when @scanner.scan(/\s+/)
+            update_position($&)
+          when @scanner.scan(/--[^\n]*/)
+            update_position($&)
+            next
+          when @scanner.scan(/\/\*.*?\*\//m)
+            update_position($&)
+            next
+          else
+            break
+          end
+        end
+      end
+
+      def scan_token
+        pos = { line: @current_position[:line], column: @current_position[:column] }
+
+        token =
+          case
+          when @scanner.scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
+            word = @scanner.matched.upcase
+            update_position($&)
+            if Keywords.keyword?(word)
+              Token.new(Keywords.token_type(word), word, **pos)
+            else
+              Token.new(Token::Type::IDENTIFIER, @scanner.matched, **pos)
+            end
+
+          when @scanner.scan(/'(?:''|[^'])*'/)
+            update_position($&)
+            Token.new(Token::Type::STRING, @scanner.matched[1..-2].gsub("''", "'"), **pos)
+
+          when @scanner.scan(/"[^"]*"/)
+            update_position($&)
+            Token.new(Token::Type::IDENTIFIER, @scanner.matched[1..-2], **pos)
+
+          when @scanner.scan(/`[^`]*`/)
+            update_position($&)
+            Token.new(Token::Type::IDENTIFIER, @scanner.matched[1..-2], **pos)
+
+          when @scanner.scan(/\d+\.\d+/)
+            update_position($&)
+            Token.new(Token::Type::NUMBER, @scanner.matched.to_f, **pos)
+
+          when @scanner.scan(/\d+/)
+            update_position($&)
+            Token.new(Token::Type::NUMBER, @scanner.matched.to_i, **pos)
+
+          when @scanner.scan(/\?/)
+            update_position($&)
+            Token.new(Token::Type::PARAMETER, nil, **pos)
+
+          when @scanner.scan(/\$\d+/)
+            update_position($&)
+            Token.new(Token::Type::PARAMETER, @scanner.matched[1..-1].to_i, **pos)
+
+          when @scanner.scan(/<=/)
+            update_position($&)
+            Token.new(Token::Type::LTE, "<=", **pos)
+
+          when @scanner.scan(/>=/)
+            update_position($&)
+            Token.new(Token::Type::GTE, ">=", **pos)
+
+          when @scanner.scan(/!=|<>/)
+            update_position($&)
+            Token.new(Token::Type::NE, @scanner.matched, **pos)
+
+          when @scanner.scan(/=/)
+            update_position($&)
+            Token.new(Token::Type::EQ, "=", **pos)
+
+          when @scanner.scan(/</)
+            update_position($&)
+            Token.new(Token::Type::LT, "<", **pos)
+
+          when @scanner.scan(/>/)
+            update_position($&)
+            Token.new(Token::Type::GT, ">", **pos)
+
+          when @scanner.scan(/\+/)
+            update_position($&)
+            Token.new(Token::Type::PLUS, "+", **pos)
+
+          when @scanner.scan(/-/)
+            update_position($&)
+            Token.new(Token::Type::MINUS, "-", **pos)
+
+          when @scanner.scan(/\*/)
+            update_position($&)
+            Token.new(Token::Type::STAR, "*", **pos)
+
+          when @scanner.scan(/\//)
+            update_position($&)
+            Token.new(Token::Type::SLASH, "/", **pos)
+
+          when @scanner.scan(/\%/)
+            update_position($&)
+            Token.new(Token::Type::PERCENT, "%", **pos)
+
+          when @scanner.scan(/\(/)
+            update_position($&)
+            Token.new(Token::Type::LPAREN, "(", **pos)
+
+          when @scanner.scan(/\)/)
+            update_position($&)
+            Token.new(Token::Type::RPAREN, ")", **pos)
+
+          when @scanner.scan(/,/)
+            update_position($&)
+            Token.new(Token::Type::COMMA, ",", **pos)
+
+          when @scanner.scan(/;/)
+            update_position($&)
+            Token.new(Token::Type::SEMICOLON, ";", **pos)
+
+          when @scanner.scan(/\./)
+            update_position($&)
+            Token.new(Token::Type::DOT, ".", **pos)
+
+          when @scanner.scan(/\[/)
+            update_position($&)
+            Token.new(Token::Type::LBRACKET, "[", **pos)
+
+          when @scanner.scan(/\]/)
+            update_position($&)
+            Token.new(Token::Type::RBRACKET, "]", **pos)
+
+          when @scanner.scan(/\{/)
+            update_position($&)
+            Token.new(Token::Type::LBRACE, "{", **pos)
+
+          when @scanner.scan(/\}/)
+            update_position($&)
+            Token.new(Token::Type::RBRACE, "}", **pos)
+
+          when @scanner.scan(/&/)
+            update_position($&)
+            Token.new(Token::Type::AMPERSAND, "&", **pos)
+
+          when @scanner.scan(/\|/)
+            update_position($&)
+            Token.new(Token::Type::PIPE, "|", **pos)
+
+          when @scanner.scan(/\^/)
+            update_position($&)
+            Token.new(Token::Type::CARET, "^", **pos)
+
+          when @scanner.scan(/~/)
+            update_position($&)
+            Token.new(Token::Type::TILDE, "~", **pos)
+
+          else
+            char = @scanner.getch
+            update_position(char)
+            raise RubyDB::ParserError, "Unexpected character #{char.inspect} at #{@current_position[:line]}:#{@current_position[:column]}"
+          end
+
+        token
+      end
+
+      def update_position(text)
+        text ||= @scanner.matched
+        lines = text.count("\n")
+        if lines > 0
+          @current_position[:line] += lines
+          @current_position[:column] = text.length - text.rindex("\n")
+        else
+          @current_position[:column] += text.length
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/operators.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    # SQL operator definitions
+    module Operators
+      # Operator precedence (higher = binds tighter)
+      PRECEDENCE = {
+        Token::Type::DOT => 18,
+        Token::Type::LBRACKET => 18,
+        Token::Type::TILDE => 17,
+        Token::Type::STAR => 16,
+        Token::Type::SLASH => 16,
+        Token::Type::PERCENT => 16,
+        Token::Type::PLUS => 15,
+        Token::Type::MINUS => 15,
+        Token::Type::AMPERSAND => 14,
+        Token::Type::PIPE => 13,
+        Token::Type::CARET => 12,
+        Token::Type::LT => 11,
+        Token::Type::LTE => 11,
+        Token::Type::GT => 11,
+        Token::Type::GTE => 11,
+        Token::Type::EQ => 10,
+        Token::Type::NE => 10,
+        Token::Type::LIKE => 9,
+        Token::Type::ILIKE => 9,
+        Token::Type::NOT => 8,
+        Token::Type::AND => 7,
+        Token::Type::OR => 6,
+        Token::Type::BETWEEN => 5,
+        Token::Type::IN => 5,
+        Token::Type::IS => 5
+      }.freeze
+
+      # Operator associativity: :left, :right, or :nonassoc
+      ASSOCIATIVITY = {
+        Token::Type::DOT => :left,
+        Token::Type::LBRACKET => :left,
+        Token::Type::TILDE => :right,
+        Token::Type::STAR => :left,
+        Token::Type::SLASH => :left,
+        Token::Type::PERCENT => :left,
+        Token::Type::PLUS => :left,
+        Token::Type::MINUS => :left,
+        Token::Type::AMPERSAND => :left,
+        Token::Type::PIPE => :left,
+        Token::Type::CARET => :left,
+        Token::Type::LT => :nonassoc,
+        Token::Type::LTE => :nonassoc,
+        Token::Type::GT => :nonassoc,
+        Token::Type::GTE => :nonassoc,
+        Token::Type::EQ => :nonassoc,
+        Token::Type::NE => :nonassoc,
+        Token::Type::LIKE => :nonassoc,
+        Token::Type::ILIKE => :nonassoc,
+        Token::Type::NOT => :right,
+        Token::Type::AND => :left,
+        Token::Type::OR => :left,
+        Token::Type::BETWEEN => :nonassoc,
+        Token::Type::IN => :nonassoc,
+        Token::Type::IS => :nonassoc
+      }.freeze
+
+      def self.precedence(token_type)
+        PRECEDENCE[token_type] || 0
+      end
+
+      def self.associativity(token_type)
+        ASSOCIATIVITY[token_type] || :left
+      end
+
+      def self.comparison?(token_type)
+        [Token::Type::EQ, Token::Type::NE, Token::Type::LT,
+         Token::Type::LTE, Token::Type::GT, Token::Type::GTE,
+         Token::Type::LIKE, Token::Type::ILIKE, Token::Type::BETWEEN,
+         Token::Type::IN, Token::Type::IS].include?(token_type)
+      end
+
+      def self.logical?(token_type)
+        [Token::Type::AND, Token::Type::OR, Token::Type::NOT].include?(token_type)
+      end
+
+      def self.arithmetic?(token_type)
+        [Token::Type::PLUS, Token::Type::MINUS, Token::Type::STAR,
+         Token::Type::SLASH, Token::Type::PERCENT].include?(token_type)
+      end
+
+      def self.bitwise?(token_type)
+        [Token::Type::AMPERSAND, Token::Type::PIPE,
+         Token::Type::CARET, Token::Type::TILDE].include?(token_type)
+      end
+
+      def self.unary?(token_type)
+        [Token::Type::PLUS, Token::Type::MINUS, Token::Type::TILDE,
+         Token::Type::NOT].include?(token_type)
+      end
+    end
+  end
+end