pg_data_encoder 0.1.6 → 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b19a299f91517f76fbcefc9698f35b227553c3b
+  data.tar.gz: 9b8eb4e9ad16d91064ad597eda6ba6fcd8f55436
+SHA512:
+  metadata.gz: f0746ac331e9479f80ad608507d724e8705f6e569ada612663b394270004a89f04bb8fe5aadec2aad1c0186d390f9d377f2c7d6b0edc8336fd576ab4ae163d6d
+  data.tar.gz: 5685336f89acf111f1a1a907a968ba99d726cef7c50fbb1395246a3d34a45776840f8ac42da26a9b781ffb004e78ef28adff174eed95b90ed9886108d47b3f69

data/lib/pg_data_encoder/decoder.rb

@@ -0,0 +1,181 @@
+require 'tempfile'
+require 'stringio'
+module PgDataEncoder
+
+  class Decoder
+    def initialize(options = {})
+      @options = options
+      @closed = false
+      if options[:column_types].kind_of?(Array)
+        map = {}
+        options[:column_types].each_with_index {|c, i|
+          map[i] = c
+        }
+        options[:column_types] = map
+      else
+        options[:column_types] ||= {}
+      end
+      @io = nil
+    end
+
+    def read_line
+      return nil if @closed
+      setup_io if !@io
+      row = []
+      bytes = @io.read(2)
+      #p bytes
+      column_count = bytes.unpack("n").first
+      if column_count == 65535
+        @closed = true
+        return nil
+      end
+      #@io.write([row.size].pack("n"))
+      0.upto(column_count - 1).each {|index|
+        field = decode_field(@io)
+        if field == nil
+          row[index] = field 
+        elsif @options[:column_types][index]
+          row[index] = map_field(field, @options[:column_types][index])
+        else
+          row[index] = field
+        end
+      }
+      row
+    end
+
+    def each
+      loop do
+        result = read_line
+        if result
+          yield result
+        else
+          break
+        end
+
+        if @closed
+          break
+        end
+      end
+    end
+
+
+    private
+
+    def setup_io
+      if @options[:file]
+        @io = File.open(@options[:file], "r:ASCII-8BIT")
+      elsif !@options[:io].nil?
+        @io = @options[:io]  
+      else
+        raise "NO io present"
+      end
+      header = "PGCOPY\n\377\r\n\0".force_encoding("ASCII-8BIT")
+      result = @io.read(header.bytesize)
+       if result != header
+        raise "invalid format"
+      end
+     #p @io.read(10)
+
+      @io.read(2)  #blank
+      @io.read(6)  #blank
+    end
+
+    def decode_field(io)
+
+      bytes = io.read(4)
+      
+      if bytes == "\xFF\xFF\xFF\xFF".force_encoding("ASCII-8BIT")
+        return nil
+      else
+        io.read(bytes.unpack("N").first)
+      end
+    end
+
+    def map_field(data, type)
+      #p [type, data]
+
+      case type
+      when :int, :integer
+        data.unpack("N").first
+      when :bytea
+        data
+      when :bigint
+        data.unpack("Q>").first
+      when :float
+        data.unpack("G").first
+      when :boolean
+        v = data.unpack("C").first
+        v == 1
+      when :string, :text, :character
+        data.force_encoding("UTF-8")
+      when :json
+        JSON.load(data)
+      when :uuid
+        r = data.unpack('H*').first
+        "#{r[0..7]}-#{r[8..11]}-#{r[12..15]}-#{r[16..19]}-#{r[20..-1]}"
+      when :uuid_raw
+        r = data.unpack('H*').first
+      when :array, :"integer[]", :"uuid[]", :"character[]"
+        io = StringIO.new(data)
+        io.read(4)  #unknown
+        io.read(4)  #unknown
+        atype = io.read(4).unpack("N").first  #string type?
+        size = io.read(4).unpack("N").first
+        io.read(4) # should be 1 for dimension
+        #p [atype, size]
+        #p data
+        case atype
+        when 2950 #uuid
+          0.upto(size - 1).map {|i|
+            io.read(4) # size
+            r = io.read(16).unpack("H*").first
+            "#{r[0..7]}-#{r[8..11]}-#{r[12..15]}-#{r[16..19]}-#{r[20..-1]}"
+          }
+        when 1043 #string
+          0.upto(size - 1).map {|i|
+            size = io.read(4).unpack("N").first
+            io.read(size)
+          }
+        when 23 #int
+          0.upto(size - 1).map {|i|
+            size = io.read(4).unpack("N").first
+            bytes = io.read(size)
+            bytes.unpack("N").first
+          }
+        else
+          raise "Unsupported Array type #{atype}"
+        end
+      when :hstore, :hash
+        io = StringIO.new(data)
+        fields = io.read(4).unpack("N").first
+        h = {}
+        0.upto(fields - 1).each {|i|
+          key_size = io.read(4).unpack("N").first
+          key = io.read(key_size).force_encoding("UTF-8")
+          value_size = io.read(4).unpack("N").first
+          value = io.read(value_size).force_encoding("UTF-8")
+          h[key] = value
+          #p h
+        }
+        raise "remaining hstore bytes!" if io.pos != io.size
+        h
+      when :time, :timestamp
+        d = data.unpack("L!>").first
+        Time.at((d + POSTGRES_EPOCH_TIME) / 1_000_000.0).utc
+      when :date
+        # couldn't find another way to get signed network byte order
+        m = 0b0111_1111_1111_1111_1111_1111_1111_1111
+        d = data.unpack("N").first
+        if data.bytes[0] & 0b1000_0000 > 0 # negative number
+          d = (d & m) - m - 1
+        end
+
+        #p [data, d, Date.jd(d + Date.new(2000,1,1).jd)]
+        Date.jd(d + Date.new(2000,1,1).jd)
+      else
+        raise "Unsupported format #{format}"
+      end
+    end
+
+  end
+end

