rubydb 0.1.4 → 0.1.5

data/lib/rubydb/client/connection_pool.rb

@@ -1,168 +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
+# 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
+
+          loop do
+            # Check if there are available connections
+            unless @available.empty?
+              conn = @available.pop
+              if conn&.connected?
+                @stats[:active_connections] += 1
+                return conn
+              elsif conn
+                remove_connection(conn)
+              end
+              # Remove dead connection
+            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

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

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