postgres-pr 0.0.1

data/examples/client.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift "../lib"
+require 'postgres-pr/message'
+require 'socket'
+
+s = UNIXSocket.new(ARGV.shift || "/tmp/.s.PGSQL.5432")
+
+msg = StartupMessage.new(196608, "user" => "mneumann", "database" => "mneumann")
+s << msg.dump
+
+Thread.start(s) { |s|
+  sleep 2
+  s << Query.new("drop table test").dump
+  s << Query.new("create table test (i int, v varchar(100))").dump
+  s << Parse.new("insert into test (i, v) values ($1, $2)", "blah").dump 
+  s << Query.new("EXECUTE blah(1, 'hallo')").dump
+
+  while not (line = gets.chomp).empty?
+    s << Query.new(line).dump
+  end
+  exit
+}
+
+loop do  
+  msg = Message.read(s)
+  p msg
+
+  case msg
+  when AuthentificationOk
+    p "OK"
+  when ErrorResponse
+    p "FAILED"
+  end
+end

data/examples/server.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift "../lib"
+require 'postgres-pr/message'
+require 'socket'
+
+s = UNIXServer.open(ARGV.shift || raise).accept
+startup = true
+loop do
+  msg = Message.read(s, startup)
+  p msg
+  startup = false
+end

data/examples/test_connection.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift '../lib'
+require 'postgres-pr/connection'
+
+conn = Connection.new('mneumann', 'mneumann')
+p conn.query("DROP TABLE test; CREATE TABLE test (a VARCHAR(100))")
+p conn.query("INSERT INTO test VALUES ('hallo')") 
+p conn.query("INSERT INTO test VALUES ('leute')") 
+conn.query("COMMIT")
+
+conn.query("BEGIN")
+10000.times do |i|
+  p i
+  conn.query("INSERT INTO test VALUES ('#{i}')") 
+end
+conn.query("COMMIT")
+
+p conn.query("SELECT * FROM test")

data/lib/binary_reader.rb

@@ -0,0 +1,120 @@
+require 'byteorder'
+
+# This mixin solely depends on method read(n), which must be defined
+# in the class/module where you mixin this module.
+module BinaryReaderMixin
+
+  # == 8 bit
+
+  # no byteorder for 8 bit! 
+
+  def read_word8
+    ru(1, 'C')
+  end
+
+  def read_int8
+    ru(1, 'c')
+  end
+
+  alias read_byte read_word8
+  
+  # == 16 bit
+
+  # === Unsigned
+  
+  def read_word16_native
+    ru(2, 'S')
+  end
+
+  def read_word16_little
+    ru(2, 'v')
+  end
+
+  def read_word16_big
+    ru(2, 'n')
+  end
+
+  # === Signed
+
+  def read_int16_native
+    ru(2, 's')
+  end
+
+  def read_int16_little
+    # swap bytes if native=big (but we want little)
+    ru_swap(2, 's', ByteOrder::Big)
+  end
+
+  def read_int16_big
+    # swap bytes if native=little (but we want big)
+    ru_swap(2, 's', ByteOrder::Little) 
+  end
+
+  # == 32 bit
+
+  # === Unsigned
+
+  def read_word32_native
+    ru(4, 'L')
+  end
+
+  def read_word32_little
+    ru(4, 'V')
+  end
+
+  def read_word32_big
+    ru(4, 'N')
+  end
+
+  # === Signed
+
+  def read_int32_native
+    ru(4, 'l')
+  end
+
+  def read_int32_little
+    # swap bytes if native=big (but we want little)
+    ru_swap(4, 'l', ByteOrder::Big) 
+  end
+
+  def read_int32_big
+    # swap bytes if native=little (but we want big)
+    ru_swap(4, 'l', ByteOrder::Little) 
+  end
+
+  # == Aliases
+
+  alias read_uint8 read_word8
+
+  # add some short-cut functions 
+  %w(word16 int16 word32 int32).each do |typ|
+    alias_method "read_#{typ}_network", "read_#{typ}_big"
+  end
+
+  {:word16 => :uint16, :word32 => :uint32}.each do |old, new|
+    ['_native', '_little', '_big', '_network'].each do |bo|
+      alias_method "read_#{new}#{bo}", "read_#{old}#{bo}"
+    end
+  end
+
+  # read exactly n characters, otherwise raise an exception.
+  def readn(n)
+    str = read(n)
+    raise "couldn't read #{n} characters" if str.nil? or str.size != n
+    str
+  end
+
+  private
+
+  # shortcut method for readn+unpack
+  def ru(size, template)
+    readn(size).unpack(template).first
+  end
+
+  # same as method +ru+, but swap bytes if native byteorder == _byteorder_  
+  def ru_swap(size, template, byteorder)
+    str = readn(size)
+    str.reverse! if ByteOrder.byteorder == byteorder 
+    str.unpack(template).first
+  end
+end

