vertica 1.0.0.rc1 → 1.0.0.rc2

data/lib/vertica/row_description.rb

@@ -1,10 +1,21 @@
+# Class that describes the shape of a query result. It contains an ordered list
+# of {Vertica::Column} instances, which describes the columns that will apear for
+# every {Vertica::Row} part of the result of a query.
+#
+# @see Vertica::Row
+# @see Vertica::Result
 class Vertica::RowDescription
   include Enumerable
 
+  # Builds a new Vertica::RowDescription instance given a list of columns.
+  # @param columns [Vertica::Protocol::RowDescription, Vertica::RowDescription, Array<Vertica::Column>]
+  #   An object that describes the list of columns.
+  # @return [Vertica::RowDescription]
+  # @raise [ArgumentError] If no Vertica::RowDescription could be constructed given the provided argument.
   def self.build(columns)
     case columns
     when Vertica::Protocol::RowDescription
-      new(columns.fields.map { |fd| Vertica::Column.new(fd) })
+      new(columns.fields.map { |fd| Vertica::Column.build(fd) })
     when Vertica::RowDescription
       columns
     when Array
@@ -16,49 +27,84 @@ class Vertica::RowDescription
     end
   end
 
+  # @param columns [Array<Vertica::Column>] The list of columns as they will
+  #   appear in the rows of a query result.
+  # @see Vertica::RowDescription.build
   def initialize(columns)
     @columns = columns
   end
 
+  # Returns a column in this row description.
+  # @param name_or_index [String, Symbol, Integer] The name of the column, or
+  #   the index of the column in this row description.
+  # @return [Vertica::Column]
+  # @raise [KeyError] if the column could not be found in this row description.
   def column(name_or_index)
     column_with_index(name_or_index).first
   end
 
   alias_method :[], :column
 
+  # Returns a column, accompanied by the index of that column in this row description.
+  # @param name_or_index [String, Symbol, Integer] The name of the column, or
+  #   the index of the column in this row description.
+  # @return [Array<Vertica::Column, Integer>]
+  # @raise [KeyError] if the column could not be found in this row description.
   def column_with_index(name_or_index)
     columns_index.fetch(name_or_index)
   end
 
+  # Iterates over the columns in this row description.
+  # @yield The provided block will be called with every column.
+  # @yieldparam column [Vertica::Column]
+  # @return [void]
   def each(&block)
     @columns.each(&block)
   end
 
+  # @return [Integer] Returns the number of columns in this row description.
   def size
     @columns.size
   end
 
   alias_method :length, :size
 
+  # @return [Array<Vertica::Column>] Returns the columns of this row description as an array.
   def to_a
     @columns.clone
   end
 
+  # @param symbolize_keys [Boolean] Whether to use symbols instead of strings as keys.
+  # @return [Hash] Returns the columns of this row description as a hash, index by the
+  #   column name.
+  # @raise [Vertica::Error::DuplicateColumnName] If the row description contains multiple
+  #   columns with the same name
   def to_h(symbolize_keys: false)
     @columns.inject({}) do |carry, column|
       key = symbolize_keys ? column.name.to_sym : column.name
-      carry.merge(key => column)
+      raise Vertica::Error::DuplicateColumnName, "Column with name #{key} occurs more than once in this row description." if carry.key?(key)
+      carry[key] = column
+      carry
     end
   end
 
+  # Builds a {Vertica::Row} instance given a list of values that conforms to
+  # this row description.
+  # @param [Array, Hash, Vertica::Protocol::DataRow] values A list of values. The number
+  #   of values should match the number of columns in the row description.
+  # @raise [ArgumentError] An ArgumentErrpr is raised if the number of values does not match
+  #   the row description, or if a type is provided that it cannot handle.
+  # @return [Vertica::Row] The row instance.
   def build_row(values)
     case values
     when Vertica::Row
+      raise ArgumentError, "Row description of provided row does match this row description" if values.row_description != self
       values
 
     when Vertica::Protocol::DataRow
+      raise ArgumentError, "Number of values does not match row description" if values.values.size != size
       converted_values = @columns.map.with_index do |column, index|
-        column.convert(values.values.fetch(index))
+        column.data_type.deserialize(values.values.fetch(index))
       end
       Vertica::Row.new(self, converted_values)
 
@@ -76,16 +122,23 @@ class Vertica::RowDescription
     end
   end
 
+  # @return [Boolean] Returns true iff this record is equal to the other provided object
   def eql?(other)
     self.class === other && other.to_a == self.to_a
   end
 
   alias_method :==, :eql?
 
+  # @return [Integer]  Returns a hash digtest of this object.
   def hash
     @columns.hash
   end
 
+  # @return [String] Returns a user-consumable string representation of this row description.
+  def inspect
+    "#<#{self.class.name}[#{@columns.map(&:name).join(', ')}]>"
+  end
+
   protected
 
   def columns_index

