rubydb 0.1.0

data/lib/rubydb/client/connection_pool.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Client
+    # ConnectionPool - Manages client connections
+    class ConnectionPool
+      attr_reader :config, :stats
+
+      def initialize(config = {})
+        @config = config
+        @pool_size = config[:pool_size] || 5
+        @connections = []
+        @available = []
+        @stats = {
+          total_connections: 0,
+          active_connections: 0,
+          idle_connections: 0,
+          borrowed_count: 0,
+          returned_count: 0,
+          created_count: 0,
+          destroyed_count: 0,
+          wait_count: 0,
+          timeout_count: 0
+        }
+        @lock = Mutex.new
+        @condition = ConditionVariable.new
+        @initialized = false
+        @shutdown = false
+
+        # Pre-create only when auto-connect is requested. A disabled
+        # auto-connect pool remains lazy and creates connections on borrow.
+        initialize_pool if config.fetch(:auto_connect, true)
+      end
+
+      def get_connection(timeout = @config[:timeout] || 30)
+        @lock.synchronize do
+          @stats[:borrowed_count] += 1
+
+          start_time = Time.now
+
+          while true
+            # Check if there are available connections
+            unless @available.empty?
+              conn = @available.pop
+              if conn && conn.connected?
+                @stats[:active_connections] += 1
+                return conn
+              else
+                # Remove dead connection
+                remove_connection(conn) if conn
+              end
+            end
+
+            # Check if we can create a new connection
+            if @connections.size < @pool_size
+              conn = create_connection
+              @stats[:active_connections] += 1
+              return conn
+            end
+
+            # Wait for a connection to become available
+            if Time.now - start_time > timeout
+              @stats[:timeout_count] += 1
+              raise ClientError, "Connection pool timeout: no connections available"
+            end
+
+            @stats[:wait_count] += 1
+            @condition.wait(@lock, 0.1)
+          end
+        end
+      end
+
+      def release_connection(connection)
+        @lock.synchronize do
+          return unless connection
+
+          @stats[:returned_count] += 1
+          @stats[:active_connections] -= 1
+
+          if connection.connected?
+            @available << connection
+            @condition.signal
+          else
+            remove_connection(connection)
+          end
+        end
+      end
+
+      def close_all
+        @lock.synchronize do
+          @shutdown = true
+
+          @connections.each do |conn|
+            conn.disconnect if conn.connected?
+          end
+
+          @connections.clear
+          @available.clear
+
+          @stats[:active_connections] = 0
+          @stats[:idle_connections] = 0
+        end
+      end
+
+      def active_count
+        @stats[:active_connections]
+      end
+
+      def idle_count
+        @available.size
+      end
+
+      def total_count
+        @connections.size
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            pool_size: @pool_size,
+            total: total_count,
+            active: active_count,
+            idle: idle_count,
+            available: @available.size,
+            shutdown: @shutdown
+          })
+        end
+      end
+
+      private
+
+      def initialize_pool
+        @lock.synchronize do
+          return if @initialized
+
+          # Create initial connections
+          @pool_size.times do
+            conn = create_connection
+            @available << conn
+          end
+
+          @initialized = true
+        end
+      end
+
+      def create_connection
+        conn = Connection.new(@config)
+        conn.connect
+        @connections << conn
+        @stats[:total_connections] += 1
+        @stats[:created_count] += 1
+        conn
+      rescue => e
+        raise ClientError, "Failed to create connection: #{e.message}"
+      end
+
+      def remove_connection(connection)
+        return unless connection
+
+        connection.disconnect if connection.connected?
+        @connections.delete(connection)
+        @available.delete(connection)
+        @stats[:total_connections] -= 1
+        @stats[:destroyed_count] += 1
+      end
+    end
+  end
+end

