postgres-pr-opt 0.6.9

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

@@ -0,0 +1,32 @@
+module Postgres::Conversion
+  # Encodes a string as bytea value.
+  #
+  # For encoding rules see:
+  #   http://www.postgresql.org/docs/7.4/static/datatype-binary.html
+  #
+  # The historical bytea escape format is always used, for maximum compatibility.
+  def encode_bytea(str)
+    # each_byte used instead of [] for 1.9 compatibility
+    str.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{sprintf('%o', b.each_byte{|x| break x}).rjust(3, '0')}"}
+  end
+
+  # Decodes a bytea encoded string.
+  #
+  # For decoding rules see:
+  #   http://www.postgresql.org/docs/7.4/static/datatype-binary.html
+  #
+  # Supports both the historical escape format and the new 9.0+ hex format.
+  def decode_bytea(str)
+    if str =~ /\A\\x/
+      # PostgreSQL 9.0+ bytea hex format
+      str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
+    else
+      # Historical PostgreSQL bytea escape format
+      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
+
+  alias unescape_bytea decode_bytea
+end

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

@@ -0,0 +1,5 @@
+module Postgres
+  module Conversion
+    class ConversionError < PostgresPR::PGError; end
+  end
+end

data/lib/postgres-pr/utils/buffer.rb

@@ -0,0 +1,252 @@
+require 'stringio'
+unless "".respond_to?(:getbyte)
+  class String
+    alias :getbyte :[]
+  end
+end
+unless "".respond_to?(:setbyte)
+  class String
+    alias :setbyte :[]=
+  end
+end
+
+if RUBY_ENGINE == 'ruby'
+  begin
+    require 'postgres-pr/utils/unpack_single'
+  rescue LoadError
+  end
+end
+
+module PostgresPR
+  module Utils
+    STRING_NATIVE_UNPACK_SINGLE = "".respond_to?(:get_int16_network)
+  end
+end
+
+unless PostgresPR::Utils::STRING_NATIVE_UNPACK_SINGLE 
+  class String
+    def get_int16_network(pos)
+      byte1, byte2 = getbyte(pos), getbyte(pos+1)
+      (byte1 < 128 ? byte1 : byte1 - 256) * 256 + byte2
+    end
+    def get_int32_network(pos)
+      byte1, byte2 = getbyte(pos), getbyte(pos+1)
+      byte3, byte4 = getbyte(pos+2), getbyte(pos+3)
+      ((((byte1 < 128 ? byte1 : byte1 - 256) * 256 + byte2) * 256) + byte3) * 256 + byte4
+    end
+  end
+end
+
+module PostgresPR
+  module Utils
+    class NativeBuffer < StringIO
+      def self.of_size(size)
+        new('#'*size, 'r+')
+      end
+      alias position pos
+      alias position= pos=
+      alias read_byte readbyte
+      alias at_end? eof?
+      alias content string
+      alias init_buffer initialize
+      public :init_buffer
+      if STRING_NATIVE_UNPACK_SINGLE
+        include ReadUnpack
+      else
+        def read_int16_network
+          byte1, byte2 = readbyte, readbyte
+          (byte1 < 128 ? byte1 : byte1 - 256) * 256 + byte2
+        end
+        def read_int32_network
+          byte1, byte2 = readbyte, readbyte
+          byte3, byte4 = readbyte, readbyte
+          ((((byte1 < 128 ? byte1 : byte1 - 256) * 256 + byte2) * 256) + byte3) * 256 + byte4
+        end
+      end
+      def write_byte(byte)
+        write(byte.chr)
+      end
+      def write_int32_network(int32)
+        write([int32].pack('N'))
+      end
+      def write_int16_network(int16)
+        write([int16].pack('n'))
+      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
+        s = readline(NUL)
+        s.chop!
+        s
+      end
+
+    end
+
+    class CustomBuffer
+
+      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)
+        self.init_buffer content
+      end
+
+      def init_buffer(content)
+        @size = content.size
+        @content = content
+        @position = 0
+      end
+
+      def close
+      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 readbyte
+        raise EOF, 'cannot read beyond the end of buffer' if @position >= @size
+        byte = @content.getbyte(@position)
+        @position += 1
+        byte
+      end
+      alias read_byte readbyte
+      
+      def read_int16_network
+        pos = @position
+        raise EOF, 'cannot read beyond the end of buffer' if pos + 2 > @size
+        @position += 2
+        @content.get_int16_network(pos)
+      end
+
+      def read_int32_network
+        pos = @position
+        raise EOF, 'cannot read beyond the end of buffer' if pos + 4 > @size
+        @position += 4
+        @content.get_int32_network(pos)
+      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
+
+      def writebyte(byte)
+        raise EOF, 'cannot write beyond the end of buffer' if @position >= @size
+        @content.setbyte(@position, byte)
+        @position += 1
+        self
+      end
+      alias write_byte writebyte
+
+      def write_int16_network(int16)
+        raise EOF, 'cannot write beyond the end of buffer' if @position + 2 > @size
+        @content[@position, 2] = [int16].pack('n')
+        @position += 2
+        self
+      end 
+
+      def write_int32_network(int32)
+        raise EOF, 'cannot write beyond the end of buffer' if @position + 4 > @size
+        @content[@position, 4] = [int32].pack('N')
+        @position += 4
+        self
+      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
+    end
+
+    if RUBY_ENGINE == 'jruby' || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9')
+      ReadBuffer = NativeBuffer
+      WriteBuffer = NativeBuffer
+    else
+      ReadBuffer = CustomBuffer
+      WriteBuffer = CustomBuffer
+    end
+  end
+end