data/lib/vertica/version.rb

@@ -1,3 +1,5 @@
 module Vertica
-  VERSION = "1.0.0.rc1"
+  # The version of the package. We adhere to semantic versioning.
+  # To release a new version, update this constant, commit to master, and run `rake release`
+  VERSION = "1.0.0.rc2"
 end

data/test/functional/functional_connection_test.rb

@@ -16,7 +16,7 @@ class FunctionalConnectionTest < Minitest::Test
 
     connection.close
     assert_valid_closed_connection(connection)
-    assert !connection.ssl?
+    refute connection.ssl?
 
   rescue Vertica::Error::SSLNotSupported
     puts "\nThe test server doesn't support SSL, so SSL connections could not be tested."
@@ -93,7 +93,7 @@ class FunctionalConnectionTest < Minitest::Test
     TCPSocket.any_instance.expects(:read_nonblock).raises(Errno::ETIMEDOUT)
 
     assert_raises(Vertica::Error::ConnectionError) { Vertica::Connection.new(TEST_CONNECTION_HASH) }
-    end
+  end
 
   def test_socket_write_error_during_query
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH)

data/test/functional/functional_query_test.rb

@@ -23,9 +23,9 @@ class FunctionalQueryTest < Minitest::Test
     r = @connection.query("SELECT * FROM test_ruby_vertica_table")
     assert_equal 1, r.size
     assert_equal 2, r.row_description.length
-    assert_equal :integer, r.columns[0].data_type
+    assert_equal 'integer', r.columns[0].data_type.name
     assert_equal 'id', r.columns[0].name
-    assert_equal :varchar, r.columns[1].data_type
+    assert_equal 'varchar', r.columns[1].data_type.name
     assert_equal 'name', r.columns[1].name
 
     assert_equal 1, r[0][:id]
@@ -36,6 +36,7 @@ class FunctionalQueryTest < Minitest::Test
     rows = []
     result = @connection.query("SELECT 1 AS a, 2 AS b UNION ALL SELECT 3, 4") do |row|
       assert_kind_of Vertica::Row, row
+      assert_kind_of Vertica::RowDescription, row.row_description
       rows << row
     end
 
@@ -64,11 +65,11 @@ class FunctionalQueryTest < Minitest::Test
     assert_equal "SELECT", r.tag
     assert_equal 0, r.size
     assert_equal 2, r.columns.length
-    assert_equal :integer, r.columns[0].data_type
+    assert_equal 'integer', r.columns[0].data_type.name
     assert_equal 'id', r.columns[0].name
-    assert_equal :varchar, r.columns[1].data_type
+    assert_equal 'varchar', r.columns[1].data_type.name
     assert_equal 'name', r.columns[1].name
-    assert_empty r.rows
+    assert_empty r
   end
 
   def test_insert
@@ -76,7 +77,7 @@ class FunctionalQueryTest < Minitest::Test
     assert_equal "INSERT", r.tag
     assert_equal 1, r.size
     assert_equal 1, r.columns.length
-    assert_equal :integer, r.columns[0].data_type
+    assert_equal 'integer', r.columns[0].data_type.name
     assert_equal 'OUTPUT', r.columns[0].name
     assert_equal 1, r.value
   end
@@ -87,7 +88,7 @@ class FunctionalQueryTest < Minitest::Test
     assert_equal "DELETE", r.tag
     assert_equal 1, r.size
     assert_equal 1, r.columns.length
-    assert_equal :integer, r.columns[0].data_type
+    assert_equal 'integer', r.columns[0].data_type.name
     assert_equal 'OUTPUT', r.columns[0].name
     assert_equal 0, r.value
   end
@@ -97,7 +98,7 @@ class FunctionalQueryTest < Minitest::Test
     assert_equal "DELETE", r.tag
     assert_equal 1, r.size
     assert_equal 1, r.columns.length
-    assert_equal :integer, r.columns[0].data_type
+    assert_equal 'integer', r.columns[0].data_type.name
     assert_equal 'OUTPUT', r.columns[0].name
     assert_equal 1, r.value
   end
@@ -119,9 +120,9 @@ class FunctionalQueryTest < Minitest::Test
       r = @connection.query("SELECT * FROM test_ruby_vertica_table")
       assert_equal 1, r.size
       assert_equal 2, r.columns.length
-      assert_equal :integer, r.columns[0].data_type
+      assert_equal 'integer', r.columns[0].data_type.name
       assert_equal 'id', r.columns[0].name
-      assert_equal :varchar, r.columns[1].data_type
+      assert_equal 'varchar', r.columns[1].data_type.name
       assert_equal 'name', r.columns[1].name
       assert_equal [{'id' => 1, 'name' => "matt"}], r.map(&:to_h)
     end
