vertica 1.0.0.rc1 → 1.0.0.rc2

data/test/unit/column_test.rb

@@ -1,51 +1,41 @@
 require 'test_helper'
 
 class ColumnTest < Minitest::Test
-
-  def test_initialize_from_row_description
-    field_description = {
+  def setup
+    @field_description = {
       :name               => "OUTPUT",
       :table_oid          => 0,
       :attribute_number   => 0,
       :data_type_oid      => 6,
       :data_type_size     => 8,
       :data_type_modifier => 8,
-      :format_code        => 0
+      :data_format        => 0
     }
+  end
 
-    column = Vertica::Column.new(field_description)
+  def test_initialize_from_row_description
+    column = Vertica::Column.build(@field_description)
     assert_equal 'OUTPUT', column.name
-    assert_equal :integer, column.data_type
-    assert_equal 8, column.data_type_modifier
+    assert_equal 'integer', column.data_type.name
+    assert_equal 8, column.data_type.modifier
+    assert_equal 8, column.data_type.size
   end
 
   def test_unknown_type_oid
-    field_description = {
-      :name               => "OUTPUT",
-      :table_oid          => 0,
-      :attribute_number   => 0,
-      :data_type_oid      => 123456,
-      :data_type_size     => 8,
-      :data_type_modifier => 8,
-      :format_code        => 0
-    }
-
-    assert_raises(Vertica::Error::UnknownTypeError) { Vertica::Column.new(field_description) }
+    field_description = @field_description.merge(data_type_oid: 123456)
+    assert_raises(Vertica::Error::UnknownTypeError) { Vertica::Column.build(field_description) }
   end
 
-  def test_integer_converter
-    field_description = {
-      :name               => "OUTPUT",
-      :table_oid          => 0,
-      :attribute_number   => 0,
-      :data_type_oid      => 6,
-      :data_type_size     => 8,
-      :data_type_modifier => 8,
-      :format_code        => 0
-    }
+  def test_equality
+    column = Vertica::Column.build(@field_description)
+
+    assert_equal column, Vertica::Column.build(@field_description)
+    refute_equal column, Vertica::Column.build(@field_description.merge(name: 'other'))
+    refute_equal column, Vertica::Column.build(@field_description.merge(data_format: 1))
+  end
 
-    column = Vertica::Column.new(field_description)
-    assert_equal :integer, column.data_type
-    assert_equal 1234, column.convert('1234')
+  def test_inspect
+    column = Vertica::Column.build(@field_description)
+    assert_equal '#<Vertica::Column name="OUTPUT" data_type=#<Vertica::DataType:6 "integer">>', column.inspect
   end
 end

data/test/unit/data_type_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class DataTypeTest < Minitest::Test
+  def test_equality
+    type = Vertica::DataType.new(oid: 6, size: 4)
+
+    assert_equal type, Vertica::DataType.new(oid: 6, size: 4)
+    assert_equal type, Vertica::DataType.new(oid: 6, size: 4, modifier: nil)
+
+    refute_equal type, Vertica::DataType.new(oid: 6, size: 10)
+    refute_equal type, Vertica::DataType.new(oid: 6, size: 4, modifier: 'unsigned')
+    refute_equal type, Vertica::DataType.new(oid: 6, size: 1)
+    refute_equal type, Vertica::DataType.new(oid: 7, size: 4)
+  end
+
+  def test_inspect
+    type = Vertica::DataType.new(oid: 6, name: "integer", size: 4)
+    assert_equal '#<Vertica::DataType:6 "integer">', type.inspect
+  end
+
+  def test_deserialize_bool
+    type = Vertica::DataType.build(oid: 5)
+
+    assert_nil type.deserialize(nil)
+    assert_equal true, type.deserialize('t')
+    assert_equal false, type.deserialize('f')
+    assert_raises(ArgumentError) { type.deserialize('foo') }
+  end
+
+  def test_deserialize_integer
+    type = Vertica::DataType.build(oid: 6)
+
+    assert_nil type.deserialize(nil)
+    assert_equal 0, type.deserialize('0')
+    assert_equal -123, type.deserialize('-123')
+    assert_raises(ArgumentError) { type.deserialize('foo') }
+  end
+
+  def test_deserialize_float
+    type = Vertica::DataType.build(oid: 7)
+
+    assert_nil type.deserialize(nil)
+    assert_equal Float::INFINITY, type.deserialize('Infinity')
+    assert_equal -Float::INFINITY, type.deserialize('-Infinity')
+    assert type.deserialize('NaN').equal?(Float::NAN)
+    assert_equal 1.1, type.deserialize('1.1')
+    assert_equal -1.1, type.deserialize('-1.1')
+    assert_raises(ArgumentError) { type.deserialize('foo') }
+  end
+
+  def test_deserialize_unicode_string
+    type = Vertica::DataType.build(oid: 115)
+
+    assert_nil type.deserialize(nil)
+    converted = type.deserialize("foo\x00".force_encoding(Encoding::BINARY))
+    assert_equal "foo\x00".force_encoding(Encoding::UTF_8), converted
+  end
+
+  def test_dersialize_binary_string
+    type = Vertica::DataType.build(oid: 17)
+
+    assert_nil type.deserialize(nil)
+    converted = type.deserialize("\\231\\237".force_encoding(Encoding::BINARY))
+    assert_equal "\x99\x9F".force_encoding(Encoding::BINARY), converted
+  end
+
+  def test_deserialize_bigdecimal
+    type = Vertica::DataType.build(oid: 16)
+    assert_nil type.deserialize(nil)
+    assert_equal BigDecimal('1.1'), type.deserialize('1.1')
+  end
+end

data/test/unit/result_test.rb

@@ -4,8 +4,8 @@ class ResultTest < Minitest::Test
   def setup
     @result = Vertica::Result.build(
       row_description: [
-        Vertica::Column.new(name: 'a', data_type_oid: 6),
-        Vertica::Column.new(name: 'b', data_type_oid: 6),
+        Vertica::Column.build(name: 'a', data_type_oid: 6),
+        Vertica::Column.build(name: 'b', data_type_oid: 6),
       ],
       rows: [
         [1, 2],

data/test/unit/row_description_test.rb

@@ -4,8 +4,8 @@ class RowDescriptionTest < Minitest::Test
   def setup
     @message = Vertica::Protocol::RowDescription.new("\x00\x02id\x00\x00\np8\x00\x01\x00\x00\x00\x06\x00\b\xFF\xFF\xFF\xFF\x00\x00name\x00\x00\np8\x00\x02\x00\x00\x00\t\xFF\xFF\x00\x00\x00h\x00\x00")
 
-    @column1 = Vertica::Column.new(@message.fields[0])
-    @column2 = Vertica::Column.new(@message.fields[1])
+    @column1 = Vertica::Column.build(@message.fields[0])
+    @column2 = Vertica::Column.build(@message.fields[1])
 
     @row_description = Vertica::RowDescription.build([@column1, @column2])
   end
@@ -53,4 +53,33 @@ class RowDescriptionTest < Minitest::Test
     hash = { 'id' => @column1, 'name' => @column2}
     assert_equal hash, @row_description.to_h
   end
+
+  def test_to_h_with_duplicate_column_name_raises
+    row_description = Vertica::RowDescription.build([@column1, @column1])
+    assert_raises(Vertica::Error::DuplicateColumnName) { row_description.to_h }
+  end
+
+  def test_eql?
+    rd1 = Vertica::RowDescription.build([@column1, @column2])
+    rd1_copy = Vertica::RowDescription.build([@column1, @column2])
+    rd2 = Vertica::RowDescription.build([@column1])
+
+    assert_equal rd1, rd1_copy
+    refute_equal rd1, rd2
+
+    refute_equal rd1, nil
+    refute_equal rd1, Vertica::RowDescription
+    refute_equal rd1, rd2.build_row([1])
+  end
+
+  def test_inspect
+    assert_equal "#<Vertica::RowDescription[id, name]>", @row_description.inspect
+  end
+
+  def test_build_row
+    row1 = @row_description.build_row([1, 'name'])
+    row2 = @row_description.build_row(id: 1, name: 'name')
+
+    assert_equal row1, row2
+  end
 end

data/test/unit/row_test.rb

@@ -4,8 +4,8 @@ class RowTest < Minitest::Test
   def setup
     @message = Vertica::Protocol::RowDescription.new("\x00\x02id\x00\x00\np8\x00\x01\x00\x00\x00\x06\x00\b\xFF\xFF\xFF\xFF\x00\x00name\x00\x00\np8\x00\x02\x00\x00\x00\t\xFF\xFF\x00\x00\x00h\x00\x00")
 
-    @column1 = Vertica::Column.new(@message.fields[0])
-    @column2 = Vertica::Column.new(@message.fields[1])
+    @column1 = Vertica::Column.build(@message.fields[0])
+    @column2 = Vertica::Column.build(@message.fields[1])
 
     @row_description = Vertica::RowDescription.build([@column1, @column2])
   end
@@ -28,4 +28,28 @@ class RowTest < Minitest::Test
     hash = { 'id' => 123, 'name' => 'test' }
     assert_equal hash, row.to_h
   end
+
+  def test_to_h_with_duplicate_column_name_raises
+    row_description = Vertica::RowDescription.build([@column1, @column1])
+    row = Vertica::Row.new(row_description, [123, 456])
+
+    assert_raises(Vertica::Error::DuplicateColumnName) { row.to_h }
+  end
+
+  def test_eql?
+    rd1 = Vertica::RowDescription.build([@column1, @column2])
+    rd2 = Vertica::RowDescription.build([@column1, @column1])
+
+    row = Vertica::Row.new(rd1, [123, 'test'])
+
+    assert_equal row, Vertica::Row.new(rd1, [123, 'test'])
+    refute_equal rd1, Vertica::Row.new(rd1, [124, 'test'])
+    refute_equal rd1, Vertica::Row.new(rd2, [123, 'test'])
+    refute_equal rd1, nil
+  end
+
+  def test_inspect
+    row = Vertica::Row.new(@row_description, [123, 'test'])
+    assert_equal "#<Vertica::Row[123, \"test\"]>", row.inspect
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vertica
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
 platform: ruby
 authors:
 - Jeff Smick
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-05 00:00:00.000000000 Z
+date: 2016-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -80,6 +80,7 @@ extra_rdoc_files:
 files:
 - .gitignore
 - .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -87,6 +88,7 @@ files:
 - lib/vertica.rb
 - lib/vertica/column.rb
 - lib/vertica/connection.rb
+- lib/vertica/data_type.rb
 - lib/vertica/error.rb
 - lib/vertica/protocol/backend/authentication.rb
 - lib/vertica/protocol/backend/backend_key_data.rb
@@ -131,11 +133,12 @@ files:
 - test/connection.yml.example
 - test/functional/functional_connection_test.rb
 - test/functional/functional_query_test.rb
-- test/functional/functional_value_conversion_test.rb
+- test/functional/functional_type_deserialization_test.rb
 - test/resources/test_ruby_vertica_table.csv
 - test/test_helper.rb
 - test/unit/backend_message_test.rb
 - test/unit/column_test.rb
+- test/unit/data_type_test.rb
 - test/unit/frontend_message_test.rb
 - test/unit/quoting_test.rb
 - test/unit/result_test.rb
@@ -172,11 +175,12 @@ test_files:
 - test/connection.yml.example
 - test/functional/functional_connection_test.rb
 - test/functional/functional_query_test.rb
-- test/functional/functional_value_conversion_test.rb
+- test/functional/functional_type_deserialization_test.rb
 - test/resources/test_ruby_vertica_table.csv
 - test/test_helper.rb
 - test/unit/backend_message_test.rb
 - test/unit/column_test.rb
+- test/unit/data_type_test.rb
 - test/unit/frontend_message_test.rb
 - test/unit/quoting_test.rb
 - test/unit/result_test.rb

data/test/functional/functional_value_conversion_test.rb

@@ -1,117 +0,0 @@
-# encoding : UTF-8
-require 'test_helper'
-
-class FunctionalValueConversionTest < Minitest::Test
-
-  def setup
-    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
-
-    @connection.query <<-SQL
-      CREATE TABLE IF NOT EXISTS conversions_table (
-        "int_field" int,
-        "string_field" varchar(100),
-        "date_field" date,
-        "timestamp_field" timestamp,
-        "timestamptz_field" timestamptz,
-        "time_field" time,
-        "interval_field" interval,
-        "boolean_field" boolean,
-        "float_field" float,
-        "float_zero" float,
-        "binary_field" varbinary,
-        "long_varchar_field" long varchar
-      )
-    SQL
-  end
-
-
-  def teardown
-    @connection.query("DROP TABLE IF EXISTS conversions_table CASCADE;")
-    @connection.close
-  end
-
-  def test_value_conversions
-    @connection.query <<-SQL
-      INSERT INTO conversions_table VALUES (
-          123,
-          'hello world',
-          '2010-01-01',
-          '2010-01-01 12:00:00.123456',
-          '2010-01-01 12:00:00 +0930',
-          '12:00:00',
-          INTERVAL '1 DAY',
-          TRUE,
-          1.0,
-          0.0,
-          HEX_TO_BINARY('d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21'),
-          'hello world'
-      )
-    SQL
-
-    result = @connection.query <<-SQL
-      SELECT *,
-             float_field / float_zero as infinity,
-             float_field / float_zero - float_field / float_zero as nan
-        FROM conversions_table LIMIT 1
-    SQL
-
-    assert_equal result.rows.length, 1
-    assert_equal [
-      123,
-      'hello world',
-      Date.parse('2010-01-01'),
-      Time.new(2010, 1, 1, 12, 0, BigDecimal.new("0.123456")),
-      Time.new(2010, 1, 1, 12, 0, 0, '+09:30'),
-      "12:00:00",
-      "1",
-      true,
-      1.0,
-      0.0,
-      ['d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21'].pack('H*'),
-      'hello world',
-      Float::INFINITY,
-      Float::NAN
-    ], result[0].to_a
-  end
-
-  def test_nil_conversions
-    @connection.query "INSERT INTO conversions_table VALUES (NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)"
-    result = @connection.query "SELECT * FROM conversions_table LIMIT 1"
-    assert_equal result.rows.length, 1
-    assert_equal [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil], result[0].to_a
-  end
-
-  def test_string_decoding
-    assert_equal 'åßç∂ë', @connection.query("SELECT 'åßç∂ë'").the_value
-    assert_equal Encoding::UTF_8, @connection.query("SELECT 'åßç∂ë'").the_value.encoding
-  end
-
-  def test_binary_decoding
-    assert_equal ['d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21'].pack('H*'), @connection.query("SELECT HEX_TO_BINARY('d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21')").the_value
-    assert_equal Encoding::BINARY, @connection.query("SELECT HEX_TO_BINARY('d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21')").the_value.encoding
-  end
-
-  def test_timestamp_decoding_with_utc_timezone_connection
-    @connection.query("SET TIMEZONE TO 'UTC'")
-
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16), @connection.query("SELECT '2013-01-02 14:15:16'::timestamp").the_value
-    assert_equal Time.new(2013, 1, 2, 19, 15, 16), @connection.query("SELECT '2013-01-02 14:15:16 America/Toronto'::timestamp").the_value
-    assert_equal Time.new(2013, 1, 2,  4, 45, 16), @connection.query("SELECT '2013-01-02 14:15:16 +9:30'::timestamp").the_value
-
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '+00:00'), @connection.query("SELECT '2013-01-02 14:15:16'::timestamptz").the_value
-    assert_equal Time.new(2013, 1, 2, 19, 15, 16, '+00:00'), @connection.query("SELECT '2013-01-02 14:15:16 America/Toronto'::timestamptz").the_value
-    assert_equal Time.new(2013, 1, 2,  4, 45, 16, '+00:00'), @connection.query("SELECT '2013-01-02 14:15:16 +09:30'::timestamptz").the_value
-  end
-
-  def test_timestamp_decoding_with_toronto_timezone_connection
-    @connection.query("SET TIMEZONE TO 'America/Toronto'")
-
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16), @connection.query("SELECT '2013-01-02 14:15:16'::timestamp").the_value
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16), @connection.query("SELECT '2013-01-02 14:15:16 America/Toronto'::timestamp").the_value
-    assert_equal Time.new(2013, 1, 1, 23, 45, 16), @connection.query("SELECT '2013-01-02 14:15:16 +9:30'::timestamp").the_value
-
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '-05:00'), @connection.query("SELECT '2013-01-02 14:15:16'::timestamptz").the_value
-    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '-05:00'), @connection.query("SELECT '2013-01-02 14:15:16 America/Toronto'::timestamptz").the_value
-    assert_equal Time.new(2013, 1, 1, 23, 45, 16, '-05:00'), @connection.query("SELECT '2013-01-02 14:15:16 +09:30'::timestamptz").the_value
-  end
-end