data/lib/binary_writer.rb

@@ -0,0 +1,100 @@
+require 'byteorder'
+
+module BinaryWriterMixin
+
+  # == 8 bit
+
+  # no byteorder for 8 bit! 
+
+  def write_word8(val)
+    pw(val, 'C')
+  end
+
+  def write_int8(val)
+    pw(val, 'c')
+  end
+
+  alias write_byte write_word8
+
+  # == 16 bit
+
+  # === Unsigned
+
+  def write_word16_native(val)
+    pw(val, 'S')
+  end
+
+  def write_word16_little(val)
+    str = [val].pack('S')
+    str.reverse! if ByteOrder.network? # swap bytes as native=network (and we want little)
+    write(str)
+  end
+
+  def write_word16_network(val)
+    str = [val].pack('S')
+    str.reverse! if ByteOrder.little? # swap bytes as native=little (and we want network)
+    write(str)
+  end
+
+  # === Signed
+
+  def write_int16_native(val)
+    pw(val, 's')
+  end
+
+  def write_int16_little(val)
+    pw(val, 'v')
+  end
+
+  def write_int16_network(val)
+    pw(val, 'n')
+  end
+
+  # == 32 bit
+
+  # === Unsigned
+
+  def write_word32_native(val)
+    pw(val, 'L')
+  end
+
+  def write_word32_little(val)
+    str = [val].pack('L')
+    str.reverse! if ByteOrder.network? # swap bytes as native=network (and we want little)
+    write(str)
+  end
+
+  def write_word32_network(val)
+    str = [val].pack('L')
+    str.reverse! if ByteOrder.little? # swap bytes as native=little (and we want network)
+    write(str)
+  end
+
+  # === Signed
+
+  def write_int32_native(val)
+    pw(val, 'l')
+  end
+
+  def write_int32_little(val)
+    pw(val, 'V')
+  end
+
+  def write_int32_network(val)
+    pw(val, 'N')
+  end
+
+  # add some short-cut functions 
+  %w(word16 int16 word32 int32).each do |typ|
+    alias_method "write_#{typ}_big", "write_#{typ}_network"
+  end
+
+  # == Other methods
+
+  private
+
+  # shortcut for pack and write
+  def pw(val, template)
+    write([val].pack(template))
+  end
+end

data/lib/buffer.rb

@@ -0,0 +1,87 @@
+require 'binary_writer'
+require 'binary_reader'
+
+# Fixed size buffer.
+class Buffer
+
+  class Error < RuntimeError; end
+  class EOF < Error; end 
+
+  def initialize(size)
+    raise ArgumentError if size < 0
+
+    @size = size
+    @position = 0
+    @content = "#" * @size
+  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
+  end
+
+  def write_cstring(cstr)
+    raise ArgumentError, "Invalid Ruby/cstring" if cstr.include?("\000")
+    write(cstr)
+    write("\000")
+  end
+
+  # returns a Ruby string without the trailing NUL character
+  def read_cstring
+    nul_pos = @content.index(0, @position)
+    raise Error, "no cstring found!" unless nul_pos
+
+    sz = nul_pos - @position
+    str = @content[@position, sz]
+    @position += sz + 1
+    return str
+  end
+
+  # read till the end of the buffer
+  def read_rest
+    read(self.size-@position)
+  end
+
+  include BinaryWriterMixin
+  include BinaryReaderMixin
+end

data/lib/byteorder.rb