@@ -156,11 +157,13 @@ class FunctionalQueryTest < Minitest::Test
   end
 
   def test_copy_in_with_customer_handler
-    @connection.copy("COPY test_ruby_vertica_table FROM STDIN") do |data|
+    copy_result = @connection.copy("COPY test_ruby_vertica_table FROM STDIN") do |data|
       data.write "11|Stuff\r\n"
       data << "12|More stuff\n13|Fin" << "al stuff\n"
     end
 
+    assert_equal "COPY", copy_result
+
     result = @connection.query("SELECT * FROM test_ruby_vertica_table ORDER BY id")
     assert_equal 4, result.length
     assert_equal [[1, "matt"], [11, "Stuff"], [12, "More stuff"], [13, "Final stuff"]], result.map(&:to_a)

data/test/functional/functional_type_deserialization_test.rb

@@ -0,0 +1,179 @@
+# encoding : UTF-8
+require 'test_helper'
+
+class FunctionalTypeDeserializationTest < Minitest::Test
+
+  def setup
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
+
+    @connection.query <<-SQL
+      CREATE TABLE IF NOT EXISTS conversions_table (
+        "int_field" int,
+        "varchar_field" varchar(100),
+        "char_field" char(10),
+        "long_varchar_field" long varchar,
+        "date_field" date,
+        "timestamp_field" timestamp,
+        "timestamptz_field" timestamptz,
+        "time_field" time,
+        "interval_field" interval,
+        "boolean_field" boolean,
+        "float_field" float,
+        "numeric_field" numeric(10, 2),
+        "binary_field" varbinary
+      )
+    SQL
+  end
+
+
+  def teardown
+    @connection.query("DROP TABLE IF EXISTS conversions_table CASCADE;")
+    @connection.close
+  end
+
+  def test_deserialize_values_from_table
+    @connection.query <<-SQL
+      INSERT INTO conversions_table VALUES (
+          123,
+          'hello world',
+          'hello',
+          '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.123,
+          1.12345,
+          HEX_TO_BINARY('d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21')
+      )
+    SQL
+
+    result = @connection.query("SELECT * FROM conversions_table LIMIT 1")
+
+    assert_equal 1, result.size
+    assert_equal 123, result.fetch(0, 'int_field')
+    assert_equal 'hello world', result.fetch(0, 'varchar_field')
+    assert_equal 'hello     ', result.fetch(0, 'char_field')
+    assert_equal 'hello world', result.fetch(0, 'long_varchar_field')
+    assert_equal Date.parse('2010-01-01'), result.fetch(0, 'date_field')
+    assert_equal Time.new(2010, 1, 1, 12, 0, BigDecimal.new("0.123456")), result.fetch(0, 'timestamp_field')
+    assert_equal Time.new(2010, 1, 1, 12, 0, 0, '+09:30'), result.fetch(0, 'timestamptz_field')
+    assert_equal "12:00:00", result.fetch(0, 'time_field')
+    assert_equal "1", result.fetch(0, 'interval_field')
+    assert_equal true, result.fetch(0, 'boolean_field')
+    assert_equal -1.123, result.fetch(0, 'float_field')
+    assert_equal BigDecimal.new('1.12'), result.fetch(0, 'numeric_field')
+    assert_equal ['d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21'].pack('H*'), result.fetch(0, 'binary_field')
+  end
+
+  def test_nil_values_from_table
+    @connection.query("INSERT INTO conversions_table VALUES (NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)")
+    result = @connection.query("SELECT * FROM conversions_table LIMIT 1")
+    assert_equal 1, result.size
+    assert result[0].all?(&:nil?)
+  end
+
+  def test_deserialize_float_values
+    result = @connection.query(<<-SQL)
+      SELECT 0::float,
+             -0::float,
+             1.1::float,
+             -1.1::float,
+             1.0::float / 0.0::float,
+             -1.0::float / 0.0::float,
+             1.0::float / 0.0::float - 1.0::float / 0.0::float,
+             NULL::float
+    SQL
+
+    assert_equal 1, result.size
+    assert_equal 0.0, result[0, 0]
+    assert_equal -0.0, result[0, 1]
+    assert_equal 1.1, result[0, 2]
+    assert_equal -1.1, result[0, 3]
+    assert_equal Float::INFINITY, result[0, 4]
+    assert_equal -Float::INFINITY, result[0, 5]
+    assert result[0, 6].equal?(Float::NAN)
+    assert_nil result[0, 7]
+  end
+
+  def test_deserialize_numeric_values
+    result = @connection.query(<<-SQL)
+      SELECT '1'::numeric(5,2),
+             '1.12'::numeric(5,2),
+             '1.1234'::numeric(5,2),
+             '1.1234'::numeric,
+             '0'::numeric,
+             '-0'::numeric,
+             NULL::numeric
+    SQL
+
+    assert_equal 1, result.size
+    assert_equal BigDecimal.new('1.00'), result.fetch(0, 0)
+    assert_equal BigDecimal.new('1.12'), result.fetch(0, 1)
+    assert_equal BigDecimal.new('1.12'), result.fetch(0, 2)
+    assert_equal BigDecimal.new('1.1234'), result.fetch(0, 3)
+    assert_equal BigDecimal.new('0'), result.fetch(0, 4)
+    assert_equal BigDecimal.new('-0'), result.fetch(0, 5)
+    assert_nil result.fetch(0, 6)
+  end
+
+  def test_deserialize_string_values
+    assert_equal 'åßç∂ë', @connection.query("SELECT 'åßç∂ë'").the_value
+    assert_equal Encoding::UTF_8, @connection.query("SELECT 'åßç∂ë'").the_value.encoding
+  end
+
+  def test_deserialize_binary_values
+    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_deserialize_timestamp_values_with_utc_timezone_connection
+    @connection.query("SET TIMEZONE TO 'UTC'")
+
+    result = @connection.query(<<-SQL)
+      SELECT '2013-01-02 14:15:16'::timestamp,
+             '2013-01-02 14:15:16 America/Toronto'::timestamp,
+             '2013-01-02 14:15:16 +9:30'::timestamp,
+             '2013-01-02 14:15:16'::timestamptz,
+             '2013-01-02 14:15:16 America/Toronto'::timestamptz,
+             '2013-01-02 14:15:16 +9:30'::timestamptz,
+             NULL::timestamp,
+             NULL::timestamptz
+    SQL
+
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16), result.fetch(0, 0)
+    assert_equal Time.new(2013, 1, 2, 19, 15, 16), result.fetch(0, 1)
+    assert_equal Time.new(2013, 1, 2,  4, 45, 16), result.fetch(0, 2)
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '+00:00'), result.fetch(0, 3)
+    assert_equal Time.new(2013, 1, 2, 19, 15, 16, '+00:00'), result.fetch(0, 4)
+    assert_equal Time.new(2013, 1, 2,  4, 45, 16, '+00:00'), result.fetch(0, 5)
+    assert_nil result.fetch(0, 6)
+    assert_nil result.fetch(0, 7)
+  end
+
+  def test_deserialize_timestamp_values_with_toronto_timezone_connection
+    @connection.query("SET TIMEZONE TO 'America/Toronto'")
+
+    result = @connection.query(<<-SQL)
+      SELECT '2013-01-02 14:15:16'::timestamp,
+             '2013-01-02 14:15:16 America/Toronto'::timestamp,
+             '2013-01-02 14:15:16 +9:30'::timestamp,
+             '2013-01-02 14:15:16'::timestamptz,
+             '2013-01-02 14:15:16 America/Toronto'::timestamptz,
+             '2013-01-02 14:15:16 +9:30'::timestamptz,
+             NULL::timestamp,
+             NULL::timestamptz
+    SQL
+
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16), result.fetch(0, 0)
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16), result.fetch(0, 1)
+    assert_equal Time.new(2013, 1, 1, 23, 45, 16), result.fetch(0, 2)
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '-05:00'), result.fetch(0, 3)
+    assert_equal Time.new(2013, 1, 2, 14, 15, 16, '-05:00'), result.fetch(0, 4)
+    assert_equal Time.new(2013, 1, 1, 23, 45, 16, '-05:00'), result.fetch(0, 5)
+    assert_nil result.fetch(0, 6)
+    assert_nil result.fetch(0, 7)
+  end
+end

data/test/unit/backend_message_test.rb

@@ -74,7 +74,7 @@ class BackendMessageTest < Minitest::Test
       :data_type_oid      => 6,
       :data_type_size     => 8,
       :data_type_modifier => 8,
-      :format_code        => 0
+      :data_format        => 0
     }
 
     msg = 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")
@@ -85,7 +85,7 @@ class BackendMessageTest < Minitest::Test
       :data_type_oid      => 6,
       :data_type_size     => 8,
       :data_type_modifier => 4294967295,
-      :format_code        => 0
+      :data_format        => 0
     }
     assert_equal msg.fields[1], {
       :name               => "name",
@@ -94,7 +94,7 @@ class BackendMessageTest < Minitest::Test
       :data_type_oid      => 9,
       :data_type_size     => 65535,
       :data_type_modifier => 104,
-      :format_code        => 0
+      :data_format        => 0
     }
   end
 
@@ -112,7 +112,5 @@ class BackendMessageTest < Minitest::Test
   def test_command_complete_message
     msg = Vertica::Protocol::CommandComplete.new("CREATE TABLE\x00")
     assert_equal "CREATE TABLE", msg.tag
-    assert_nil msg.rows
-    assert_nil msg.oid
   end
 end