rubydb 0.1.0

data/lib/rubydb/protocol/protocol.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "monitor"
+require_relative "message"
+require_relative "encoder"
+require_relative "decoder"
+require_relative "version"
+require_relative "capabilities"
+require_relative "handshake"
+
+module RubyDB
+  module Protocol
+    class Protocol
+      attr_reader :encoder, :decoder, :handshake, :capabilities, :stats
+
+      def initialize(options = {})
+        @options = options
+        @encoder = Encoder.new(options[:format] || Encoder::FORMAT_JSON, options)
+        @decoder = Decoder.new(options)
+        @handshake = Handshake.new(options[:server_info])
+        @capabilities = Capabilities.default_server
+        @buffer = ""
+        @chunk_size = options[:chunk_size] || 4096
+        @socket = nil
+        @connected = false
+        @authenticated = false
+        @stats = {
+          messages_sent: 0,
+          messages_received: 0,
+          bytes_sent: 0,
+          bytes_received: 0,
+          errors: 0,
+          reconnects: 0,
+          connection_time: 0
+        }
+        @lock = Monitor.new
+        @read_timeout = options[:read_timeout] || 30
+        @write_timeout = options[:write_timeout] || 30
+      end
+
+      def connect(host, port)
+        @lock.synchronize do
+          start_time = Time.now
+
+          begin
+            @socket = TCPSocket.new(host, port)
+            @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+            if @read_timeout
+              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [@read_timeout, 0].pack("l_2"))
+            end
+
+            if @write_timeout
+              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, [@write_timeout, 0].pack("l_2"))
+            end
+
+            @connected = true
+            @stats[:connection_time] = (Time.now - start_time) * 1000
+
+            # Perform handshake
+            perform_handshake
+
+            true
+
+          rescue => e
+            @stats[:errors] += 1
+            @connected = false
+            raise ProtocolError, "Connection failed: #{e.message}"
+          end
+        end
+      end
+
+      def disconnect
+        @lock.synchronize do
+          if @socket
+            begin
+              send_message(Message.new(Message::TYPE_TERMINATE))
+            rescue
+              # Ignore errors on disconnect
+            end
+            @socket.close
+          end
+
+          @socket = nil
+          @connected = false
+          @authenticated = false
+          true
+        end
+      end
+
+      def send_message(message)
+        @lock.synchronize do
+          raise ProtocolError, "Not connected" unless @connected
+
+          begin
+            data = @encoder.encode(message)
+            @socket.write(data)
+            @socket.flush
+
+            @stats[:messages_sent] += 1
+            @stats[:bytes_sent] += data.bytesize
+
+            true
+          rescue => e
+            @stats[:errors] += 1
+            raise ProtocolError, "Send failed: #{e.message}"
+          end
+        end
+      end
+
+      def receive_message(timeout = @read_timeout)
+        @lock.synchronize do
+          raise ProtocolError, "Not connected" unless @connected
+
+          begin
+            Timeout.timeout(timeout) do
+              data = read_data
+              @stats[:bytes_received] += data.bytesize
+              @stats[:messages_received] += 1
+
+              @decoder.decode(data, @encoder.format)
+            end
+          rescue Timeout::Error
+            @stats[:errors] += 1
+            raise ProtocolError, "Receive timeout"
+          rescue => e
+            @stats[:errors] += 1
+            raise ProtocolError, "Receive failed: #{e.message}"
+          end
+        end
+      end
+
+      def query(sql, params = [])
+        message = Message.new(Message::TYPE_QUERY, { sql: sql, params: params })
+        send_message(message)
+        receive_message
+      end
+
+      def prepare(sql)
+        message = Message.new(Message::TYPE_PREPARE, { sql: sql })
+        send_message(message)
+        receive_message
+      end
+
+      def execute(statement_id, params = [])
+        message = Message.new(Message::TYPE_EXECUTE, { statement_id: statement_id, params: params })
+        send_message(message)
+        receive_message
+      end
+
+      def close_statement(statement_id)
+        message = Message.new(Message::TYPE_CLOSE, { statement_id: statement_id })
+        send_message(message)
+        receive_message
+      end
+
+      def begin_transaction
+        message = Message.new(Message::TYPE_BEGIN)
+        send_message(message)
+        receive_message
+      end
+
+      def commit
+        message = Message.new(Message::TYPE_COMMIT)
+        send_message(message)
+        receive_message
+      end
+
+      def rollback
+        message = Message.new(Message::TYPE_ROLLBACK)
+        send_message(message)
+        receive_message
+      end
+
+      def ping
+        message = Message.new(Message::TYPE_PING)
+        send_message(message)
+        receive_message
+      end
+
+      def connected?
+        @connected && @socket && !@socket.closed?
+      end
+
+      def authenticated?
+        @authenticated
+      end
+
+      def reconnect(host, port)
+        @lock.synchronize do
+          disconnect
+          connect(host, port)
+          @stats[:reconnects] += 1
+          true
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            connected: @connected,
+            authenticated: @authenticated,
+            handshake_state: @handshake.state,
+            buffer_size: @buffer.bytesize,
+            socket_info: @socket ? "#{@socket.peeraddr[2]}:#{@socket.peeraddr[1]}" : nil
+          })
+        end
+      end
+
+      private
+
+      def read_data
+        @socket.gets || ""
+      end
+
+      def perform_handshake
+        # Send handshake request
+        handshake_msg = Message.new(
+          Message::TYPE_HANDSHAKE,
+          {
+            protocol_version: ProtocolVersion.current,
+            client_name: "RubyDB Client",
+            client_version: RubyDB::VERSION
+          }
+        )
+
+        send_message(handshake_msg)
+        response = receive_message
+
+        if response.type == Message::TYPE_HANDSHAKE_RESPONSE
+          handshake_data = response.payload
+
+          if handshake_data[:success]
+            # Send authentication response
+            auth_msg = Message.new(
+              Message::TYPE_AUTHENTICATION_RESPONSE,
+              {
+                username: @options[:username] || "rubydb",
+                password: @options[:password] || "",
+                auth_method: @options[:auth_method] || "none"
+              }
+            )
+
+            send_message(auth_msg)
+            auth_response = receive_message
+
+            if auth_response.type == Message::TYPE_AUTHENTICATION
+              @authenticated = true
+              @handshake.state = Handshake::STATE_AUTHENTICATED
+
+              # Negotiate capabilities
+              caps_msg = Message.new(
+                Message::TYPE_SYNCHRONIZE,
+                {
+                  capabilities: Capabilities.default_client.to_hash
+                }
+              )
+
+              send_message(caps_msg)
+              caps_response = receive_message
+
+              if caps_response.type == Message::TYPE_READY_FOR_QUERY
+                @handshake.state = Handshake::STATE_COMPLETE
+                @capabilities.negotiate(caps_response.payload[:capabilities] || 0)
+                @authenticated = true
+              end
+            end
+          else
+            raise ProtocolError, "Handshake failed: #{handshake_data[:error]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/protocol/version.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Protocol
+    # ProtocolVersion - Defines protocol versions and compatibility
+    class ProtocolVersion
+      MAJOR = 1
+      MINOR = 0
+      PATCH = 0
+
+      VERSION_STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+      VERSION_INT = (MAJOR << 16) | (MINOR << 8) | PATCH
+
+      # Supported protocol versions
+      SUPPORTED_VERSIONS = {
+        0x010000 => "1.0.0",
+        0x010001 => "1.0.1"
+      }
+
+      def self.current
+        VERSION_INT
+      end
+
+      def self.current_string
+        VERSION_STRING
+      end
+
+      def self.supported?(version)
+        SUPPORTED_VERSIONS.key?(version)
+      end
+
+      def self.parse(version_string)
+        parts = version_string.split(".").map(&:to_i)
+        return nil if parts.size != 3
+        (parts[0] << 16) | (parts[1] << 8) | parts[2]
+      end
+
+      def self.to_string(version_int)
+        major = (version_int >> 16) & 0xFF
+        minor = (version_int >> 8) & 0xFF
+        patch = version_int & 0xFF
+        "#{major}.#{minor}.#{patch}"
+      end
+
+      def self.compatible?(client_version, server_version)
+        # Major version must match
+        return false if (client_version >> 16) != (server_version >> 16)
+        # Minor version: server must support client's minor version
+        return false if (client_version & 0xFF00) > (server_version & 0xFF00)
+        true
+      end
+    end
+  end
+end

