rubydb 0.1.4 → 0.1.6

data/lib/rubydb/server/worker_pool.rb

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

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