data/lib/pg_data_encoder/encode_for_copy.rb

@@ -1,8 +1,6 @@
 require 'tempfile'
 require 'stringio'
 module PgDataEncoder
-  POSTGRES_EPOCH_TIME = (Time.utc(2000,1,1).to_f * 1_000_000).to_i
-
   
   class EncodeForCopy
     def initialize(options = {})
@@ -178,7 +176,7 @@ module PgDataEncoder
           hash_io.write(buf.to_s)
           encode_field(hash_io, val.nil? ? val : val.to_s, index, depth + 1)
         }
-        io.write([hash_io.pos].pack("N"))  # assumed identifier for hstore column
+        io.write([hash_io.pos].pack("N"))  # size of hstore data
         io.write(hash_io.string)
       when Time
         buf = [(field.to_f * 1_000_000 - POSTGRES_EPOCH_TIME).to_i].pack("L!>")

data/lib/pg_data_encoder/version.rb

@@ -1,3 +1,3 @@
 module PgDataEncoder
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/pg_data_encoder.rb

@@ -2,7 +2,9 @@ require "pg_data_encoder/version"
 
 require 'pg_data_encoder/temp_buffer'
 require 'pg_data_encoder/encode_for_copy'
+require 'pg_data_encoder/decoder'
 
 module PgDataEncoder
   # Your code goes here...
+  POSTGRES_EPOCH_TIME = (Time.utc(2000,1,1).to_f * 1_000_000).to_i
 end

data/spec/spec_helper.rb

@@ -18,4 +18,8 @@ def filedata(filename)
     str = io.read
   }
   str
+end
+
+def fileio(filename)
+  File.open("spec/fixtures/#{filename}", "r:ASCII-8BIT") 
 end

data/spec/verify_data_formats_spec.rb

@@ -175,6 +175,57 @@ describe "generating data" do
     str.should == existing_data
   end
 