@@ -0,0 +1,32 @@
+module ByteOrder 
+  Native = :Native
+  BigEndian = Big = Network = :BigEndian
+  LittleEndian = Little = :LittleEndian
+
+  # examines the byte order of the underlying machine
+  def byte_order
+    if [0x12345678].pack("L") == "\x12\x34\x56\x78" 
+      BigEndian
+    else
+      LittleEndian
+    end
+  end
+
+  alias byteorder byte_order 
+
+  def little_endian?
+    byte_order == LittleEndian
+  end
+
+  def big_endian?
+    byte_order == BigEndian
+  end
+
+  alias little? little_endian? 
+  alias big? big_endian?
+  alias network? big_endian?
+
+  module_function :byte_order, :byteorder
+  module_function :little_endian?, :little?
+  module_function :big_endian?, :big?, :network?
+end

data/lib/postgres-pr/connection.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Michael Neumann
+# Copyright:: (c) 2004 by Michael Neumann
+#
+
+require 'postgres-pr/message'
+require 'uri'
+require 'socket'
+require 'thread'
+
+PROTO_VERSION = 196608
+
+class Connection
+
+  # sync
+
+  def initialize(database, user, auth=nil, uri = "unix:/tmp/.s.PGSQL.5432")
+    raise unless @mutex.nil?
+
+    @mutex = Mutex.new
+
+    @mutex.synchronize {
+      @params = {}
+      establish_connection(uri)
+    
+      @conn << StartupMessage.new(PROTO_VERSION, 'user' => user, 'database' => database).dump
+
+      loop do
+        msg = Message.read(@conn)
+        case msg
+        when AuthentificationOk
+        when ErrorResponse
+          raise
+        when NoticeResponse
+          # TODO
+        when ParameterStatus
+          @params[msg.key] = msg.value
+        when BackendKeyData
+          # TODO
+          #p msg
+        when ReadyForQuery
+          # TODO: use transaction status
+          break
+        else
+          raise "unhandled message type"
+        end
+      end
+    }
+  end
+
+  def query(sql)
+    @mutex.synchronize {
+      @conn << Query.dump(sql)
+
+      rows = []
+
+      loop do
+        msg = Message.read(@conn)
+        case msg
+        when DataRow
+          rows << msg.columns 
+        when CommandComplete
+        when ReadyForQuery
+          break
+        when RowDescription
+          # TODO
+        when CopyInResponse
+        when CopyOutResponse
+        when EmptyQueryResponse
+        when ErrorResponse
+          p msg
+          raise 
+        when NoticeResponse
+          # TODO
+        else
+          raise
+        end
+      end
+      rows
+    }
+  end
+
+  DEFAULT_PORT = 5432
+  DEFAULT_HOST = 'localhost'
+
+  private
+
+  # tcp://localhost:5432
+  # unix:/tmp/.s.PGSQL.5432
+  def establish_connection(uri)
+    u = URI.parse(uri)
+    case u.scheme
+    when 'tcp'
+      @conn = TCPSocket.new(u.host || DEFAULT_HOST, u.port || DEFAULT_PORT)
+    when 'unix'
+      @conn = UNIXSocket.new(u.path)
+    else
+      raise 'unrecognized uri scheme format (must be tcp or unix)'
+    end
+  end
+end

data/lib/postgres-pr/message.rb