data/lib/rubydb/client/connection_url.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module RubyDB
+  module Client
+    # Parses RubyDB's own connection URL format. This is deliberately not a
+    # PostgreSQL URL parser: RubyDB speaks its framed RubyDB protocol.
+    module ConnectionURL
+      SUPPORTED_SCHEMES = %w[rubydb rubydbs].freeze
+
+      module_function
+
+      def parse(value)
+        raise ArgumentError, "RubyDB connection URL is required" if value.nil? || value.to_s.empty?
+
+        uri = URI.parse(value.to_s)
+        scheme = uri.scheme.to_s.downcase
+        raise ArgumentError, "Unsupported RubyDB connection URL scheme" unless SUPPORTED_SCHEMES.include?(scheme)
+        raise ArgumentError, "RubyDB connection URL requires a host" if uri.host.nil? || uri.host.empty?
+
+        database = uri.path.to_s.sub(%r{\A/}, "")
+        raise ArgumentError, "RubyDB connection URL requires a database name" if database.empty?
+
+        query = URI.decode_www_form(uri.query.to_s).to_h
+        ssl_mode = query["sslmode"]&.downcase
+        ssl_enabled = scheme == "rubydbs" || boolean(query["ssl"], false) || %w[require verify-ca verify-full].include?(ssl_mode)
+        verify_peer = if query.key?("verify_peer")
+          boolean(query["verify_peer"], true)
+        else
+          %w[verify-ca verify-full].include?(ssl_mode) || scheme == "rubydbs"
+        end
+
+        ssl = {enabled: true, verify_peer: verify_peer} if ssl_enabled
+        if ssl
+          ssl[:ca_file] = query["ca_file"] if query["ca_file"]
+          ssl[:cert_file] = query["cert_file"] if query["cert_file"]
+          ssl[:key_file] = query["key_file"] if query["key_file"]
+          ssl[:min_version] = query["min_version"] if query["min_version"]
+        end
+
+        result = {
+          host: uri.host,
+          port: uri.port || 7432,
+          username: decode(uri.user),
+          password: decode(uri.password),
+          database: URI.decode_www_form_component(database),
+          ssl: ssl || false
+        }
+        result[:timeout] = positive_number(query["timeout"], "timeout") if query["timeout"]
+        result[:pool_size] = positive_integer(query["pool_size"], "pool_size") if query["pool_size"]
+        result[:compress] = boolean(query["compress"], false) if query.key?("compress")
+        result[:format] = query["format"].to_sym if query["format"]
+        result.compact
+      rescue URI::InvalidURIError
+        raise ArgumentError, "Invalid RubyDB connection URL"
+      end
+
+      def decode(value)
+        value && URI.decode_www_form_component(value)
+      end
+      private_class_method :decode
+
+      def boolean(value, default)
+        return default if value.nil?
+
+        case value.to_s.downcase
+        when "1", "true", "yes", "on" then true
+        when "0", "false", "no", "off" then false
+        else raise ArgumentError, "Invalid boolean connection URL option"
+        end
+      end
+      private_class_method :boolean
+
+      def positive_integer(value, name)
+        number = Integer(value, 10)
+        raise ArgumentError, "#{name} must be positive" unless number.positive?
+
+        number
+      rescue ArgumentError
+        raise ArgumentError, "Invalid #{name} connection URL option"
+      end
+      private_class_method :positive_integer
+
+      def positive_number(value, name)
+        number = Float(value)
+        raise ArgumentError, "#{name} must be positive" unless number.positive?
+
+        number
+      rescue ArgumentError
+        raise ArgumentError, "Invalid #{name} connection URL option"
+      end
+      private_class_method :positive_number
+    end
+  end
+end