+  it 'should encode multiple 2015 dates' do
+    encoder = PgDataEncoder::EncodeForCopy.new
+    encoder.add [Date.parse("2015-04-08"), nil, Date.parse("2015-04-13")]
+    encoder.close
+    io = encoder.get_io
+    existing_data = filedata("dates.dat")
+    str = io.read
+    io.class.name.should == "StringIO"
+    str.force_encoding("ASCII-8BIT")
+    str.should == existing_data
+  end
+
+  it 'should encode timestamp data correctly' do
+    encoder = PgDataEncoder::EncodeForCopy.new
+    encoder.add [Time.parse("2013-06-11 15:03:54.62605 UTC")]
+    encoder.close
+    io = encoder.get_io
+    existing_data = filedata("timestamp.dat")
+    str = io.read
+    io.class.name.should == "StringIO"
+    str.force_encoding("ASCII-8BIT")
+    #File.open("spec/fixtures/output.dat", "w:ASCII-8BIT") {|out| out.write(str) }
+    str.should == existing_data
+  end
+
+  it 'should encode dates and times in pg 9.2.4' do
+    encoder = PgDataEncoder::EncodeForCopy.new
+    encoder.add [Date.parse('2015-04-08'), nil,  Time.parse("2015-02-13 16:13:57.732772 UTC")]
+    encoder.close
+    io = encoder.get_io
+    existing_data = filedata("dates_p924.dat")
+    str = io.read
+    io.class.name.should == "StringIO"
+    str.force_encoding("ASCII-8BIT")
+    #File.open("spec/fixtures/output.dat", "w:ASCII-8BIT") {|out| out.write(str) }
+    str.should == existing_data
+  end
+
+  it 'should encode dates and times in pg 9.3.5' do
+    encoder = PgDataEncoder::EncodeForCopy.new
+    encoder.add [Date.parse('2015-04-08'), nil,  Time.parse("2015-02-13 16:13:57.732772 UTC")]
+    encoder.close
+    io = encoder.get_io
+    existing_data = filedata("dates_pg935.dat")
+    str = io.read
+    io.class.name.should == "StringIO"
+    str.force_encoding("ASCII-8BIT")
+    #File.open("spec/fixtures/output.dat", "w:ASCII-8BIT") {|out| out.write(str) }
+    str.should == existing_data
+  end
+
   it 'should encode timestamp data correctly' do
     encoder = PgDataEncoder::EncodeForCopy.new
     encoder.add [Time.parse("2013-06-11 15:03:54.62605 UTC")]
@@ -188,6 +239,19 @@ describe "generating data" do
     str.should == existing_data
   end
 
+  it 'should encode big timestamp data correctly' do
+    encoder = PgDataEncoder::EncodeForCopy.new
+    encoder.add [Time.parse("2014-12-02 16:01:22.437311 UTC")]
+    encoder.close
+    io = encoder.get_io
+    existing_data = filedata("timestamp_9.3.dat")
+    str = io.read
+    io.class.name.should == "StringIO"
+    str.force_encoding("ASCII-8BIT")
+    #File.open("spec/fixtures/output.dat", "w:ASCII-8BIT") {|out| out.write(str) }
+    str.should == existing_data
+  end
+
   it 'should encode float correctly from tempfile' do
     encoder = PgDataEncoder::EncodeForCopy.new(:use_tempfile => true)
     encoder.add [Time.parse("2013-06-11 15:03:54.62605 UTC")]

data/spec/verify_decoder_spec.rb