data/lib/postgres-pr/utils/byteorder.rb

@@ -0,0 +1,45 @@
+module PostgresPR
+  module Utils
+    module ByteOrder 
+      Native = :Native
+      BigEndian = Big = Network = :BigEndian
+      LittleEndian = Little = :LittleEndian
+
+      # examines the byte order of the underlying machine
+      if [0x12345678].pack("L") == "\x12\x34\x56\x78" 
+        def byte_order
+          BigEndian
+        end
+
+        def little_endian?
+          false
+        end
+
+        def big_endian?
+          true
+        end
+      else
+        def byte_order
+          LittleEndian
+        end
+
+        def little_endian?
+          true
+        end
+
+        def big_endian?
+          false
+        end
+      end
+
+      alias byteorder byte_order 
+      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
+  end
+end

data/lib/postgres-pr/version.rb

@@ -0,0 +1,3 @@
+module PostgresPR
+  VERSION = "0.6.9"
+end

data/lib/postgres.rb

@@ -0,0 +1,8 @@
+# This is a compatibility layer for using the pure Ruby postgres-pr instead of
+# the C interface of postgres.
+
+begin
+  require 'postgres.so'
+rescue LoadError
+  require 'postgres-pr/postgres-compat'
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: postgres-pr-opt
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 9
+  version: 0.6.9
+platform: ruby
+authors: 
+- Michael Neumann
+- Jeremy Evans
+- Alexander E. Fischer
+- Aaron Hamid
+- Rahim Packir Saibo
+- Lars Christensen
+- Kashif Rasul
+- Sokolov Yura aka funny_falcon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-25 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- mneumann@ntecs.de
+- code@jeremyevans.net
+- aef@raxys.net
+- larsch@belunktum.dk
+- kashif@nomad-labs.com
+- funny.falcon@gmail.com
+executables: []
+
+extensions: 
+- ext/postgres-pr/utils/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile
+- lib/postgres-pr/version.rb
+- lib/postgres-pr/pg-compat.rb
+- lib/postgres-pr/postgres-compat.rb
+- lib/postgres-pr/typeconv/TC_conv.rb
+- lib/postgres-pr/typeconv/array.rb
+- lib/postgres-pr/typeconv/conv.rb
+- lib/postgres-pr/typeconv/bytea.rb
+- lib/postgres-pr/utils/buffer.rb
+- lib/postgres-pr/utils/byteorder.rb
+- lib/postgres-pr/connection.rb
+- lib/postgres-pr/message.rb
+- lib/pg.rb
+- lib/postgres.rb
+- examples/test_connection.rb
+- examples/server.rb
+- examples/client.rb
+- examples/og/test.rb
+- ext/postgres-pr/utils/extconf.rb
+- ext/postgres-pr/utils/string_unpack_single.c
+has_rdoc: true
+homepage: https://github.com/funny-falcon/postgres-pr
+licenses: 
+- Ruby
+- GPL
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A pure Ruby interface to the PostgreSQL (>= 7.4) database.
+test_files: []
+