rubydb 0.1.0

data/lib/rubydb/server/worker_pool.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Server
+    # WorkerPool - Manages worker threads
+    class WorkerPool
+      attr_reader :stats
+
+      def initialize(config, engine, transaction_manager)
+        @config = config
+        @engine = engine
+        @transaction_manager = transaction_manager
+        @min_workers = config[:min_workers] || 2
+        @max_workers = config[:max_workers] || 20
+        @workers = []
+        @worker_counter = 0
+        @stats = {
+          total_workers: 0,
+          active_workers: 0,
+          idle_workers: 0,
+          workers_created: 0,
+          workers_destroyed: 0,
+          total_requests: 0,
+          queue_size: 0
+        }
+        @lock = Mutex.new
+        @running = false
+        @queue = Queue.new
+        @cleanup_thread = nil
+        @scaling_thread = nil
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+
+          # Create initial workers
+          @min_workers.times { create_worker }
+
+          # Start scaling thread
+          @scaling_thread = Thread.new { scaling_loop }
+
+          # Start cleanup thread
+          @cleanup_thread = Thread.new { cleanup_loop }
+
+          true
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          return unless @running
+
+          @running = false
+
+          # Stop scaling thread
+          if @scaling_thread
+            @scaling_thread.kill
+            @scaling_thread = nil
+          end
+
+          # Stop cleanup thread
+          if @cleanup_thread
+            @cleanup_thread.kill
+            @cleanup_thread = nil
+          end
+
+          # Stop all workers
+          @workers.each(&:stop)
+          @workers.clear
+
+          true
+        end
+      end
+
+      def submit(request)
+        @lock.synchronize do
+          return false unless @running
+
+          @queue << request
+          @stats[:total_requests] += 1
+          @stats[:queue_size] = @queue.size
+
+          # Find idle worker
+          worker = find_idle_worker
+
+          if worker
+            worker.submit(request)
+          else
+            # Queue the request
+            @queue << request
+          end
+
+          true
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            workers: @workers.size,
+            running: @running,
+            min_workers: @min_workers,
+            max_workers: @max_workers,
+            queue_size: @queue.size
+          })
+        end
+      end
+
+      private
+
+      def create_worker
+        @worker_counter += 1
+        worker = Worker.new(@worker_counter, @config, @engine, @transaction_manager)
+        worker.start
+        @workers << worker
+        @stats[:workers_created] += 1
+        @stats[:total_workers] = @workers.size
+        worker
+      end
+
+      def destroy_worker(worker)
+        worker.stop
+        @workers.delete(worker)
+        @stats[:workers_destroyed] += 1
+        @stats[:total_workers] = @workers.size
+      end
+
+      def find_idle_worker
+        @workers.find { |w| !w.busy? }
+      end
+
+      def scaling_loop
+        while @running
+          sleep(5)
+
+          @lock.synchronize do
+            # Scale up if queue is growing
+            if @queue.size > @workers.size * 2 && @workers.size < @max_workers
+              create_worker
+            end
+
+            # Scale down if queue is empty and we have extra workers
+            if @queue.empty? && @workers.size > @min_workers
+              idle_workers = @workers.select { |w| !w.busy? }
+              if idle_workers.size > 1
+                destroy_worker(idle_workers.first)
+              end
+            end
+          end
+        end
+      end
+
+      def cleanup_loop
+        while @running
+          sleep(60)
+
+          @lock.synchronize do
+            # Remove dead workers
+            @workers.reject! { |w| !w.running? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # ALTER TABLE statement AST node (base)
+      class AlterTable < Node
+        attr_reader :table_name
+
+        def initialize(table_name, location: nil)
+          super(location: location)
+          @table_name = table_name
+        end
+
+        def to_sql
+          "ALTER TABLE #{@table_name}"
+        end
+
+        def inspect
+          "AlterTable(table: #{@table_name})"
+        end
+      end
+
+      # ALTER TABLE ADD COLUMN
+      class AlterTableAddColumn < AlterTable
+        attr_reader :column_name, :column_type, :options
+
+        def initialize(table_name, column_name, column_type, options = {}, location: nil)
+          super(table_name, location: location)
+          @column_name = column_name
+          @column_type = column_type
+          @options = options
+        end
+
+        def accept(visitor)
+          visitor.visit_alter_table_add_column(self)
+        end
+
+        def clone
+          AlterTableAddColumn.new(
+            @table_name,
+            @column_name,
+            @column_type.is_a?(Hash) ? @column_type.dup : @column_type,
+            @options.dup,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = [super]
+          parts << "ADD"
+          parts << @column_name
+          parts << type_sql
+          parts << "NOT NULL" if @options[:null] == false
+          parts << "NULL" if @options[:null] == true
+          parts << "DEFAULT #{@options[:default].to_sql}" if @options[:default]
+          if @options[:references]
+            ref = @options[:references]
+            parts << "REFERENCES #{ref[:table]}(#{ref[:column]})"
+          end
+          parts.join(" ")
+        end
+
+        def inspect
+          "AlterTableAddColumn(table: #{@table_name}, column: #{@column_name}, type: #{type_sql}, options: #{@options.inspect})"
+        end
+
+        def type_sql
+          case @column_type
+          when Symbol
+            @column_type.to_s.upcase
+          when Hash
+            if @column_type[:type] == :decimal
+              "DECIMAL(#{@column_type[:precision]}, #{@column_type[:scale]})"
+            elsif @column_type[:type] == :varchar
+              "VARCHAR(#{@column_type[:limit]})"
+            else
+              @column_type[:type].to_s.upcase
+            end
+          else
+            @column_type.to_s
+          end
+        end
+      end
+
+      # ALTER TABLE DROP COLUMN
+      class AlterTableDropColumn < AlterTable
+        attr_reader :column_name
+
+        def initialize(table_name, column_name, location: nil)
+          super(table_name, location: location)
+          @column_name = column_name
+        end
+
+        def accept(visitor)
+          visitor.visit_alter_table_drop_column(self)
+        end
+
+        def clone
+          AlterTableDropColumn.new(@table_name, @column_name, location: @location)
+        end
+
+        def to_sql
+          "#{super} DROP COLUMN #{@column_name}"
+        end
+
+        def inspect
+          "AlterTableDropColumn(table: #{@table_name}, column: #{@column_name})"
+        end
+      end
+
+      # ALTER TABLE ADD CONSTRAINT
+      class AlterTableAddConstraint < AlterTable
+        attr_reader :constraint
+
+        def initialize(table_name, constraint, location: nil)
+          super(table_name, location: location)
+          @constraint = constraint
+        end
+
+        def accept(visitor)
+          visitor.visit_alter_table_add_constraint(self)
+        end
+
+        def clone
+          AlterTableAddConstraint.new(
+            @table_name,
+            @constraint.clone,
+            location: @location
+          )
+        end
+
+        def to_sql
+          "#{super} ADD #{@constraint.to_sql}"
+        end
+
+        def inspect
+          "AlterTableAddConstraint(table: #{@table_name}, constraint: #{@constraint.inspect})"
+        end
+      end
+
+      # ALTER TABLE DROP CONSTRAINT
+      class AlterTableDropConstraint < AlterTable
+        attr_reader :constraint_name
+
+        def initialize(table_name, constraint_name, location: nil)
+          super(table_name, location: location)
+          @constraint_name = constraint_name
+        end
+
+        def accept(visitor)
+          visitor.visit_alter_table_drop_constraint(self)
+        end
+
+        def clone
+          AlterTableDropConstraint.new(@table_name, @constraint_name, location: @location)
+        end
+
+        def to_sql
+          "#{super} DROP CONSTRAINT #{@constraint_name}"
+        end
+
+        def inspect
+          "AlterTableDropConstraint(table: #{@table_name}, constraint: #{@constraint_name})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # BEGIN TRANSACTION statement AST node
+      class BeginTransaction < Node
+        attr_reader :isolation_level, :read_only
+
+        def initialize(isolation_level: nil, read_only: false, location: nil)
+          super(location: location)
+          @isolation_level = isolation_level
+          @read_only = read_only
+        end
+
+        def accept(visitor)
+          visitor.visit_begin_transaction(self)
+        end
+
+        def clone
+          BeginTransaction.new(
+            isolation_level: @isolation_level,
+            read_only: @read_only,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = ["BEGIN"]
+          if @isolation_level
+            parts << "ISOLATION LEVEL"
+            parts << @isolation_level.to_s.upcase
+          end
+          parts << "READ ONLY" if @read_only
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "BeginTransaction"
+          str << " (isolation_level: #{@isolation_level})" if @isolation_level
+          str << " (read_only: true)" if @read_only
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # COMMIT statement AST node
+      class Commit < Node
+        attr_reader :chain
+
+        def initialize(chain: false, location: nil)
+          super(location: location)
+          @chain = chain
+        end
+
+        def accept(visitor)
+          visitor.visit_commit(self)
+        end
+
+        def clone
+          Commit.new(chain: @chain, location: @location)
+        end
+
+        def to_sql
+          parts = ["COMMIT"]
+          parts << "AND CHAIN" if @chain
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "Commit"
+          str << " (chain: true)" if @chain
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      class ConstraintDefinition < Node
+        attr_reader :name
+
+        def initialize(name, location: nil)
+          super(location: location)
+          @name = name
+        end
+
+        def accept(visitor)
+          visitor.public_send("visit_#{constraint_visit_name}", self)
+        end
+
+        def clone
+          self.class.new(@name, location: @location)
+        end
+
+        private
+
+        def constraint_visit_name
+          self.class.name.split("::").last.gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase
+        end
+      end
+
+      class PrimaryKeyConstraint < ConstraintDefinition
+        attr_reader :columns
+        def initialize(name, columns, location: nil)
+          super(name, location: location)
+          @columns = Array(columns)
+        end
+        def clone = self.class.new(@name, @columns.dup, location: @location)
+        def to_sql = "CONSTRAINT #{@name} PRIMARY KEY (#{@columns.join(', ')})"
+      end
+
+      class ForeignKeyConstraint < ConstraintDefinition
+        attr_reader :columns, :reference_table, :reference_columns, :on_delete, :on_update
+        def initialize(name, columns, reference_table, reference_columns, on_delete: nil, on_update: nil, location: nil)
+          super(name, location: location)
+          @columns = Array(columns)
+          @reference_table = reference_table
+          @reference_columns = Array(reference_columns)
+          @on_delete = on_delete
+          @on_update = on_update
+        end
+        def clone = self.class.new(@name, @columns.dup, @reference_table, @reference_columns.dup, on_delete: @on_delete, on_update: @on_update, location: @location)
+        def to_sql
+          sql = "CONSTRAINT #{@name} FOREIGN KEY (#{@columns.join(', ')}) REFERENCES #{@reference_table} (#{@reference_columns.join(', ')})"
+          sql << " ON DELETE #{@on_delete.to_s.upcase.tr('_', ' ')}" if @on_delete
+          sql << " ON UPDATE #{@on_update.to_s.upcase.tr('_', ' ')}" if @on_update
+          sql
+        end
+      end
+
+      class UniqueConstraint < ConstraintDefinition
+        attr_reader :columns
+        def initialize(name, columns, location: nil)
+          super(name, location: location)
+          @columns = Array(columns)
+        end
+        def clone = self.class.new(@name, @columns.dup, location: @location)
+        def to_sql = "CONSTRAINT #{@name} UNIQUE (#{@columns.join(', ')})"
+      end
+
+      class CheckConstraint < ConstraintDefinition
+        attr_reader :condition
+        def initialize(name, condition, location: nil)
+          super(name, location: location)
+          @condition = condition
+        end
+        def accept(visitor)
+          super
+          @condition.accept(visitor) if @condition.respond_to?(:accept)
+        end
+        def clone = self.class.new(@name, @condition.clone, location: @location)
+        def to_sql = "CONSTRAINT #{@name} CHECK (#{@condition.to_sql})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # CREATE DATABASE statement AST node
+      class CreateDatabase < Node
+        attr_reader :name, :if_not_exists
+
+        def initialize(name, if_not_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @if_not_exists = if_not_exists
+        end
+
+        def accept(visitor)
+          visitor.visit_create_database(self)
+        end
+
+        def clone
+          CreateDatabase.new(@name, if_not_exists: @if_not_exists, location: @location)
+        end
+
+        def to_sql
+          parts = []
+          parts << "CREATE DATABASE"
+          parts << "IF NOT EXISTS" if @if_not_exists
+          parts << @name
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "CreateDatabase(name: #{@name}"
+          str << ", if_not_exists: true" if @if_not_exists
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # CREATE INDEX statement AST node
+      class CreateIndex < Node
+        attr_reader :name, :table_name, :columns, :unique, :if_not_exists
+
+        def initialize(name, table_name, columns, unique: false, if_not_exists: false, location: nil)
+          super(location: location)
+          @name = name
+          @table_name = table_name
+          @columns = columns
+          @unique = unique
+          @if_not_exists = if_not_exists
+        end
+
+        def accept(visitor)
+          visitor.visit_create_index(self)
+        end
+
+        def clone
+          CreateIndex.new(
+            @name,
+            @table_name,
+            @columns.dup,
+            unique: @unique,
+            if_not_exists: @if_not_exists,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "CREATE"
+          parts << "UNIQUE" if @unique
+          parts << "INDEX"
+          parts << "IF NOT EXISTS" if @if_not_exists
+          parts << @name
+          parts << "ON"
+          parts << @table_name
+          parts << "(#{@columns.join(", ")})"
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "CreateIndex(name: #{@name}, table: #{@table_name}, columns: [#{@columns.join(", ")}]"
+          str << ", unique: true" if @unique
+          str << ", if_not_exists: true" if @if_not_exists
+          str << ")"
+          str
+        end
+
+        def column_count
+          @columns.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module SQL
+    module AST
+      # CREATE SCHEMA statement AST node
+      class CreateSchema < Node
+        attr_reader :name, :if_not_exists, :authorization
+
+        def initialize(name, if_not_exists: false, authorization: nil, location: nil)
+          super(location: location)
+          @name = name
+          @if_not_exists = if_not_exists
+          @authorization = authorization
+        end
+
+        def accept(visitor)
+          visitor.visit_create_schema(self)
+        end
+
+        def clone
+          CreateSchema.new(
+            @name,
+            if_not_exists: @if_not_exists,
+            authorization: @authorization,
+            location: @location
+          )
+        end
+
+        def to_sql
+          parts = []
+          parts << "CREATE SCHEMA"
+          parts << "IF NOT EXISTS" if @if_not_exists
+          parts << @name
+          if @authorization
+            parts << "AUTHORIZATION"
+            parts << @authorization
+          end
+          parts.join(" ")
+        end
+
+        def inspect
+          str = "CreateSchema(name: #{@name}"
+          str << ", if_not_exists: true" if @if_not_exists
+          str << ", authorization: #{@authorization}" if @authorization
+          str << ")"
+          str
+        end
+      end
+    end
+  end
+end