@@ -0,0 +1,290 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "parsing data" do
+
+  it 'should walk through each line and stop' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("hstore_utf8.dat"), 
+      column_types: {0 => :hstore}
+    )
+    lines = []
+    decoder.each do |l|
+      lines << l
+    end
+    lines.should == [
+      [{'test' => "Ekström"}],
+      [{'test' => "Dueñas"}],
+      [{"account_first_name"=>"asdfasdf asñas", "testtesttesttesttesttestest"=>"" , "aasdfasdfasdfasdfasdfasdfasdfasdfasfasfasdfs"=>""}]
+    ]
+  end
+  it 'should handle getting called after running out of data' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("3_col_hstore.dat"), 
+      column_types: {0 => :int, 1=> :string, 2 => :hstore}
+    )
+    r = decoder.read_line
+    r.should == [1, "text", {'a' => "1", "b" => "asdf"}]
+    decoder.read_line.should == nil
+    decoder.read_line.should == nil
+    
+    
+  end
+  it 'should encode hstore data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("3_col_hstore.dat"), 
+      column_types: {0 => :int, 1=> :string, 2 => :hstore}
+    )
+    r = decoder.read_line
+    r.should == [1, "text", {'a' => "1", "b" => "asdf"}]
+    
+  end
+
+  it 'should return nil if past data' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("3_col_hstore.dat"), 
+      column_types: {0 => :int, 1=> :string, 2 => :hstore}
+    )
+    r = decoder.read_line
+    r.should == [1, "text", {'a' => "1", "b" => "asdf"}]
+    r = decoder.read_line
+    r.should == nil
+  end
+
+  it 'should encode hstore with utf8 data correctly from tempfile' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("hstore_utf8.dat"), 
+      column_types: {0 => :hstore}
+    )
+    r = decoder.read_line
+    r.should == [{'test' => "Ekström"}]
+    r = decoder.read_line
+    r.should == [{'test' => "Dueñas"}]
+    r = decoder.read_line
+    r.should == [{"account_first_name"=>"asdfasdf asñas", "testtesttesttesttesttestest"=>"" , "aasdfasdfasdfasdfasdfasdfasdfasdfasfasfasdfs"=>""}]
+
+  end
+
+  it 'should encode TrueClass data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("trueclass.dat"), 
+      column_types: {0 => :boolean}
+    )
+    r = decoder.read_line
+    r.should == [true]
+  end
+
+  it 'should encode FalseClass data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("falseclass.dat"), 
+      column_types: {0 => :boolean}
+    )
+    r = decoder.read_line
+    r.should == [false]
+  end
+
+  it 'should encode array data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("array_with_two2.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [["hi", "jim"]]
+   
+  end
+
+  it 'should encode string array data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("big_str_array.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [['asdfasdfasdfasdf', 'asdfasdfasdfasdfadsfadf', '1123423423423']]
+
+  end
+
+  it 'should encode string array with big string int' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("just_an_array2.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [["182749082739172"]]
+
+  end
+
+  it 'should encode string array data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("big_str_array2.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [['asdfasdfasdfasdf', 'asdfasdfasdfasdfadsfadf']]
+
+  end
+
+  #it 'should encode array data from tempfile correctly' do
+  #  encoder = PgDataEncoder::EncodeForCopy.new(:use_tempfile => true)
+  #  encoder.add [1, "hi", ["hi", "there", "rubyist"]]
+  #  encoder.close
+  #  io = encoder.get_io
+  #  existing_data = filedata("3_column_array.dat")
+  #  str = io.read_line
+  #  io.class.name.should == "Tempfile"
+  #  str.force_encoding("ASCII-8BIT")
+  #  str.should == existing_data
+  #end
+
+  it 'should encode integer array data from tempfile correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("intarray.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [[1,2,3]]
+  end
+
+  it 'should encode old date data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("date.dat"), 
+      column_types: {0 => :date}
+    )
+    r = decoder.read_line
+    r.should == [Date.parse("1900-12-03")]
+    
+  end
+
+  it 'should encode date data correctly for years > 2000' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("date2000.dat"), 
+      column_types: {0 => :date}
+    )
+    r = decoder.read_line
+    r.should == [Date.parse("2033-01-12")]
+  
+  end
+
+  it 'should encode date data correctly in the 70s' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("date2.dat"), 
+      column_types: {0 => :date}
+    )
+    r = decoder.read_line
+    r.should == [Date.parse("1971-12-11")]
+  
+  end
+
+  it 'should encode multiple 2015 dates' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("dates.dat"), 
+      column_types: {0 => :date, 1 => :date, 2 => :date}
+    )
+    r = decoder.read_line
+    r.should == [Date.parse("2015-04-08"), nil, Date.parse("2015-04-13")]
+  
+  end
+
+  it 'should encode timestamp data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("timestamp.dat"), 
+      column_types: {0 => :time}
+    )
+    r = decoder.read_line
+    r.map(&:to_f).should == [Time.parse("2013-06-11 15:03:54.62605 UTC")].map(&:to_f)
+  
+  end
+
+  it 'should encode dates and times in pg 9.2.4' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("dates_p924.dat"), 
+      column_types: {0 => :date, 2 => :time}
+    )
+    r = decoder.read_line
+    r.map {|f| f.kind_of?(Time) ? f.to_f : f}.should == [Date.parse('2015-04-08'), nil,  Time.parse("2015-02-13 16:13:57.732772 UTC")].map {|f| f.kind_of?(Time) ? f.to_f : f}
+  
+  end
+
+  it 'should encode dates and times in pg 9.3.5' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("dates_pg935.dat"), 
+      column_types: {0 => :date, 2 => :time}
+    )
+    r = decoder.read_line
+    r.map {|f| f.kind_of?(Time) ? f.to_f : f}.should == [Date.parse('2015-04-08'), nil,  Time.parse("2015-02-13 16:13:57.732772 UTC")].map {|f| f.kind_of?(Time) ? f.to_f : f}
+  
+  end
+
+
+  it 'should encode big timestamp data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("timestamp_9.3.dat"), 
+      column_types: {0 => :time}
+    )
+    r = decoder.read_line
+    r.map {|f| f.kind_of?(Time) ? f.to_f : f}.should == [Time.parse("2014-12-02 16:01:22.437311 UTC")].map {|f| f.kind_of?(Time) ? f.to_f : f}
+  
+  end
+
+  it 'should encode float data correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("float.dat"), 
+      column_types: {0 => :float}
+    )
+    r = decoder.read_line
+    r.should == [1234567.1234567]
+  
+  end
+
+  it 'should encode uuid correctly from tempfile' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("uuid.dat"), 
+      column_types: {0 => :uuid}
+    )
+    r = decoder.read_line
+    r.should == ['e876eef5-a116-4a27-b71f-bac4a1dcd20e']
+    
+  end
+
+  it 'should encode null uuid correctly from tempfile' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("empty_uuid.dat"), 
+      column_types: {0 => :string, 1 => :uuid, 2 => :uuid, 3 => :integer}
+    )
+    r = decoder.read_line
+    r.should == ['before2', nil, nil, 123423423]
+    
+  end
+
+
+  it 'should encode uuid correctly from tempfile' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("uuid_array.dat"), 
+      column_types: {0 => :array}
+    )
+    r = decoder.read_line
+    r.should == [['6272bd7d-adae-44b7-bba1-dca871c2a6fd', '7dc8431f-fcce-4d4d-86f3-6857cba47d38']]
+    
+  end
+
+
+  it 'should encode utf8 string correctly' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("utf8.dat"), 
+      column_types: {0 => :string}
+    )
+    r = decoder.read_line
+    r.should == ["Ekström"]
+    
+  end
+
+  it 'should encode bigint as int correctly from tempfile' do
+    decoder = PgDataEncoder::Decoder.new(
+      io: fileio("bigint.dat"), 
+      column_types: {0 => :bigint, 1 => :string}
+    )
+    r = decoder.read_line
+    r.should == [23372036854775808, 'test']
+  end
+
+
+end

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: pg_data_encoder
 version: !ruby/object:Gem::Version