@@ -0,0 +1,473 @@
+#
+# Author:: Michael Neumann
+# Copyright:: (c) 2004 by Michael Neumann
+# 
+
+require 'buffer'
+require 'readbytes'
+
+class ParseError < RuntimeError; end
+class DumpError < RuntimeError; 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)
+    raise ArgumentError if type < 0 or type > 255
+    raise "duplicate message type registration" if MsgTypeMap.has_key? type
+
+    MsgTypeMap[type] = self
+
+    self.const_set(:MsgType, type) 
+    class_eval "def message_type; MsgType end"
+  end
+
+  def self.read(stream, startup=false)
+    type = stream.readbytes(1).unpack('C').first unless startup
+    length = stream.readbytes(4).unpack('N').first  # FIXME: length should be signed, not unsigned
+
+    raise ParseError unless length >= 4
+
+    # initialize buffer
+    buffer = Buffer.new(startup ? length : 1+length)
+    buffer.write_byte(type) unless startup
+    buffer.write_int32_network(length)
+    buffer.copy_from_stream(stream, length-4)
+    
+    (startup ? StartupMessage : MsgTypeMap[type]).create(buffer)
+  end
+
+  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.new(5 +  body_size)
+    buffer.write_byte(self.message_type)
+    buffer.write_int32_network(4 + body_size)
+    yield buffer if block_given?
+    raise DumpError  unless buffer.at_end?
+    return buffer.content
+  end
+
+  def parse(buffer)
+    buffer.position = 5
+    yield buffer if block_given?
+    raise ParseError, buffer.inspect unless buffer.at_end?
+  end
+
+  def self.fields(*attribs)
+    names = attribs.map {|name, type| name.to_s}
+    arg_list = names.join(", ")
+    ivar_list = names.map {|name| "@" + name }.join(", ")
+    sym_list = names.map {|name| ":" + name }.join(", ")
+    class_eval %[
+      attr_accessor #{ sym_list } 
+      def initialize(#{ arg_list })
+        #{ ivar_list } = #{ arg_list }
+      end
+    ] 
+  end
+end
+
+class UnknownMessageType < Message
+  def dump
+    raise
+  end
+end
+
+class Authentification < Message
+  register_message_type ?R
+
+  AuthTypeMap = Hash.new { UnknownAuthType }
+
+  def self.create(buffer)
+    buffer.position = 5
+    authtype = buffer.read_int32_network
+    klass = AuthTypeMap[authtype]
+    obj = klass.allocate
+    obj.parse(buffer)
+    obj
+  end
+
+  def self.register_auth_type(type)
+    raise "duplicate auth type registration" if AuthTypeMap.has_key?(type)
+    AuthTypeMap[type] = self
+    self.const_set(:AuthType, type) 
+    class_eval "def auth_type() AuthType end"
+  end
+
+  # the dump method of class Message
+  alias message__dump dump
+
+  def dump
+    super(4) do |buffer|
+      buffer.write_int32_network(self.auth_type)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      auth_t = buffer.read_int32_network 
+      raise ParseError unless auth_t == self.auth_type
+      yield if block_given?
+    end
+  end
+end
+
+class UnknownAuthType < Authentification
+end
+
+class AuthentificationOk < Authentification 
+  register_auth_type 0
+end
+
+class AuthentificationKerberosV4 < Authentification 
+  register_auth_type 1
+end
+
+class AuthentificationKerberosV5 < Authentification 
+  register_auth_type 2
+end
+
+class AuthentificationClearTextPassword < Authentification 
+  register_auth_type 3
+end
+
+module SaltedAuthentificationMixin
+  attr_accessor :salt
+
+  def initialize(salt)
+    @salt = salt
+  end
+
+  def dump
+    raise DumpError unless @salt.size == self.salt_size
+
+    message__dump(4 + self.salt_size) do |buffer|
+      buffer.write_int32_network(self.auth_type)
+      buffer.write(@salt)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @salt = buffer.read(self.salt_size)
+    end
+  end
+end
+
+class AuthentificationCryptPassword < Authentification 
+  register_auth_type 4
+  include SaltedAuthentificationMixin
+  def salt_size; 2 end
+end
+
+
+class AuthentificationMD5Password < Authentification 
+  register_auth_type 5
+  include SaltedAuthentificationMixin
+  def salt_size; 4 end
+end
+
+class AuthentificationSCMCredential < Authentification 
+  register_auth_type 6
+end
+
+class ParameterStatus < Message
+  register_message_type ?S
+  fields :key, :value
+
+  def dump
+    super(@key.size + 1 + @value.size + 1) do |buffer|
+      buffer.write_cstring(@key)
+      buffer.write_cstring(@value)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @key = buffer.read_cstring
+      @value = buffer.read_cstring
+    end
+  end
+end
+
+class BackendKeyData < Message
+  register_message_type ?K
+  fields :process_id, :secret_key
+
+  def dump
+    super(4 + 4) do |buffer|
+      buffer.write_int32_network(@process_id)
+      buffer.write_int32_network(@secret_key)
+    end 
+  end
+
+  def parse(buffer)
+    super do
+      @process_id = buffer.read_int32_network
+      @secret_key = buffer.read_int32_network
+    end
+  end
+end
+
+class ReadyForQuery < Message
+  register_message_type ?Z
+  fields :backend_transaction_status_indicator
+
+  def dump
+    super(1) do |buffer|
+      buffer.write_byte(@backend_transaction_status_indicator)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @backend_transaction_status_indicator = buffer.read_byte
+    end
+  end
+end
+
+class DataRow < Message
+  register_message_type ?D
+  fields :columns
+
+  def dump
+    sz = @columns.inject(2) {|sum, col| sum + 4 + (col ? col.size : 0)}
+    super(sz) do |buffer|
+      buffer.write_int16_network(@columns.size)
+      @columns.each {|col|
+        buffer.write_int32_network(col ? col.size : -1)
+        buffer.write(col) if col
+      }
+    end
+  end
+
+  def parse(buffer)
+    super do
+      n_cols = buffer.read_int16_network
+      @columns = (1..n_cols).collect {
+        len = buffer.read_int32_network 
+        if len == -1
+          nil
+        else
+          buffer.read(len)
+        end
+      }
+    end
+  end
+end
+
+class CommandComplete < Message
+  register_message_type ?C
+  fields :cmd_tag
+
+  def dump
+    super(@cmd_tag.size + 1) do |buffer|
+      buffer.write_cstring(@cmd_tag)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @cmd_tag = buffer.read_cstring
+    end
+  end
+end
+
+class EmptyQueryResponse < Message
+  register_message_type ?I
+end
+
+module NoticeErrorMixin
+  attr_accessor :field_type, :field_values
+
+  def initialize(field_type=0, field_values=[])
+    raise ArgumentError if field_type == 0 and not field_values.empty?
+    @field_type, @field_values = field_type, field_values
+  end
+
+  def dump
+    raise ArgumentError if @field_type == 0 and not @field_values.empty?
+
+    sz = 1 
+    sz += @field_values.inject(1) {|sum, fld| sum + fld.size + 1} unless @field_type == 0 
+
+    super(sz) do |buffer|
+      buffer.write_byte(@field_type)
+      break if @field_type == 0 
+      @field_values.each {|fld| buffer.write_cstring(fld) }
+      buffer.write_byte(0)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @field_type = buffer.read_byte
+      break if @field_type == 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
+
+# TODO
+class CopyInResponse < Message
+  register_message_type ?G
+end
+
+# TODO
+class CopyOutResponse < Message
+  register_message_type ?H
+end
+
+class Parse < Message
+  register_message_type ?P
+  fields :query, :stmt_name, :parameter_oids
+
+  def initialize(query, stmt_name="", parameter_oids=[])
+    @query, @stmt_name, @parameter_oids = query, stmt_name, parameter_oids
+  end
+
+  def dump
+    sz = @stmt_name.size + 1 + @query.size + 1 + 2 + (4 * @parameter_oids.size)
+    super(sz) do |buffer| 
+      buffer.write_cstring(@stmt_name)
+      buffer.write_cstring(@query)
+      buffer.write_int16_network(@parameter_oids.size)
+      @parameter_oids.each {|oid| buffer.write_int32_network(oid) }
+    end
+  end
+
+  def parse(buffer)
+    super do 
+      @stmt_name = buffer.read_cstring
+      @query = buffer.read_cstring
+      n_oids = buffer.read_int16_network
+      @parameter_oids = (1..n_oids).collect {
+        # TODO: zero means unspecified. map to nil?
+        buffer.read_int32_network
+      }
+    end
+  end
+end
+
+class ParseComplete < Message
+  register_message_type ?1
+end
+
+class Query < Message
+  register_message_type ?Q
+  fields :query
+
+  def dump
+    super(@query.size + 1) do |buffer|
+      buffer.write_cstring(@query)
+    end
+  end
+
+  def parse(buffer)
+    super do
+      @query = buffer.read_cstring
+    end
+  end
+end
+
+class RowDescription < Message
+  register_message_type ?T
+
+  class FieldInfo < Struct.new(:name, :oid, :attr_nr, :type_oid, :typlen, :atttypmod, :formatcode); end
+
+  def dump
+    sz = @fields.inject(2) {|sum, fld| sum + 18 + fld.name.size + 1 }
+    super(sz) do |buffer|
+      buffer.write_int16_network(@fields.size)
+      @fields.each { |f|
+        buffer.write_cstring(f.name)
+        buffer.write_int32_network(f.oid)
+        buffer.write_int16_network(f.attr_nr)
+        buffer.write_int32_network(f.type_oid)
+        buffer.write_int16_network(f.typlen)
+        buffer.write_int32_network(f.atttypmod)
+        buffer.write_int16_network(f.formatcode)
+      }
+    end
+  end
+
+  def parse(buffer)
+    super do
+      n_fields = buffer.read_int16_network
+      @fields = (1..n_fields).collect {
+        f = FieldInfo.new
+        f.name       = buffer.read_cstring
+        f.oid        = buffer.read_int32_network
+        f.attr_nr    = buffer.read_int16_network
+        f.type_oid   = buffer.read_int32_network
+        f.typlen     = buffer.read_int16_network
+        f.atttypmod  = buffer.read_int32_network
+        f.formatcode = buffer.read_int16_network
+      }
+    end
+  end
+end
+
+class StartupMessage < Message
+  fields :proto_version, :params
+
+  def dump
+    sz = @params.inject(4 + 4) {|sum, kv| sum + kv[0].size + 1 + kv[1].size + 1} + 1
+
+    buffer = Buffer.new(sz)
+    buffer.write_int32_network(sz)
+    buffer.write_int32_network(@proto_version)
+    @params.each_pair {|key, value| 
+      buffer.write_cstring(key)
+      buffer.write_cstring(value)
+    }
+    buffer.write_byte(0)
+
+    raise DumpError unless buffer.at_end?
+    return buffer.content
+  end
+
+  def parse(buffer)
+    buffer.position = 4
+
+    @proto_version = buffer.read_int32_network
+    @params = {}
+
+    while buffer.position < buffer.size-1
+      key = buffer.read_cstring
+      val = buffer.read_cstring
+      @params[key] = val
+    end
+
+    nul = buffer.read_byte
+    raise ParseError unless nul == 0
+    raise ParseError unless buffer.at_end?
+  end
+end

data/lib/postgres-pr/typeconv/TC_conv.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'conv'
+require 'array'
+require 'bytea'
+
+class TC_Conversion < Test::Unit::TestCase
+  def test_decode_array
+    assert_equal ["abcdef ", "hallo", ["1", "2"]], decode_array("{   abcdef ,    hallo, {   1, 2} }")
+    assert_equal [""], decode_array("{ }") # TODO: Correct?
+    assert_equal [], decode_array("{}")
+    assert_equal ["hallo", ""], decode_array("{hallo,}")
+  end
+
+  def test_bytea
+  end
+
+  include Postgres::Conversion
+end

data/lib/postgres-pr/typeconv/array.rb

@@ -0,0 +1,46 @@
+require 'strscan'
+
+module Postgres::Conversion
+
+  def decode_array(str, delim=',', &conv_proc)
+    delim = Regexp.escape(delim)
+    buf = StringScanner.new(str)
+    return parse_arr(buf, delim, &conv_proc)
+  ensure
+    raise ConversionError, "end of string expected (#{buf.rest})" unless buf.empty?
+  end
+
+  private
+
+  def parse_arr(buf, delim, &conv_proc)
+    # skip whitespace
+    buf.skip(/\s*/)       
+
+    raise ConversionError, "'{' expected" unless buf.get_byte == '{'
+
+    elems = []
+    unless buf.scan(/\}/) # array is not empty
+      loop do
+        # skip whitespace
+        buf.skip(/\s+/)   
+
+        elems <<
+        if buf.check(/\{/)
+          parse_arr(buf, delim, &conv_proc)
+        else
+          e = buf.scan(/("((\\.)|[^"])*"|\\.|[^\}#{ delim }])*/) || raise(ConversionError)
+          if conv_proc then conv_proc.call(e) else e end
+        end
+
+        break if buf.scan(/\}/)
+        break unless buf.scan(/#{ delim }/)
+      end
+    end
+
+    # skip whitespace
+    buf.skip(/\s*/)
+
+    elems
+  end
+
+end

data/lib/postgres-pr/typeconv/bytea.rb

@@ -0,0 +1,26 @@
+module Postgres::Conversion
+
+  #
+  # Encodes a string as bytea value.
+  #
+  # for encoding rules see:
+  #   http://www.postgresql.org/docs/7.4/static/datatype-binary.html
+  #
+
+  def encode_bytea(str)
+    str.gsub(/[\000-\037\047\134\177-\377]/) {|b| "\\#{ b[0].to_s(8).rjust(3, '0') }" }
+  end
+
+  #
+  # Decodes a bytea encoded string.
+  #
+  # for decoding rules see:
+  #   http://www.postgresql.org/docs/7.4/static/datatype-binary.html
+  #
+  def decode_bytea(str)
+    str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
+      if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+    }
+  end
+
+end

