rubydb 0.1.4 → 0.1.5

data/lib/rubydb/sql/lexer.rb

@@ -1,214 +1,209 @@
-# 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
+# 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
+        loop do
+          if @scanner.scan(/\s+/)
+            update_position($&)
+          elsif @scanner.scan(/--[^\n]*/)
+            update_position($&)
+            next
+          elsif @scanner.scan(/\/\*.*?\*\//m)
+            update_position($&)
+            next
+          else
+            break
+          end
+        end
+      end
+
+      def scan_token
+        pos = {line: @current_position[:line], column: @current_position[:column]}
+
+        if @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
+
+        elsif @scanner.scan(/'(?:''|[^'])*'/)
+          update_position($&)
+          Token.new(Token::Type::STRING, @scanner.matched[1..-2].gsub("''", "'"), **pos)
+
+        elsif @scanner.scan(/"[^"]*"/)
+          update_position($&)
+          Token.new(Token::Type::IDENTIFIER, @scanner.matched[1..-2], **pos)
+
+        elsif @scanner.scan(/`[^`]*`/)
+          update_position($&)
+          Token.new(Token::Type::IDENTIFIER, @scanner.matched[1..-2], **pos)
+
+        elsif @scanner.scan(/\d+\.\d+/)
+          update_position($&)
+          Token.new(Token::Type::NUMBER, @scanner.matched.to_f, **pos)
+
+        elsif @scanner.scan(/\d+/)
+          update_position($&)
+          Token.new(Token::Type::NUMBER, @scanner.matched.to_i, **pos)
+
+        elsif @scanner.scan("?")
+          update_position($&)
+          Token.new(Token::Type::PARAMETER, nil, **pos)
+
+        elsif @scanner.scan(/\$\d+/)
+          update_position($&)
+          Token.new(Token::Type::PARAMETER, @scanner.matched[1..].to_i, **pos)
+
+        elsif @scanner.scan("<=")
+          update_position($&)
+          Token.new(Token::Type::LTE, "<=", **pos)
+
+        elsif @scanner.scan(">=")
+          update_position($&)
+          Token.new(Token::Type::GTE, ">=", **pos)
+
+        elsif @scanner.scan(/!=|<>/)
+          update_position($&)
+          Token.new(Token::Type::NE, @scanner.matched, **pos)
+
+        elsif @scanner.scan("=")
+          update_position($&)
+          Token.new(Token::Type::EQ, "=", **pos)
+
+        elsif @scanner.scan("<")
+          update_position($&)
+          Token.new(Token::Type::LT, "<", **pos)
+
+        elsif @scanner.scan(">")
+          update_position($&)
+          Token.new(Token::Type::GT, ">", **pos)
+
+        elsif @scanner.scan("+")
+          update_position($&)
+          Token.new(Token::Type::PLUS, "+", **pos)
+
+        elsif @scanner.scan("-")
+          update_position($&)
+          Token.new(Token::Type::MINUS, "-", **pos)
+
+        elsif @scanner.scan("*")
+          update_position($&)
+          Token.new(Token::Type::STAR, "*", **pos)
+
+        elsif @scanner.scan("/")
+          update_position($&)
+          Token.new(Token::Type::SLASH, "/", **pos)
+
+        elsif @scanner.scan("%")
+          update_position($&)
+          Token.new(Token::Type::PERCENT, "%", **pos)
+
+        elsif @scanner.scan("(")
+          update_position($&)
+          Token.new(Token::Type::LPAREN, "(", **pos)
+
+        elsif @scanner.scan(")")
+          update_position($&)
+          Token.new(Token::Type::RPAREN, ")", **pos)
+
+        elsif @scanner.scan(",")
+          update_position($&)
+          Token.new(Token::Type::COMMA, ",", **pos)
+
+        elsif @scanner.scan(";")
+          update_position($&)
+          Token.new(Token::Type::SEMICOLON, ";", **pos)
+
+        elsif @scanner.scan(".")
+          update_position($&)
+          Token.new(Token::Type::DOT, ".", **pos)
+
+        elsif @scanner.scan("[")
+          update_position($&)
+          Token.new(Token::Type::LBRACKET, "[", **pos)
+
+        elsif @scanner.scan("]")
+          update_position($&)
+          Token.new(Token::Type::RBRACKET, "]", **pos)
+
+        elsif @scanner.scan("{")
+          update_position($&)
+          Token.new(Token::Type::LBRACE, "{", **pos)
+
+        elsif @scanner.scan("}")
+          update_position($&)
+          Token.new(Token::Type::RBRACE, "}", **pos)
+
+        elsif @scanner.scan("&")
+          update_position($&)
+          Token.new(Token::Type::AMPERSAND, "&", **pos)
+
+        elsif @scanner.scan("|")
+          update_position($&)
+          Token.new(Token::Type::PIPE, "|", **pos)
+
+        elsif @scanner.scan("^")
+          update_position($&)
+          Token.new(Token::Type::CARET, "^", **pos)
+
+        elsif @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
+      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

@@ -1,100 +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
+# 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