rubydb 0.1.0

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # ROLLBACK statement AST node
+      class Rollback < Node
+        attr_reader :chain
+
+        def initialize(chain: false, location: nil)
+          super(location: location)
+          @chain = chain
+        end
+
+        def accept(visitor)
+          visitor.visit_rollback(self)
+        end
+
+        def clone
+          Rollback.new(chain: @chain, location: @location)
+        end
+
+        def to_sql
+          parts = ["ROLLBACK"]
+          parts << "AND CHAIN" if @chain
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "Rollback"
+          str << " (chain: true)" if @chain
+          str
+        end
+      end
+
+      # ROLLBACK TO SAVEPOINT statement AST node
+      class RollbackToSavepoint < Node
+        attr_reader :savepoint_name
+
+        def initialize(savepoint_name, location: nil)
+          super(location: location)
+          @savepoint_name = savepoint_name
+        end
+
+        def accept(visitor)
+          visitor.visit_rollback_to_savepoint(self)
+        end
+
+        def clone
+          RollbackToSavepoint.new(@savepoint_name, location: @location)
+        end
+
+        def to_sql
+          "ROLLBACK TO SAVEPOINT #{@savepoint_name}"
+        end
+
+        def inspect
+          "RollbackToSavepoint(savepoint: #{@savepoint_name})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # SAVEPOINT statement AST node
+      class Savepoint < Node
+        attr_reader :name
+
+        def initialize(name, location: nil)
+          super(location: location)
+          @name = name
+        end
+
+        def accept(visitor)
+          visitor.visit_savepoint(self)
+        end
+
+        def clone
+          Savepoint.new(@name, location: @location)
+        end
+
+        def to_sql
+          "SAVEPOINT #{@name}"
+        end
+
+        def inspect
+          "Savepoint(name: #{@name})"
+        end
+      end
+
+      # RELEASE SAVEPOINT statement AST node
+      class ReleaseSavepoint < Node
+        attr_reader :name
+
+        def initialize(name, location: nil)
+          super(location: location)
+          @name = name
+        end
+
+        def accept(visitor)
+          visitor.visit_release_savepoint(self)
+        end
+
+        def clone
+          ReleaseSavepoint.new(@name, location: @location)
+        end
+
+        def to_sql
+          "RELEASE SAVEPOINT #{@name}"
+        end
+
+        def inspect
+          "ReleaseSavepoint(name: #{@name})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # SELECT statement AST node
+      class Select < Node
+        attr_reader :columns, :from, :where, :order_by, :limit, :offset, :distinct, :group_by, :having, :joins
+
+        def initialize(columns, from, where = nil, order_by = nil, limit = nil, offset = nil, distinct = false, joins: [], group_by: [], having: nil, location: nil)
+          super(location: location)
+          @columns = columns
+          @from = from
+          @where = where
+          @order_by = order_by || []
+          @limit = limit
+          @offset = offset
+          @distinct = distinct
+          @group_by = group_by
+          @having = having
+          @joins = joins
+        end
+
+        def accept(visitor)
+          visitor.visit_select(self)
+        end
+
+        def clone
+          Select.new(
+            @columns.map(&:clone),
+            @from&.clone,
+            @where&.clone,
+            @order_by.map(&:clone),
+            @limit&.clone,
+            @offset&.clone,
+            @distinct,
+            joins: @joins.map(&:clone), group_by: @group_by.map(&:clone), having: @having&.clone,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "SELECT"
+          parts << "DISTINCT" if @distinct
+          parts << @columns.map(&:to_sql).join(", ")
+          parts << "FROM #{@from.to_sql}" if @from
+          parts.concat(@joins.map(&:to_sql))
+          parts << "WHERE #{@where.to_sql}" if @where
+          parts << "GROUP BY #{@group_by.map(&:to_sql).join(', ')}" if @group_by.any?
+          parts << "HAVING #{@having.to_sql}" if @having
+          parts << "ORDER BY #{@order_by.map(&:to_sql).join(", ")}" if @order_by.any?
+          parts << "LIMIT #{@limit.to_sql}" if @limit
+          parts << "OFFSET #{@offset.to_sql}" if @offset
+          parts.join(" ")
+        end
+
+        def inspect
+          cols = @columns.map(&:inspect).join(", ")
+          str = "Select(columns: [#{cols}], from: #{@from.inspect}"
+          str << ", joins: #{@joins.map(&:inspect).join(', ')}" if @joins.any?
+          str << ", where: #{@where.inspect}" if @where
+          str << ", order_by: #{@order_by.map(&:inspect).join(", ")}" if @order_by.any?
+          str << ", limit: #{@limit.inspect}" if @limit
+          str << ", offset: #{@offset.inspect}" if @offset
+          str << ", distinct: true" if @distinct
+          str << ")"
+          str
+        end
+
+        # Helper methods for semantic analysis
+        def has_star?
+          @columns.any? do |col|
+            col.is_a?(Star) || (col.respond_to?(:expression) && col.expression.is_a?(Star))
+          end
+        end
+
+        def column_count
+          @columns.size
+        end
+
+        def table_name
+          @from&.name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class SetOperation < Node
+        attr_reader :left, :right, :operator, :all
+
+        def initialize(left, right, operator, all: false, location: nil)
+          super(location: location)
+          @left, @right, @operator, @all = left, right, operator, all
+        end
+
+        def accept(visitor) = visitor.visit_set_operation(self)
+        def clone = SetOperation.new(@left.clone, @right.clone, @operator, all: @all, location: @location)
+        def to_sql = "#{@left.to_sql} #{@operator.to_s.upcase}#{@all ? ' ALL' : ''} #{@right.to_sql}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class CreateTrigger < Node
+        attr_reader :name, :timing, :event, :table_name, :function_name
+        def initialize(name, timing, event, table_name, function_name, location: nil)
+          super(location: location)
+          @name, @timing, @event, @table_name, @function_name = name, timing, event, table_name, function_name
+        end
+        def accept(visitor) = visitor.visit_create_trigger(self)
+        def clone = self.class.new(@name, @timing, @event, @table_name, @function_name, location: @location)
+        def to_sql = "CREATE TRIGGER #{@name} #{@timing.to_s.upcase} #{@event.to_s.upcase} ON #{@table_name} EXECUTE FUNCTION #{@function_name}()"
+      end
+
+      class DropTrigger < Node
+        attr_reader :name, :if_exists
+        def initialize(name, if_exists: false, location: nil)
+          super(location: location)
+          @name, @if_exists = name, if_exists
+        end
+        def accept(visitor) = visitor.visit_drop_trigger(self)
+        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
+        def to_sql = "DROP TRIGGER #{@name}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # UPDATE statement AST node
+      class Update < Node
+        attr_reader :table, :assignments, :where
+
+        def initialize(table, assignments, where = nil, location: nil)
+          super(location: location)
+          @table = table
+          @assignments = assignments
+          @where = where
+        end
+
+        def accept(visitor)
+          visitor.visit_update(self)
+        end
+
+        def clone
+          Update.new(
+            @table,
+            @assignments.map(&:clone),
+            @where&.clone,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "UPDATE #{@table}"
+          parts << "SET #{@assignments.map(&:to_sql).join(", ")}"
+          parts << "WHERE #{@where.to_sql}" if @where
+          parts.join(" ")
+        end
+
+        def inspect
+          ass = @assignments.map(&:inspect).join(", ")
+          str = "Update(table: #{@table}, assignments: [#{ass}]"
+          str << ", where: #{@where.inspect}" if @where
+          str << ")"
+          str
+        end
+
+        # Helper methods
+        def assignment_count
+          @assignments.size
+        end
+
+        def has_where?
+          !@where.nil?
+        end
+
+        def updated_columns
+          @assignments.map(&:column)
+        end
+      end
+
+      # Assignment in UPDATE statement
+      class Assignment < Node
+        attr_reader :column, :value
+
+        def initialize(column, value, location: nil)
+          super(location: location)
+          @column = column
+          @value = value
+        end
+
+        def accept(visitor)
+          visitor.visit_assignment(self)
+        end
+
+        def clone
+          Assignment.new(@column, @value.clone, location: @location)
+        end
+
+        def to_sql
+          "#{@column} = #{@value.to_sql}"
+        end
+
+        def inspect
+          "Assignment(#{@column} = #{@value.inspect})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class Vacuum < Node
+        def accept(visitor)
+          visitor.visit_vacuum(self)
+        end
+
+        def clone
+          self.class.new(location: @location)
+        end
+
+        def to_sql = "VACUUM"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class CreateView < Node
+        attr_reader :name, :query, :if_not_exists
+        def initialize(name, query, if_not_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @query = query
+          @if_not_exists = if_not_exists
+        end
+        def accept(visitor) = visitor.visit_create_view(self)
+        def clone = self.class.new(@name, @query.clone, if_not_exists: @if_not_exists, location: @location)
+        def to_sql = "CREATE VIEW #{@name} AS #{@query.to_sql}"
+      end
+
+      class DropView < Node
+        attr_reader :name, :if_exists
+        def initialize(name, if_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_exists = if_exists
+        end
+        def accept(visitor) = visitor.visit_drop_view(self)
+        def clone = self.class.new(@name, if_exists: @if_exists, location: @location)
+        def to_sql = "DROP VIEW #{@name}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # A materialized WITH query. Recursive CTEs are evaluated iteratively by
+      # the executor with a bounded working set.
+      class With < Node
+        attr_reader :ctes, :query, :recursive
+
+        def initialize(ctes, query, recursive: false, location: nil)
+          super(location: location)
+          @ctes = ctes
+          @query = query
+          @recursive = recursive
+        end
+
+        def accept(visitor) = visitor.visit_with(self)
+
+        def clone
+          With.new(@ctes.map { |name, query| [name, query.clone] }, @query.clone, recursive: @recursive, location: @location)
+        end
+
+        def to_sql
+          definitions = @ctes.map { |name, query| "#{name} AS (#{query.to_sql})" }.join(", ")
+          prefix = @recursive ? "WITH RECURSIVE" : "WITH"
+          "#{prefix} #{definitions} #{@query.to_sql}"
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/sql/grammar.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    # SQL Grammar definitions - used for validation and reference
+    module Grammar
+      # SQL statement types
+      STATEMENT_TYPES = {
+        select: "SELECT ... FROM ... [WHERE ...] [ORDER BY ...] [LIMIT ...] [OFFSET ...]",
+        insert: "INSERT INTO table [(columns)] VALUES (values)[, (values)...]",
+        update: "UPDATE table SET column = value [WHERE ...]",
+        delete: "DELETE FROM table [WHERE ...]",
+        create_table: "CREATE TABLE name (column_definitions [, constraints])",
+        create_index: "CREATE [UNIQUE] INDEX name ON table (columns)",
+        create_database: "CREATE DATABASE name",
+        drop_table: "DROP TABLE name",
+        drop_index: "DROP INDEX name",
+        drop_database: "DROP DATABASE name",
+        alter_table: "ALTER TABLE name ADD/DROP column/constraint",
+        begin: "BEGIN [TRANSACTION]",
+        commit: "COMMIT [TRANSACTION]",
+        rollback: "ROLLBACK [TRANSACTION] [TO SAVEPOINT name]",
+        savepoint: "SAVEPOINT name",
+        release_savepoint: "RELEASE [SAVEPOINT] name",
+        explain: "EXPLAIN [ANALYZE] statement",
+        vacuum: "VACUUM",
+        create_view: "CREATE VIEW name AS SELECT ...",
+        create_trigger: "CREATE TRIGGER name BEFORE|AFTER event ON table EXECUTE FUNCTION name()"
+      }.freeze
+
+      # Column data types
+      DATA_TYPES = {
+        integer: "INTEGER",
+        bigint: "BIGINT",
+        smallint: "SMALLINT",
+        float: "FLOAT",
+        decimal: "DECIMAL(precision, scale)",
+        numeric: "NUMERIC(precision, scale)",
+        boolean: "BOOLEAN",
+        text: "TEXT",
+        varchar: "VARCHAR(length)",
+        char: "CHAR(length)",
+        blob: "BLOB",
+        date: "DATE",
+        time: "TIME",
+        timestamp: "TIMESTAMP",
+        json: "JSON",
+        uuid: "UUID"
+      }.freeze
+
+      # Operators
+      OPERATORS = {
+        comparison: ["=", "!=", "<>", "<", "<=", ">", ">="],
+        logical: ["AND", "OR", "NOT"],
+        arithmetic: ["+", "-", "*", "/", "%"],
+        bitwise: ["&", "|", "^", "~"],
+        other: ["LIKE", "ILIKE", "BETWEEN", "IN", "IS", "IS NOT"]
+      }.freeze
+
+      # Constraint types
+      CONSTRAINT_TYPES = {
+        primary_key: "PRIMARY KEY (columns)",
+        foreign_key: "FOREIGN KEY (columns) REFERENCES table (columns)",
+        unique: "UNIQUE (columns)",
+        check: "CHECK (condition)",
+        not_null: "NOT NULL"
+      }.freeze
+
+      def self.validate_statement_type(type)
+        STATEMENT_TYPES.key?(type) ? true : false
+      end
+
+      def self.validate_data_type(type)
+        DATA_TYPES.key?(type) ? true : false
+      end
+
+      def self.validate_operator(op)
+        OPERATORS.values.flatten.include?(op.to_s.upcase)
+      end
+
+      def self.validate_constraint_type(type)
+        CONSTRAINT_TYPES.key?(type) ? true : false
+      end
+    end
+  end
+end

data/lib/rubydb/sql/keywords.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    # SQL keyword definitions
+    module Keywords
+      # Map of keyword strings to token types
+      KEYWORD_MAP = {
+        "SELECT" => Token::Type::SELECT,
+        "INSERT" => Token::Type::INSERT,
+        "UPDATE" => Token::Type::UPDATE,
+        "DELETE" => Token::Type::DELETE,
+        "CREATE" => Token::Type::CREATE,
+        "ALTER" => Token::Type::ALTER,
+        "DROP" => Token::Type::DROP,
+        "TABLE" => Token::Type::TABLE,
+        "INDEX" => Token::Type::INDEX,
+        "DATABASE" => Token::Type::DATABASE,
+        "SCHEMA" => Token::Type::SCHEMA,
+        "VIEW" => Token::Type::VIEW,
+        "TRIGGER" => Token::Type::TRIGGER,
+        "FROM" => Token::Type::FROM,
+        "WHERE" => Token::Type::WHERE,
+        "SET" => Token::Type::SET,
+        "VALUES" => Token::Type::VALUES,
+        "INTO" => Token::Type::INTO,
+        "CONFLICT" => Token::Type::CONFLICT,
+        "DO" => Token::Type::DO,
+        "NOTHING" => Token::Type::NOTHING,
+        "JOIN" => Token::Type::JOIN,
+        "INNER" => Token::Type::INNER,
+        "LEFT" => Token::Type::LEFT,
+        "RIGHT" => Token::Type::RIGHT,
+        "OUTER" => Token::Type::OUTER,
+        "FULL" => Token::Type::FULL,
+        "CROSS" => Token::Type::CROSS,
+        "ON" => Token::Type::ON,
+        "AS" => Token::Type::AS,
+        "DISTINCT" => Token::Type::DISTINCT,
+        "ORDER" => Token::Type::ORDER,
+        "BY" => Token::Type::BY,
+        "ASC" => Token::Type::ASC,
+        "DESC" => Token::Type::DESC,
+        "GROUP" => Token::Type::GROUP,
+        "HAVING" => Token::Type::HAVING,
+        "LIMIT" => Token::Type::LIMIT,
+        "OFFSET" => Token::Type::OFFSET,
+        "UNION" => Token::Type::UNION,
+        "INTERSECT" => Token::Type::INTERSECT,
+        "EXCEPT" => Token::Type::EXCEPT,
+        "ALL" => Token::Type::ALL,
+        "ANY" => Token::Type::ANY,
+        "SOME" => Token::Type::SOME,
+        "EXISTS" => Token::Type::EXISTS,
+        "IF" => Token::Type::IF,
+        "BETWEEN" => Token::Type::BETWEEN,
+        "LIKE" => Token::Type::LIKE,
+        "ILIKE" => Token::Type::ILIKE,
+        "IN" => Token::Type::IN,
+        "IS" => Token::Type::IS,
+        "NULL" => Token::Type::NULL,
+        "NOT" => Token::Type::NOT,
+        "AND" => Token::Type::AND,
+        "OR" => Token::Type::OR,
+        "TRUE" => Token::Type::TRUE,
+        "FALSE" => Token::Type::FALSE,
+        "PRIMARY" => Token::Type::PRIMARY,
+        "FOREIGN" => Token::Type::FOREIGN,
+        "KEY" => Token::Type::KEY,
+        "UNIQUE" => Token::Type::UNIQUE,
+        "CHECK" => Token::Type::CHECK,
+        "DEFAULT" => Token::Type::DEFAULT,
+        "REFERENCES" => Token::Type::REFERENCES,
+        "CONSTRAINT" => Token::Type::CONSTRAINT,
+        "CASCADE" => Token::Type::CASCADE,
+        "RESTRICT" => Token::Type::RESTRICT,
+        "BEFORE" => Token::Type::BEFORE,
+        "AFTER" => Token::Type::AFTER,
+        "EXECUTE" => Token::Type::EXECUTE,
+        "FUNCTION" => Token::Type::FUNCTION,
+        "ADD" => Token::Type::ADD,
+        "TO" => Token::Type::TO,
+        "BEGIN" => Token::Type::BEGIN_TRANSACTION,
+        "COMMIT" => Token::Type::COMMIT,
+        "ROLLBACK" => Token::Type::ROLLBACK,
+        "SAVEPOINT" => Token::Type::SAVEPOINT,
+        "RELEASE" => Token::Type::RELEASE,
+        "TRANSACTION" => Token::Type::TRANSACTION,
+        "EXPLAIN" => Token::Type::EXPLAIN,
+        "ANALYZE" => Token::Type::ANALYZE,
+        "VACUUM" => Token::Type::VACUUM,
+        "WITH" => Token::Type::WITH,
+        "RECURSIVE" => Token::Type::RECURSIVE,
+        "OVER" => Token::Type::OVER,
+        "PARTITION" => Token::Type::PARTITION,
+        "ROWS" => Token::Type::ROWS,
+        "UNBOUNDED" => Token::Type::UNBOUNDED,
+        "PRECEDING" => Token::Type::PRECEDING,
+        "FOLLOWING" => Token::Type::FOLLOWING,
+        "CURRENT" => Token::Type::CURRENT,
+        "INTEGER" => Token::Type::INTEGER,
+        "BIGINT" => Token::Type::BIGINT,
+        "SMALLINT" => Token::Type::SMALLINT,
+        "FLOAT" => Token::Type::FLOAT,
+        "DECIMAL" => Token::Type::DECIMAL,
+        "NUMERIC" => Token::Type::NUMERIC,
+        "BOOLEAN" => Token::Type::BOOLEAN,
+        "TEXT" => Token::Type::TEXT,
+        "VARCHAR" => Token::Type::VARCHAR,
+        "CHAR" => Token::Type::CHAR,
+        "BLOB" => Token::Type::BLOB,
+        "DATE" => Token::Type::DATE,
+        "TIME" => Token::Type::TIME,
+        "TIMESTAMP" => Token::Type::TIMESTAMP,
+        "JSON" => Token::Type::JSON,
+        "UUID" => Token::Type::UUID
+      }.freeze
+
+      # SQL keywords that are reserved
+      RESERVED_KEYWORDS = %w[
+        SELECT INSERT UPDATE DELETE CREATE ALTER DROP
+        TABLE INDEX DATABASE SCHEMA VIEW TRIGGER
+        FROM WHERE SET VALUES INTO JOIN ON AS
+        DISTINCT ORDER BY ASC DESC GROUP HAVING LIMIT OFFSET
+        UNION INTERSECT EXCEPT ALL ANY SOME EXISTS
+        BETWEEN LIKE ILIKE IN IS NULL NOT AND OR
+        TRUE FALSE PRIMARY FOREIGN KEY UNIQUE CHECK
+        DEFAULT REFERENCES CONSTRAINT CASCADE RESTRICT
+        BEGIN COMMIT ROLLBACK SAVEPOINT RELEASE TRANSACTION
+      ].freeze
+
+      # Data type keywords
+      TYPE_KEYWORDS = %w[
+        INTEGER BIGINT SMALLINT FLOAT DECIMAL NUMERIC
+        BOOLEAN TEXT VARCHAR CHAR BLOB DATE TIME TIMESTAMP
+        JSON UUID
+      ].freeze
+
+      def self.keyword?(word)
+        KEYWORD_MAP.key?(word.upcase)
+      end
+
+      def self.token_type(word)
+        KEYWORD_MAP[word.upcase]
+      end
+
+      def self.reserved?(word)
+        RESERVED_KEYWORDS.include?(word.upcase)
+      end
+
+      def self.type_keyword?(word)
+        TYPE_KEYWORDS.include?(word.upcase)
+      end
+    end
+  end
+end