data/lib/rubydb/client/prepared_statement.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Client
+    # PreparedStatement - Prepared SQL statement
+    class PreparedStatement
+      attr_reader :id, :sql, :client, :params
+
+      def initialize(id, sql, client)
+        @id = id
+        @sql = sql
+        @client = client
+        @params = []
+        @param_count = sql.scan(/\$/).size
+        @created_at = Time.now
+        @closed = false
+        @lock = Mutex.new
+      end
+
+      def execute(params = [])
+        @lock.synchronize do
+          raise ClientError, "Statement is closed" if @closed
+          @params = params
+          @client.execute(@id, params)
+        end
+      end
+
+      def execute_batch(params_list)
+        @lock.synchronize do
+          raise ClientError, "Statement is closed" if @closed
+          results = []
+          params_list.each do |params|
+            results << @client.execute(@id, params)
+          end
+          results
+        end
+      end
+
+      def close
+        @lock.synchronize do
+          return if @closed
+          @client.close_statement(@id)
+          @closed = true
+        end
+      end
+
+      def closed?
+        @closed
+      end
+
+      def to_s
+        "#<PreparedStatement id=#{@id} sql=\"#{@sql[0..50]}#{'...' if @sql.length > 50}\">"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/rubydb/client/result.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Client
+    # Result - Query result set
+    class Result
+      attr_reader :columns, :rows, :row_count, :affected_rows, :sql
+      attr_reader :command_tag, :statement_id, :transaction_id
+      attr_reader :error
+
+      def initialize(data = {})
+        @columns = data[:columns] || []
+        @rows = data[:rows] || []
+        @row_count = data[:row_count] || @rows.size
+        @affected_rows = data[:affected_rows] || 0
+        @sql = data[:sql]
+        @command_tag = data[:command_tag] || "SELECT"
+        @statement_id = data[:statement_id]
+        @transaction_id = data[:transaction_id]
+        @success = data[:success] != false
+        @error = data[:error]
+        @warnings = data[:warnings] || []
+        @notice = data[:notice]
+        @execution_time_ms = data[:execution_time_ms] || 0
+        @created_at = Time.now
+        @position = 0
+      end
+
+      def success?
+        @success
+      end
+
+      def error?
+        !@success && !@error.nil?
+      end
+
+      def empty?
+        @rows.empty?
+      end
+
+      def first
+        @rows.first
+      end
+
+      def last
+        @rows.last
+      end
+
+      def [](index)
+        @rows[index]
+      end
+
+      def each
+        @rows.each { |row| yield row }
+      end
+
+      def each_with_index
+        @rows.each_with_index { |row, idx| yield row, idx }
+      end
+
+      def each_row
+        @rows.each { |row| yield row }
+      end
+
+      def each_column
+        @columns.each { |col| yield col }
+      end
+
+      def column_names
+        @columns.map { |c| c[:name] || c }
+      end
+
+      def column_types
+        @columns.map { |c| c[:type] || "text" }
+      end
+
+      def to_a
+        @rows
+      end
+
+      def to_hash
+        {
+          columns: @columns,
+          rows: @rows,
+          row_count: @row_count,
+          affected_rows: @affected_rows,
+          command_tag: @command_tag,
+          success: @success,
+          error: @error,
+          execution_time_ms: @execution_time_ms
+        }
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      def inspect
+        rows_preview = @rows.first(3).map(&:inspect).join(", ")
+        more = @rows.size > 3 ? "..." : ""
+        "#<Result rows=#{@row_count} columns=#{@columns.size} data=[#{rows_preview}#{more}]>"
+      end
+
+      def to_s
+        if @rows.empty?
+          "Result: #{@command_tag} (0 rows)"
+        else
+          "Result: #{@command_tag} (#{@row_count} rows)"
+        end
+      end
+
+      # Enumerable support
+      include Enumerable
+
+      def size
+        @row_count
+      end
+
+      alias length size
+      alias count size
+    end
+  end
+end