data/lib/postgres-pr/typeconv/conv.rb

@@ -0,0 +1,5 @@
+module Postgres
+  module Conversion
+    class ConversionError < Exception; end
+  end
+end

data/test/TC_message.rb

@@ -0,0 +1,101 @@
+require 'test/unit'
+require 'stringio'
+
+class Module
+  def attr_accessor(*attrs)
+    @@attrs = [] unless defined?(@@attrs)
+    @@attrs += attrs
+
+    x = @@attrs.map {|a| "self.#{a} == o.#{a}"}.join(" && ")
+    class_eval %{
+      def ==(o)
+        #{ x }
+      end
+    }
+
+    @@attrs.each do |a|
+      class_eval %{
+        def #{a}() @#{a} end
+        def #{a}=(v) @#{a}=v end
+      }
+    end
+  end
+end
+
+$LOAD_PATH.unshift '../lib'
+require 'postgres-pr/message'
+class Buffer
+  alias old_content content
+  def content
+    self
+  end
+end
+
+class Message
+  attr_accessor :buffer
+
+  class << self
+    alias old_create create
+    def create(buffer)
+      obj = old_create(buffer)
+      obj.buffer = buffer
+      obj
+    end
+  end
+
+  alias old_dump dump
+
+  def dump(body_size=0, &block)
+    buf = old_dump(body_size, &block)
+    self.buffer = buf
+    buf.old_content
+  end
+end
+
+class StartupMessage
+  alias old_dump dump
+  def dump
+    buf = old_dump
+    self.buffer = buf
+    buf.old_content
+  end
+end
+
+class StringIO
+  alias readbytes read
+end
+
+class TC_Message < Test::Unit::TestCase
+
+  CASES = [ 
+    #[AuthentificationOk], 
+    #[ErrorResponse],
+    [ParameterStatus, "key", "value"],
+    [BackendKeyData, 234234234, 213434],
+    [ReadyForQuery, ?T],
+    # TODO: RowDescription
+    [DataRow, ["a", "bbbbbb", "ccc", nil, nil, "ddddd", "e" * 10_000]],
+    [DataRow, []],
+    [CommandComplete, "INSERT"],
+    [StartupMessage, 196608, {"user" => "mneumann", "database" => "mneumann"}],
+    [Parse, "INSERT INTO blah values (?, ?)", ""],
+    [Query, "SELECT * FROM test\nWHERE a='test'"]
+  ]
+
+  def test_pack_unpack_feature
+    assert_equal ['a', 'b'], "a\000b\000".unpack('Z*Z*')
+  end
+
+  def test_marshal_unmarshal
+    CASES.each do |klass, *params|
+      msg = klass.new(*params)
+      new_msg = Message.read(StringIO.new(msg.dump), klass == StartupMessage)
+      assert_equal(msg, new_msg)
+
+      msg1, msg2 = klass.new(*params), klass.new(*params)
+      msg1.dump
+      msg2.dump; msg2.parse(msg2.buffer)
+      assert_equal(msg1, msg2)
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: postgres-pr
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2004-11-18
+summary: A pure Ruby interface to the PostgreSQL database
+require_paths: 
+  - lib
+author: Michael Neumann
+email: mneumann@ntecs.de
+homepage: ruby-dbi.rubyforge.org
+rubyforge_project: ruby-dbi
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/postgres-pr
+  - lib/binary_writer.rb
+  - lib/byteorder.rb
+  - lib/binary_reader.rb
+  - lib/buffer.rb
+  - lib/postgres-pr/typeconv
+  - lib/postgres-pr/connection.rb
+  - lib/postgres-pr/message.rb
+  - lib/postgres-pr/typeconv/array.rb
+  - lib/postgres-pr/typeconv/bytea.rb
+  - lib/postgres-pr/typeconv/conv.rb
+  - lib/postgres-pr/typeconv/TC_conv.rb
+  - test/TC_message.rb
+  - examples/client.rb
+  - examples/server.rb
+  - examples/test_connection.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []