sequel-postgres-pr 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4dd2fbfe50a8241149a3e1c152222cf432167b8a23ad8a2a64809df42592401
+  data.tar.gz: 41bdfefa0423a5d6effb320eb84efe033d3dac64e831d055805d00d8aacb79b3
+SHA512:
+  metadata.gz: 06ae1e4aec9e24c03cf157984ba11fc66ff38064687050ce04ba842390ec72a6a465ca20fc4ff64cd2fa3f2335654cdc72aa50220377d5a2b1d92d4d9e0ce36c
+  data.tar.gz: 4edf6e57f4fa8f65f3a39d53435189bf7645eae80f64dbd232e45720002de3152d827092c529754b9ee7e36177761f9543891dcc40499bf8f90e63fabe185514

data/README

@@ -0,0 +1,17 @@
+= sequel-postgres-pr
+
+This is a library to access PostgreSQL from pure Ruby, without any C library,
+with the goal of proper functioning with Sequel's postgres adapter.
+
+The only supported PostgreSQL authentication methods are password and md5. SSL
+is not supported. COPY and LISTEN are not supported.
+
+This requires Sequel 5.59.0.  For older versions of Sequel, please use the
+jeremyevans-postgres-pr gem.
+
+== Author and Copyright
+
+Copyright (c) 2005, 2008 by Michael Neumann (mneumann@ntecs.de)
+Copyright (c) 2009-2022 by Jeremy Evans (code@jeremyevans.net)
+
+Released under the same terms of license as Ruby.

data/lib/postgres-pr/buffer.rb

@@ -0,0 +1,132 @@
+# Fixed size buffer.
+class PostgresPR::Buffer
+
+  class Error < RuntimeError; end
+  class EOF < Error; end 
+
+  def self.of_size(size)
+    raise ArgumentError if size < 0
+    new('#' * size)
+  end 
+
+  def initialize(content)
+    @size = content.size
+    @content = content
+    @position = 0
+  end
+
+  def size
+    @size
+  end
+
+  def position
+    @position
+  end
+
+  def position=(new_pos)
+    raise ArgumentError if new_pos < 0 or new_pos > @size
+    @position = new_pos
+  end
+
+  def at_end?
+    @position == @size
+  end
+
+  def content
+    @content
+  end
+
+  def read(n)
+    raise EOF, 'cannot read beyond the end of buffer' if @position + n > @size
+    str = @content[@position, n]
+    @position += n
+    str
+  end
+
+  def write(str)
+    sz = str.size
+    raise EOF, 'cannot write beyond the end of buffer' if @position + sz > @size
+    @content[@position, sz] = str
+    @position += sz
+    self
+  end
+
+  def copy_from_stream(stream, n)
+    raise ArgumentError if n < 0
+    while n > 0
+      str = stream.read(n) 
+      write(str)
+      n -= str.size
+    end
+    raise if n < 0 
+  end
+
+  NUL = "\000"
+
+  def write_cstring(cstr)
+    raise ArgumentError, "Invalid Ruby/cstring" if cstr.include?(NUL)
+    write(cstr)
+    write(NUL)
+  end
+
+  # returns a Ruby string without the trailing NUL character
+  def read_cstring
+    nul_pos = @content.index(NUL, @position)
+    raise Error, "no cstring found!" unless nul_pos
+
+    sz = nul_pos - @position
+    str = @content[@position, sz]
+    @position += sz + 1
+    return str
+  end
+
+  IS_BIG_ENDIAN = [0x12345678].pack("L") == "\x12\x34\x56\x78"
+  private_constant :IS_BIG_ENDIAN
+
+  def read_byte
+    ru(1, 'C')
+  end
+
+  def read_int16
+    ru_swap(2, 's') 
+  end
+
+  def read_int32
+    ru_swap(4, 'l') 
+  end
+
+  def write_byte(val)
+    pw(val, 'C')
+  end
+
+  def write_int32(val)
+    pw(val, 'N')
+  end
+
+  private
+
+  def pw(val, template)
+    write([val].pack(template))
+  end
+
+  # shortcut method for readn+unpack
+  def ru(size, template)
+    read(size).unpack(template).first
+  end
+
+  if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+    # :nocov:
+    # Big Endian
+    def ru_swap(size, template)
+      read(size).unpack(template).first
+    end
+    # :nocov:
+  else
+    # Little Endian
+    def ru_swap(size, template)
+      str = read(size)
+      str.reverse!
+      str.unpack(template).first
+    end
+  end
+end

data/lib/postgres-pr/connection.rb

@@ -0,0 +1,161 @@
+#
+# Author:: Michael Neumann
+# Copyright:: (c) 2005 by Michael Neumann
+# License:: Same as Ruby's or BSD
+#
+
+require 'socket'
+
+module PostgresPR
+  class Connection
+    CONNECTION_OK = -1
+
+    class << self
+      alias connect new
+    end
+
+    # Returns one of the following statuses:
+    #
+    #   PQTRANS_IDLE    = 0 (connection idle)
+    #   PQTRANS_INTRANS = 2 (idle, within transaction block)
+    #   PQTRANS_INERROR = 3 (idle, within failed transaction)
+    #   PQTRANS_UNKNOWN = 4 (cannot determine status)
+    #
+    # Not yet implemented is:
+    #
+    #   PQTRANS_ACTIVE  = 1 (command in progress)
+    #
+    def transaction_status
+      case @transaction_status
+      when 73 # I
+        0
+      when 84 # T
+        2
+      when 69 # E
+        3
+      else
+        4
+      end
+    end
+
+    def initialize(host, port, _, _, database, user, password)
+      @conn = _connection(host, port)
+      @transaction_status = nil
+      @params = {}
+    
+      @conn << StartupMessage.new('user' => user, 'database' => database).dump
+
+      while true
+        msg = Message.read(@conn)
+
+        case msg
+        when AuthentificationClearTextPassword
+          check_password!(password)
+          @conn << PasswordMessage.new(password).dump
+        when AuthentificationMD5Password
+          check_password!(password)
+          require 'digest/md5'
+          @conn << PasswordMessage.new("md5#{Digest::MD5.hexdigest(Digest::MD5.hexdigest(password + user) << msg.salt)}").dump
+        when ErrorResponse
+          raise PGError, msg.field_values.join("\t")
+        when ReadyForQuery
+          @transaction_status = msg.backend_transaction_status_indicator
+          break
+        when AuthentificationOk, NoticeResponse, ParameterStatus, BackendKeyData
+          # ignore
+        when UnknownAuthType
+          raise PGError, "unhandled authentication type: #{msg.auth_type}"
+        else
+          raise PGError, "unhandled message type"
+        end
+      end
+    end
+
+    def finish
+      check_connection_open!
+      @conn.shutdown
+      @conn = nil
+    end
+
+    def async_exec(sql)
+      check_connection_open!
+      @conn << Query.dump(sql)
+
+      rows = []
+      errors = []
+
+      while true
+        msg = Message.read(@conn)
+        case msg
+        when DataRow
+          rows << msg.columns
+        when CommandComplete
+          cmd_tag = msg.cmd_tag
+        when ReadyForQuery
+          @transaction_status = msg.backend_transaction_status_indicator
+          break
+        when RowDescription
+          fields = msg.fields
+        when ErrorResponse
+          errors << msg
+        when NoticeResponse, EmptyQueryResponse
+          # ignore
+        else
+          raise PGError, "unhandled message type"
+        end
+      end
+
+      raise(PGError, errors.map{|e| e.field_values.join("\t") }.join("\n")) unless errors.empty?
+
+      Result.new(fields||[], rows, cmd_tag)
+    end
+
+    # Escape bytea values.  Uses historical format instead of hex
+    # format for maximum compatibility.
+    def escape_bytea(str)
+      str.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{sprintf('%o', b.each_byte{|x| break x}).rjust(3, '0')}"}
+    end
+    
+    # Escape strings by doubling apostrophes.  This only works if standard
+    # conforming strings are used.
+    def escape_string(str)
+      str.gsub("'", "''")
+    end
+
+    def block(timeout=nil)
+    end
+
+    def status
+      CONNECTION_OK
+    end
+
+    private
+
+    def check_password!(password)
+      raise PGError, "no password specified" unless password
+    end
+
+    # Doesn't check the connection actually works, only checks that
+    # it hasn't been closed.
+    def check_connection_open!
+      raise(PGError, "connection already closed") if @conn.nil?
+    end
+
+    def _connection(host, port)
+      if host.nil?
+        if RUBY_PLATFORM =~ /mingw|win/i
+          TCPSocket.new('localhost', port)
+        else
+          UNIXSocket.new("/tmp/.s.PGSQL.#{port}")
+        end
+      elsif host.start_with?('/')
+        UNIXSocket.new(host)
+      else
+        TCPSocket.new(host, port)
+      end
+    end
+  end
+end
+
+require_relative 'message'
+require_relative 'result'

data/lib/postgres-pr/message.rb

@@ -0,0 +1,307 @@
+#
+# Author:: Michael Neumann
+# Copyright:: (c) 2005 by Michael Neumann
+# License:: Same as Ruby's or BSD
+# 
+
+module PostgresPR
+
+  class PGError < StandardError; end
+  class ParseError < PGError; end
+  class DumpError < PGError; end
+
+  # Base class representing a PostgreSQL protocol message
+  class Message
+    # One character message-typecode to class map
+    MsgTypeMap = Hash.new { UnknownMessageType }
+
+    def self.register_message_type(type)
+      define_method(:message_type){type}
+      MsgTypeMap[type] = self
+    end
+
+    def self.read(stream)
+      type = read_exactly_n_bytes(stream, 1)
+      length = read_exactly_n_bytes(stream, 4).unpack('N').first  # FIXME: length should be signed, not unsigned
+
+      raise ParseError unless length >= 4
+
+      # initialize buffer
+      buffer = Buffer.of_size(1+length)
+      buffer.write(type)
+      buffer.write_int32(length)
+      buffer.copy_from_stream(stream, length-4)
+      
+      MsgTypeMap[type].create(buffer)
+    end
+
+    def self.read_exactly_n_bytes(io, n)
+      buf = io.read(n)
+      raise EOFError unless buf && buf.size == n
+      buf
+    end
+    private_class_method :read_exactly_n_bytes
+
+    def self.create(buffer)
+      obj = allocate
+      obj.parse(buffer)
+      obj
+    end
+
+    def self.dump(*args)
+      new(*args).dump
+    end
+
+    def dump(body_size=0)
+      buffer = Buffer.of_size(5 +  body_size)
+      buffer.write(self.message_type)
+      buffer.write_int32(4 + body_size)
+      yield buffer
+      raise DumpError  unless buffer.at_end?
+      return buffer.content
+    end
+
+    def parse(buffer)
+      buffer.position = 5
+      yield buffer
+      raise ParseError, buffer.inspect unless buffer.at_end?
+    end
+  end
+
+  class UnknownMessageType < Message
+    def parse(buffer)
+      raise PGError, "unable to parse message type: #{buffer.content.inspect}" 
+    end
+  end
+
+  class Authentification < Message
+    register_message_type 'R'
+    attr_reader :auth_type
+
+    AuthTypeMap = {}
+
+    def self.create(buffer)
+      buffer.position = 5
+      authtype = buffer.read_int32
+      klass = AuthTypeMap.fetch(authtype, UnknownAuthType)
+      obj = klass.allocate
+      obj.parse(buffer)
+      obj
+    end
+
+    def self.register_auth_type(type)
+      AuthTypeMap[type] = self
+    end
+
+    def parse(buffer)
+      super do
+        @auth_type = buffer.read_int32 
+        yield if block_given?
+      end
+    end
+  end
+
+  class UnknownAuthType < Authentification
+  end
+
+  class AuthentificationOk < Authentification 
+    register_auth_type 0
+  end
+
+  class AuthentificationClearTextPassword < Authentification 
+    register_auth_type 3
+  end
+
+  class AuthentificationMD5Password < Authentification 
+    register_auth_type 5
+    attr_accessor :salt
+
+    def parse(buffer)
+      super do
+        @salt = buffer.read(4)
+      end
+    end
+  end
+
+  class PasswordMessage < Message
+    register_message_type 'p'
+
+    def initialize(password)
+      @password = password
+    end
+
+    def dump
+      super(@password.size + 1) do |buffer|
+        buffer.write_cstring(@password)
+      end
+    end
+  end
+
+  class ParameterStatus < Message
+    register_message_type 'S'
+
+    def parse(buffer)
+      super do
+        buffer.read_cstring
+        buffer.read_cstring
+      end
+    end
+  end
+
+  class BackendKeyData < Message
+    register_message_type 'K'
+
+    def parse(buffer)
+      super do
+        buffer.read(8)
+      end
+    end
+  end
+
+  class ReadyForQuery < Message
+    register_message_type 'Z'
+    attr_reader :backend_transaction_status_indicator
+
+    def parse(buffer)
+      super do
+        @backend_transaction_status_indicator = buffer.read_byte
+      end
+    end
+  end
+
+  class DataRow < Message
+    register_message_type 'D'
+    attr_reader :columns
+
+    def parse(buffer)
+      super do
+        n_cols = buffer.read_int16
+        @columns = (1..n_cols).collect {
+          len = buffer.read_int32 
+          if len == -1
+            nil
+          else
+            buffer.read(len)
+          end
+        }
+      end
+    end
+  end
+
+  class CommandComplete < Message
+    register_message_type 'C'
+    attr_reader :cmd_tag
+
+    def parse(buffer)
+      super do
+        @cmd_tag = buffer.read_cstring
+      end
+    end
+  end
+
+  class EmptyQueryResponse < Message
+    register_message_type 'I'
+  end
+
+  module NoticeErrorMixin
+    attr_reader :field_values
+
+    def parse(buffer)
+      super do
+        break if buffer.read_byte == 0
+        @field_values = []
+        while buffer.position < buffer.size-1
+          @field_values << buffer.read_cstring
+        end
+        terminator = buffer.read_byte
+        raise ParseError unless terminator == 0
+      end
+    end
+  end
+
+  class NoticeResponse < Message
+    register_message_type 'N'
+    include NoticeErrorMixin
+  end
+
+  class ErrorResponse < Message
+    register_message_type 'E'
+    include NoticeErrorMixin
+  end
+
+  class Query < Message
+    register_message_type 'Q'
+    attr_accessor :query
+
+    # :nocov:
+    if RUBY_VERSION < '2'
+      def initialize(query)
+        @query = String.new(query).force_encoding('BINARY')
+      end
+    # :nocov:
+    else
+      def initialize(query)
+        @query = query.b
+      end
+    end
+
+    def dump
+      super(@query.size + 1) do |buffer|
+        buffer.write_cstring(@query)
+      end
+    end
+  end
+
+  class RowDescription < Message
+    register_message_type 'T'
+    attr_reader :fields
+
+    class FieldInfo < Struct.new(:name, :oid, :attr_nr, :type_oid, :typlen, :atttypmod, :formatcode); end
+
+    def parse(buffer)
+      super do
+        nfields = buffer.read_int16
+        @fields = nfields.times.map do
+          FieldInfo.new(
+            buffer.read_cstring,
+            buffer.read_int32,
+            buffer.read_int16,
+            buffer.read_int32,
+            buffer.read_int16,
+            buffer.read_int32,
+            buffer.read_int16
+          )
+        end
+      end
+    end
+  end
+
+  class StartupMessage < Message
+    PROTO_VERSION = 3 << 16 # 196608
+
+    def initialize(params)
+      @params = params
+    end
+
+    def dump
+      params = @params.reject{|k,v| v.nil?}
+      sz = params.inject(4 + 4) {|sum, kv| sum + kv[0].size + 1 + kv[1].size + 1} + 1
+
+      buffer = Buffer.of_size(sz)
+      buffer.write_int32(sz)
+      buffer.write_int32(PROTO_VERSION)
+      params.each_pair do |key, value| 
+        buffer.write_cstring(key)
+        buffer.write_cstring(value)
+      end
+      buffer.write_byte(0)
+      buffer.content
+    end
+  end
+
+  class Terminate < Message
+    register_message_type 'X'
+  end
+end
+
+require_relative 'buffer'