-  version: 0.1.6
-  prerelease: 
+  version: 0.1.7
 platform: ruby
 authors:
 - Pete Brumm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.0
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.12.0
 description: Creates a binary data file that can be imported into postgres's copy
@@ -51,13 +46,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - examples/fast_load.rb
 - lib/pg_data_encoder.rb
+- lib/pg_data_encoder/decoder.rb
 - lib/pg_data_encoder/encode_for_copy.rb
 - lib/pg_data_encoder/temp_buffer.rb
 - lib/pg_data_encoder/version.rb
@@ -76,6 +72,9 @@ files:
 - spec/fixtures/date.dat
 - spec/fixtures/date2.dat
 - spec/fixtures/date2000.dat
+- spec/fixtures/dates.dat
+- spec/fixtures/dates_p924.dat
+- spec/fixtures/dates_pg935.dat
 - spec/fixtures/empty_uuid.dat
 - spec/fixtures/falseclass.dat
 - spec/fixtures/float.dat
@@ -86,6 +85,8 @@ files:
 - spec/fixtures/multiline_hstore.dat
 - spec/fixtures/output.dat
 - spec/fixtures/timestamp.dat
+- spec/fixtures/timestamp_9.3.dat
+- spec/fixtures/timestamp_big.dat
 - spec/fixtures/trueclass.dat
 - spec/fixtures/utf8.dat
 - spec/fixtures/uuid.dat
@@ -93,30 +94,30 @@ files:
 - spec/multiline_spec.rb
 - spec/spec_helper.rb
 - spec/verify_data_formats_spec.rb
+- spec/verify_decoder_spec.rb
 homepage: https://github.com/pbrumm/pg_data_encoder
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: for faster input of data into postgres you can use this to generate the binary
   import and run COPY FROM
 test_files:
@@ -134,6 +135,9 @@ test_files:
 - spec/fixtures/date.dat
 - spec/fixtures/date2.dat
 - spec/fixtures/date2000.dat
+- spec/fixtures/dates.dat
+- spec/fixtures/dates_p924.dat
+- spec/fixtures/dates_pg935.dat
 - spec/fixtures/empty_uuid.dat
 - spec/fixtures/falseclass.dat
 - spec/fixtures/float.dat
@@ -144,6 +148,8 @@ test_files:
 - spec/fixtures/multiline_hstore.dat
 - spec/fixtures/output.dat
 - spec/fixtures/timestamp.dat
+- spec/fixtures/timestamp_9.3.dat
+- spec/fixtures/timestamp_big.dat
 - spec/fixtures/trueclass.dat
 - spec/fixtures/utf8.dat
 - spec/fixtures/uuid.dat
@@ -151,4 +157,4 @@ test_files:
 - spec/multiline_spec.rb
 - spec/spec_helper.rb
 - spec/verify_data_formats_spec.rb
-has_rdoc: 
+- spec/verify_decoder_spec.rb