jeremyevans-postgres-pr 0.6.1

data/examples/client.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH.unshift "../lib"
+require 'postgres-pr/message'
+require 'socket'
+include PostgresPR
+
+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/og/test.rb

@@ -0,0 +1,50 @@
+$LOAD_PATH.unshift '../../lib'
+require 'rubygems'
+require 'og'
+require 'glue/logger'
+
+$DBG = true
+
+class User
+end
+
+class Comment
+  prop_accessor :body, String
+  belongs_to :user, User
+end
+
+class User
+  prop_accessor :name, String
+  has_many :comments, Comment
+end
+
+if __FILE__ == $0
+  config = {
+    :address => "localhost",
+    :database => "mneumann",
+    :backend => "psql",
+    :user => "mneumann",
+    :password => "",
+    :connection_count => 1
+  }
+  $log = Logger.new(STDERR)
+  $og = Og::Database.new(config)
+
+  $og.get_connection
+
+  u1 = User.new
+  u1.name = "Michael Neumann"
+  u1.save!
+
+  u2 = User.new
+  u2.name = "John User"
+  u2.save!
+
+  c1 = Comment.new
+  c1.body = "og test"
+  c1.user = u1
+  c1.save!
+
+  p User.all
+  p Comment.all
+end

data/examples/server.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift "../lib"
+require 'postgres-pr/message'
+require 'socket'
+include PostgresPR
+
+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,18 @@
+$LOAD_PATH.unshift '../lib'
+require 'postgres-pr/connection'
+
+conn = PostgresPR::Connection.new('mneumann', 'mneumann', nil, 'unix:/var/run/postgresql/.s.PGSQL.5432')
+p conn.query("DROP TABLE test") rescue nil
+p conn.query("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,97 @@
+require 'binary_writer'
+require 'binary_reader'
+
+# Fixed size buffer.
+class Buffer
+
+  class Error < RuntimeError; end
+  class EOF < Error; end 
+
+  def self.from_string(str)
+    new(str)
+  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
+
+  # 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,174 @@
+#
+# Author:: Michael Neumann
+# Copyright:: (c) 2005 by Michael Neumann
+# License:: Same as Ruby's or BSD
+#
+
+require 'postgres-pr/message'
+require 'postgres-pr/version'
+require 'uri'
+require 'socket'
+
+module PostgresPR
+
+PROTO_VERSION = 3 << 16   #196608
+
+class Connection
+
+  # A block which is called with the NoticeResponse object as parameter.
+  attr_accessor :notice_processor
+
+  #
+  # 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 ?I
+      0
+    when ?T
+      2
+    when ?E
+      3
+    else
+      4
+    end
+  end
+
+  def initialize(database, user, password=nil, uri = nil)
+    uri ||= DEFAULT_URI
+
+    @transaction_status = nil
+    @params = {}
+    establish_connection(uri)
+  
+    @conn << StartupMessage.new(PROTO_VERSION, 'user' => user, 'database' => database).dump
+
+    loop do
+      msg = Message.read(@conn)
+
+      case msg
+      when AuthentificationClearTextPassword
+        raise PGError, "no password specified" if password.nil?
+        @conn << PasswordMessage.new(password).dump
+
+      when AuthentificationCryptPassword
+        raise PGError, "no password specified" if password.nil?
+        @conn << PasswordMessage.new(password.crypt(msg.salt)).dump
+
+      when AuthentificationMD5Password
+        raise PGError, "no password specified" if password.nil?
+        require 'digest/md5'
+
+        m = Digest::MD5.hexdigest(password + user) 
+        m = Digest::MD5.hexdigest(m + msg.salt)
+        m = 'md5' + m
+        @conn << PasswordMessage.new(m).dump
+
+      when AuthentificationKerberosV4, AuthentificationKerberosV5, AuthentificationSCMCredential
+        raise PGError, "unsupported authentification"
+
+      when AuthentificationOk
+      when ErrorResponse
+        raise PGError, msg.field_values.join("\t")
+      when NoticeResponse
+        @notice_processor.call(msg) if @notice_processor
+      when ParameterStatus
+        @params[msg.key] = msg.value
+      when BackendKeyData
+        # TODO
+        #p msg
+      when ReadyForQuery
+        @transaction_status = msg.backend_transaction_status_indicator
+        break
+      else
+        raise PGError, "unhandled message type"
+      end
+    end
+  end
+
+  def close
+    raise(PGError, "connection already closed") if @conn.nil?
+    @conn.shutdown
+    @conn = nil
+  end
+
+  class Result 
+    attr_accessor :rows, :fields, :cmd_tag
+    def initialize(rows=[], fields=[])
+      @rows, @fields = rows, fields
+    end
+  end
+
+  def query(sql)
+    @conn << Query.dump(sql)
+
+    result = Result.new
+    errors = []
+
+    loop do
+      msg = Message.read(@conn)
+      case msg
+      when DataRow
+        result.rows << msg.columns
+      when CommandComplete
+        result.cmd_tag = msg.cmd_tag
+      when ReadyForQuery
+        @transaction_status = msg.backend_transaction_status_indicator
+        break
+      when RowDescription
+        result.fields = msg.fields
+      when CopyInResponse
+      when CopyOutResponse
+      when EmptyQueryResponse
+      when ErrorResponse
+        # TODO
+        errors << msg
+      when NoticeResponse
+        @notice_processor.call(msg) if @notice_processor
+      else
+        # TODO
+      end
+    end
+
+    raise(PGError, errors.map{|e| e.field_values.join("\t") }.join("\n")) unless errors.empty?
+
+    result
+  end
+
+  DEFAULT_PORT = 5432
+  DEFAULT_HOST = 'localhost'
+  DEFAULT_PATH = '/tmp' 
+  DEFAULT_URI = 
+    if RUBY_PLATFORM.include?('win')
+      'tcp://' + DEFAULT_HOST + ':' + DEFAULT_PORT.to_s 
+    else
+      'unix:' + File.join(DEFAULT_PATH, '.s.PGSQL.' + DEFAULT_PORT.to_s)  
+    end
+
+  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 PGError, 'unrecognized uri scheme format (must be tcp or unix)'
+    end
+  end
+end
+
+end # module PostgresPR