data/lib/postgres-pr/result.rb

@@ -0,0 +1,40 @@
+class PostgresPR::Result
+  def initialize(fields, rows, cmd_tag)
+    @fields = fields
+    @rows = rows
+    @cmd_tag = cmd_tag
+  end
+
+  def ntuples
+    @rows.size
+  end
+
+  def nfields
+    @fields.size
+  end
+
+  def fname(index)
+    @fields[index].name
+  end
+
+  def ftype(index)
+    @fields[index].type_oid
+  end
+
+  def getvalue(tup_num, field_num)
+    @rows[tup_num][field_num]
+  end
+
+  # free the result set
+  def clear
+    @fields = @rows = @cmd_tag = nil
+  end
+
+  # Returns the number of rows affected by the SQL command
+  def cmd_tuples
+    case @cmd_tag
+    when /^INSERT\s+(\d+)\s+(\d+)$/, /^(DELETE|UPDATE|MOVE|FETCH)\s+(\d+)$/
+      $2.to_i
+    end
+  end
+end

data/lib/sequel/postgres-pr.rb

@@ -0,0 +1,5 @@
+require_relative '../postgres-pr/connection'
+
+Sequel::Postgres::PGError = PostgresPR::PGError
+Sequel::Postgres::PGconn = PostgresPR::Connection
+Sequel::Postgres::PGresult = PostgresPR::Result

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: sequel-postgres-pr
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Jeremy Evans
+- Michael Neumann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-13 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- README
+- lib/postgres-pr/buffer.rb
+- lib/postgres-pr/connection.rb
+- lib/postgres-pr/message.rb
+- lib/postgres-pr/result.rb
+- lib/sequel/postgres-pr.rb
+homepage: https://github.com/jeremyevans/sequel-postgres-pr
+licenses:
+- MIT
+- Ruby
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/sequel-postgres-pr/issues
+  mailing_list_uri: https://github.com/jeremyevans/sequel-postgres-pr/discussions
+  source_code_uri: https://github.com/jeremyevans/sequel-postgres-pr
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'sequel-postgres-pr: Pure Ruby driver for PostgreSQL, designed for use with Sequel'
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: Pure Ruby driver for PostgreSQL, designed for use with Sequel
+test_files: []