data/lib/rubydb/rails/adapter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+require_relative "database_statements"
+require_relative "schema_statements"
+require_relative "quoting"
+require_relative "type"
+require_relative "transaction"
+require_relative "migration"
+require_relative "result"
+
+module RubyDB
+  module Rails
+    # Adapter - Rails database adapter
+    class Adapter
+      attr_reader :config, :connection, :engine, :logger
+
+      include DatabaseStatements
+      include SchemaStatements
+      include Quoting
+
+      ADAPTER_NAME = "RubyDB"
+
+      def initialize(config)
+        @config = config
+        @engine = config[:engine]
+        @logger = config[:logger]
+        @connection = Connection.new(config)
+        @connection.connect
+        @pool = nil
+        @statements = {}
+        @statement_counter = 0
+        @prepared_statements = {}
+        @transaction = nil
+        @lock = Mutex.new
+      end
+
+      def self.new(config)
+        adapter = allocate
+        adapter.send(:initialize, config)
+        adapter
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def supports_index_sort_order?
+        true
+      end
+
+      def supports_transactions?
+        true
+      end
+
+      def supports_savepoints?
+        true
+      end
+
+      def supports_foreign_keys?
+        true
+      end
+
+      def supports_views?
+        true
+      end
+
+      def supports_json?
+        true
+      end
+
+      def supports_uuid?
+        true
+      end
+
+      def primary_key(table_name)
+        column = columns(table_name).find { |entry| entry[:primary_key] }
+        column ? column[:name] : "id"
+      end
+
+      def tables
+        metadata_engine.list_tables.map(&:to_s)
+      end
+
+      def table_exists?(table_name)
+        tables.include?(table_name)
+      end
+
+      def indexes(table_name)
+        manager = metadata_engine.index_manager
+        manager.get_indexes_for_table(table_name).map do |index|
+          {
+            name: index.name.to_s,
+            columns: index.columns.map(&:to_s),
+            unique: index.unique
+          }
+        end
+      end
+
+      def columns(table_name)
+        metadata_engine.table_columns(table_name).map do |column|
+          {
+            name: column.name.to_s,
+            type: column.type,
+            default: normalize_catalog_default(column.default),
+            null: column.nullable?,
+            primary_key: column.primary_key?
+          }
+        end
+      end
+
+      def column_exists?(table_name, column_name)
+        columns(table_name).any? { |c| c[:name] == column_name }
+      end
+
+      def schema_version
+        return nil unless table_exists?("schema_migrations")
+
+        result = execute("SELECT version FROM schema_migrations ORDER BY version DESC LIMIT 1")
+        result.first && (result.first["version"] || result.first[:version])
+      end
+
+      def dump_schema
+        schema = +""
+
+        tables.each do |table|
+          table_columns = columns(table)
+          primary_key = table_columns.find { |col| col[:primary_key] }
+          automatic_id = @engine && primary_key && primary_key[:name].to_s == "id" && primary_key[:type].to_sym == :integer
+          table_options = automatic_id ? "" : ", id: false"
+          schema << "create_table \"#{table}\"#{table_options} do |t|\n"
+          table_columns.each do |col|
+            next if automatic_id && col[:primary_key]
+
+            type = Type.to_rails(col[:type])
+            schema << "  t.#{type} \"#{col[:name]}\""
+            schema << ", primary_key: true" if col[:primary_key]
+            schema << ", default: #{schema_literal(col[:default])}" if col.key?(:default) && !col[:default].nil?
+            schema << ", null: false" unless col[:null]
+            schema << "\n"
+          end
+          schema << "end\n\n"
+
+          # Schema dumps can be generated from an adapter double or a
+          # connection-only configuration where catalog introspection is not
+          # available. In a live embedded adapter, always use the real index
+          # catalog; otherwise preserve the column-only dump contract.
+          table_indexes = @engine ? indexes(table) : []
+          table_indexes.each do |index|
+            schema << "add_index \"#{table}\", #{index[:columns].map(&:to_s).inspect}"
+            schema << ", unique: true" if index[:unique]
+            schema << ", name: #{index[:name].to_s.inspect}"
+            schema << "\n"
+          end
+          schema << "\n" if table_indexes.any?
+        end
+
+        schema
+      end
+
+      def reconnect!
+        @connection.disconnect
+        @connection.connect
+      end
+
+      def disconnect!
+        @connection.disconnect
+      end
+
+      def reset!
+        reconnect!
+        @statements.clear
+        @prepared_statements.clear
+      end
+
+      def close
+        @connection.disconnect
+      end
+
+      def active?
+        @connection.connected?
+      end
+
+      def stats
+        @connection.stats
+      end
+
+      private
+
+      def metadata_engine
+        return @engine if @engine
+
+        raise ConnectionError, "RubyDB catalog introspection requires an embedded :engine"
+      end
+
+      def normalize_catalog_default(value)
+        value.respond_to?(:value) ? value.value : value
+      end
+
+      def parse_index_columns(sql)
+        if sql =~ /\(([^)]+)\)/
+          $1.split(",").map(&:strip)
+        else
+          []
+        end
+      end
+
+      def schema_literal(value)
+        case value
+        when true then @engine ? "true" : (respond_to?(:quote) ? quote(value) : "true")
+        when false then @engine ? "false" : (respond_to?(:quote) ? quote(value) : "false")
+        when nil then "nil"
+        when Numeric then value.to_s
+        else value.to_s.inspect
+        end
+      end
+
+      def log(sql, name = nil, &block)
+        start_time = Time.now
+        result = block.call
+        elapsed_ms = (Time.now - start_time) * 1000
+
+        if @logger
+          @logger.debug "  #{name || 'SQL'} (#{elapsed_ms.round(2)}ms) #{sql}"
+        end
+
+        result
+      end
+    end
+  end
+end