data/lib/rubydb/client/statement.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Client
+    # Statement - SQL statement
+    class Statement
+      attr_reader :sql, :params, :client, :result
+
+      def initialize(sql, client)
+        @sql = sql
+        @client = client
+        @result = nil
+        @executed = false
+        @params = []
+        @param_count = sql.scan(/\$/).size
+        @created_at = Time.now
+        @lock = Mutex.new
+      end
+
+      def execute(params = [])
+        @lock.synchronize do
+          @params = params
+          @result = @client.query(@sql, params)
+          @executed = true
+          @result
+        end
+      end
+
+      def execute_batch(params_list)
+        @lock.synchronize do
+          results = []
+          params_list.each do |params|
+            results << execute(params)
+          end
+          results
+        end
+      end
+
+      def executed?
+        @executed
+      end
+
+      def to_s
+        @sql
+      end
+
+      def inspect
+        "#<Statement sql=\"#{@sql[0..50]}#{'...' if @sql.length > 50}\">"
+      end
+    end
+  end
+end

data/lib/rubydb/client/transaction.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Client
+    # Transaction - Database transaction
+    class Transaction
+      attr_reader :id, :client, :started_at, :options
+
+      def initialize(client, options = {})
+        @client = client
+        @options = options
+        @id = "txn_#{Time.now.to_i}_#{rand(1000)}"
+        @started_at = Time.now
+        @active = true
+        @committed = false
+        @rolled_back = false
+        @savepoints = []
+        @lock = Mutex.new
+      end
+
+      def query(sql, params = [])
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          @client.query(sql, params)
+        end
+      end
+
+      def prepare(sql)
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          @client.prepare(sql)
+        end
+      end
+
+      def execute(statement_id, params = [])
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          @client.execute(statement_id, params)
+        end
+      end
+
+      def savepoint(name)
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          @savepoints << name
+          @client.query("SAVEPOINT #{name}")
+        end
+      end
+
+      def rollback_to_savepoint(name)
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          unless @savepoints.include?(name)
+            raise ClientError, "Savepoint '#{name}' not found"
+          end
+          @client.query("ROLLBACK TO SAVEPOINT #{name}")
+          @savepoints.delete(name)
+        end
+      end
+
+      def release_savepoint(name)
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+          unless @savepoints.include?(name)
+            raise ClientError, "Savepoint '#{name}' not found"
+          end
+          @client.query("RELEASE SAVEPOINT #{name}")
+          @savepoints.delete(name)
+        end
+      end
+
+      def commit
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+        end
+        @client.commit
+      end
+
+      def rollback
+        @lock.synchronize do
+          raise ClientError, "Transaction is not active" unless @active
+        end
+        @client.rollback
+      end
+
+      def active?
+        @active
+      end
+
+      def committed?
+        @committed
+      end
+
+      def rolled_back?
+        @rolled_back
+      end
+
+      # Used by Client#commit/#rollback after the wire request has completed.
+      def mark_committed
+        @lock.synchronize do
+          @active = false
+          @committed = true
+        end
+      end
+
+      def mark_rolled_back
+        @lock.synchronize do
+          @active = false
+          @rolled_back = true
+        end
+      end
+
+      def to_hash
+        {
+          id: @id,
+          started_at: @started_at.iso8601,
+          active: @active,
+          committed: @committed,
+          rolled_back: @rolled_back,
+          savepoints: @savepoints,
+          options: @options
+        }
+      end
+
+      def inspect
+        "#<Transaction id=#{@id} active=#{@active}>"
+      end
+    end
+  end
+end

data/lib/rubydb/concurrency/concurrency.rb

@@ -0,0 +1,19 @@
+# lib/rubydb/concurrency.rb
+# frozen_string_literal: true
+
+require "etc"
+
+# Main entry point for Concurrency module
+require_relative "concurrency/scheduler"
+require_relative "concurrency/latch"
+require_relative "concurrency/mutex"
+require_relative "concurrency/rw_lock"
+require_relative "concurrency/deadlock_detector"
+require_relative "concurrency/lock_graph"
+require_relative "concurrency/worker_pool"
+
+module RubyDB
+  module Concurrency
+    # All classes are now loaded
+  end
+end