vertica 0.12.0 → 1.0.0.rc1

data/test/functional/functional_value_conversion_test.rb

@@ -0,0 +1,117 @@
+# 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

data/test/test_helper.rb

@@ -1,9 +1,9 @@
-require 'rubygems'
 require 'bundler/setup'
 
 require 'yaml'
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'mocha/mini_test'
 
 require 'vertica'
 

data/test/unit/backend_message_test.rb

@@ -1,61 +1,61 @@
 require 'test_helper'
 
 class BackendMessageTest < Minitest::Test
-  
+
   def test_cleartext_authentication_message
-    msg = Vertica::Messages::Authentication.new("\x00\x00\x00\x03")
-    assert_equal Vertica::Messages::Authentication::CLEARTEXT_PASSWORD , msg.code
+    msg = Vertica::Protocol::Authentication.new("\x00\x00\x00\x03")
+    assert_equal Vertica::Protocol::Authentication::CLEARTEXT_PASSWORD , msg.code
     assert_nil msg.salt
     assert_nil msg.auth_data
   end
-  
+
   def test_parameter_status_message
-    msg = Vertica::Messages::ParameterStatus.new("standard_conforming_strings\x00on\x00")
+    msg = Vertica::Protocol::ParameterStatus.new("standard_conforming_strings\x00on\x00")
     assert_equal "standard_conforming_strings", msg.name
     assert_equal "on", msg.value
   end
-  
+
   def test_backend_key_data_message
-    msg = Vertica::Messages::BackendKeyData.new("\x00\x01\xED\xD8\x02\xC4\"\t")
+    msg = Vertica::Protocol::BackendKeyData.new("\x00\x01\xED\xD8\x02\xC4\"\t")
     assert_equal 126424, msg.pid
     assert_equal 46408201, msg.key
   end
-  
+
   def test_ready_for_query_message
-    msg = Vertica::Messages::ReadyForQuery.new("I")
+    msg = Vertica::Protocol::ReadyForQuery.new("I")
     assert_equal :no_transaction, msg.transaction_status
   end
-  
+
   def test_error_response_message
     data = "SFATAL\x00C3D000\x00Mdatabase \"nonexistant_db\" does not exist\x00F/scratch_a/release/vbuild/vertica/Basics/ClientAuthentication.cpp\x00L1496\x00RClientAuthentication\x00\x00"
-    msg = Vertica::Messages::ErrorResponse.new(data)
+    msg = Vertica::Protocol::ErrorResponse.new(data)
     assert_equal msg.values, {
-      "Severity" => "FATAL", 
-      "Sqlstate" => "3D000", 
-      "Message"  => "database \"nonexistant_db\" does not exist", 
-      "File"     => "/scratch_a/release/vbuild/vertica/Basics/ClientAuthentication.cpp", 
-      "Line"     => "1496", 
+      "Severity" => "FATAL",
+      "Sqlstate" => "3D000",
+      "Message"  => "database \"nonexistant_db\" does not exist",
+      "File"     => "/scratch_a/release/vbuild/vertica/Basics/ClientAuthentication.cpp",
+      "Line"     => "1496",
       "Routine"  => "ClientAuthentication"
     }
-    
+
     assert_equal "Severity: FATAL, Message: database \"nonexistant_db\" does not exist, Sqlstate: 3D000, Routine: ClientAuthentication, File: /scratch_a/release/vbuild/vertica/Basics/ClientAuthentication.cpp, Line: 1496", msg.error_message
   end
-  
+
   def test_error_response_fields
     data = "SFATAL\x00C3D000\x00Mdatabase \"nonexistant_db\" does not exist\x00F/scratch_a/release/vbuild/vertica/Basics/ClientAuthentication.cpp\x00L1496\x00RClientAuthentication\x00\x00"
-    msg = Vertica::Messages::ErrorResponse.new(data)
+    msg = Vertica::Protocol::ErrorResponse.new(data)
 
     assert_equal "FATAL", msg.severity
     assert_equal "ClientAuthentication", msg.routine
   end
-  
-  
+
+
   def test_notice_response_values
     data = "SINFO\x00C00000\x00Mcannot commit; no transaction in progress\x00F/scratch_a/release/vbuild/vertica/Commands/PGCall.cpp\x00L3502\x00Rprocess_vertica_transaction\x00\x00"
-    msg = Vertica::Messages::NoticeResponse.new(data)
-    
+    msg = Vertica::Protocol::NoticeResponse.new(data)
+
     assert_equal msg.values, {
-      "Severity" => "INFO", 
+      "Severity" => "INFO",
       "Sqlstate" => "00000",
       "Message"  => "cannot commit; no transaction in progress",
       "File"     => "/scratch_a/release/vbuild/vertica/Commands/PGCall.cpp",
@@ -63,54 +63,54 @@ class BackendMessageTest < Minitest::Test
       "Routine"  => "process_vertica_transaction"
     }
   end
-  
+
   def test_row_description_message
-    msg = Vertica::Messages::RowDescription.new("\x00\x01OUTPUT\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\b\x00\x00\x00\b\x00\x00")
+    msg = Vertica::Protocol::RowDescription.new("\x00\x01OUTPUT\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\b\x00\x00\x00\b\x00\x00")
     assert_equal 1, msg.fields.size
     assert_equal msg.fields[0], {
-      :name             => "OUTPUT", 
-      :table_oid        => 0, 
-      :attribute_number => 0, 
-      :data_type_oid    => 6, 
-      :data_type_size   => 8, 
-      :type_modifier    => 8, 
-      :format_code      => 0
+      :name               => "OUTPUT",
+      :table_oid          => 0,
+      :attribute_number   => 0,
+      :data_type_oid      => 6,
+      :data_type_size     => 8,
+      :data_type_modifier => 8,
+      :format_code        => 0
     }
-    
-    msg = Vertica::Messages::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")
+
+    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")
     assert_equal msg.fields[0], {
-      :name             => "id", 
-      :table_oid        => 684088, 
-      :attribute_number => 1, 
-      :data_type_oid    => 6, 
-      :data_type_size   => 8, 
-      :type_modifier    => 4294967295, 
-      :format_code      => 0
+      :name               => "id",
+      :table_oid          => 684088,
+      :attribute_number   => 1,
+      :data_type_oid      => 6,
+      :data_type_size     => 8,
+      :data_type_modifier => 4294967295,
+      :format_code        => 0
     }
     assert_equal msg.fields[1], {
-      :name             => "name",
-      :table_oid        => 684088, 
-      :attribute_number => 2, 
-      :data_type_oid    => 9, 
-      :data_type_size   => 65535, 
-      :type_modifier    => 104, 
-      :format_code      => 0
+      :name               => "name",
+      :table_oid          => 684088,
+      :attribute_number   => 2,
+      :data_type_oid      => 9,
+      :data_type_size     => 65535,
+      :data_type_modifier => 104,
+      :format_code        => 0
     }
   end
-  
+
   def test_data_row_message
-    msg = Vertica::Messages::DataRow.new("\x00\x01\x00\x00\x00\x011")
+    msg = Vertica::Protocol::DataRow.new("\x00\x01\x00\x00\x00\x011")
     assert_equal ['1'], msg.values
-    
-    msg = Vertica::Messages::DataRow.new("\x00\x02\x00\x00\x00\x011\x00\x00\x00\x04matt")
+
+    msg = Vertica::Protocol::DataRow.new("\x00\x02\x00\x00\x00\x011\x00\x00\x00\x04matt")
     assert_equal ['1', 'matt'], msg.values
-    
-    msg = Vertica::Messages::DataRow.new("\x00\a\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
+
+    msg = Vertica::Protocol::DataRow.new("\x00\a\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
     assert_equal [nil,nil,nil,nil,nil,nil,nil], msg.values
   end
-  
+
   def test_command_complete_message
-    msg = Vertica::Messages::CommandComplete.new("CREATE TABLE\x00")
+    msg = Vertica::Protocol::CommandComplete.new("CREATE TABLE\x00")
     assert_equal "CREATE TABLE", msg.tag
     assert_nil msg.rows
     assert_nil msg.oid

data/test/unit/column_test.rb

@@ -4,30 +4,30 @@ class ColumnTest < Minitest::Test
 
   def test_initialize_from_row_description
     field_description = {
-      :name             => "OUTPUT",
-      :table_oid        => 0,
-      :attribute_number => 0,
-      :data_type_oid    => 6,
-      :data_type_size   => 8,
-      :type_modifier    => 8,
-      :format_code      => 0
+      :name               => "OUTPUT",
+      :table_oid          => 0,
+      :attribute_number   => 0,
+      :data_type_oid      => 6,
+      :data_type_size     => 8,
+      :data_type_modifier => 8,
+      :format_code        => 0
     }
 
     column = Vertica::Column.new(field_description)
-    assert_equal :OUTPUT, column.name
+    assert_equal 'OUTPUT', column.name
     assert_equal :integer, column.data_type
-    assert_equal 8, column.type_modifier
+    assert_equal 8, column.data_type_modifier
   end
 
   def test_unknown_type_oid
     field_description = {
-      :name             => "OUTPUT",
-      :table_oid        => 0,
-      :attribute_number => 0,
-      :data_type_oid    => 123456,
-      :data_type_size   => 8,
-      :type_modifier    => 8,
-      :format_code      => 0
+      :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) }
@@ -35,13 +35,13 @@ class ColumnTest < Minitest::Test
 
   def test_integer_converter
     field_description = {
-      :name             => "OUTPUT",
-      :table_oid        => 0,
-      :attribute_number => 0,
-      :data_type_oid    => 6,
-      :data_type_size   => 8,
-      :type_modifier    => 8,
-      :format_code      => 0
+      :name               => "OUTPUT",
+      :table_oid          => 0,
+      :attribute_number   => 0,
+      :data_type_oid      => 6,
+      :data_type_size     => 8,
+      :data_type_modifier => 8,
+      :format_code        => 0
     }
 
     column = Vertica::Column.new(field_description)

data/test/unit/frontend_message_test.rb

@@ -3,17 +3,17 @@ require 'test_helper'
 class FrontendMessageTest < Minitest::Test
 
   def test_copy_done_message
-    message = Vertica::Messages::CopyDone.new
+    message = Vertica::Protocol::CopyDone.new
     assert_equal message.to_bytes, ['c', 0, 0, 0, 4].pack('AC4')
   end
-  
+
   def test_copy_fail_message
-    message = Vertica::Messages::CopyFail.new('sad panda')
+    message = Vertica::Protocol::CopyFail.new('sad panda')
     assert_equal message.to_bytes, ['f', 0, 0, 0, 14, "sad panda"].pack('AC4Z*')
   end
-  
+
   def test_copy_data_message
-    message = Vertica::Messages::CopyData.new("foo|bar\n")
+    message = Vertica::Protocol::CopyData.new("foo|bar\n")
     assert_equal message.to_bytes, ['d', 0, 0, 0, 12, "foo|bar\n"].pack('AC4A*')
   end
 end

data/test/unit/quoting_test.rb

@@ -1,31 +1,42 @@
 require 'test_helper'
 
 class QuotingTest < Minitest::Test
-
   def test_quote_identifier
     assert_equal '"test"', Vertica.quote_identifier(:test)
     assert_equal '"te""st"', Vertica.quote_identifier('te"st')
     assert_equal '"te""""st"', Vertica.quote_identifier('te""st')
   end
 
-  def test_quote
+  def test_quote_strings
     assert_equal "'test'", Vertica.quote('test')
     assert_equal "'te''st'", Vertica.quote("te'st")
     assert_equal "'te''''st'", Vertica.quote("te''st")
     assert_equal "'test'", Vertica.quote(:test)
+  end
 
+  def test_quote_null_and_booleans
     assert_equal 'NULL', Vertica.quote(nil)
     assert_equal 'TRUE', Vertica.quote(true)
     assert_equal 'FALSE', Vertica.quote(false)
+  end
 
+  def test_quote_numerics
     assert_equal '1', Vertica.quote(1)
     assert_equal '1.1', Vertica.quote(1.1)
     assert_equal '1.1', Vertica.quote(BigDecimal.new('1.1'))
+  end
 
+  def test_quote_date_and_timestamps
     assert_equal "'2010-02-27'::date", Vertica.quote(Date.parse('2010-02-27'))
-    assert_equal "'2010-02-27 12:44:25'::timestamp", Vertica.quote(DateTime.parse('2010-02-27 12:44:25'))
-    assert_equal "'2010-02-27 12:44:25'::timestamp", Vertica.quote(Time.utc(2010,2, 27, 12, 44, 25))
-    
+    assert_equal "'2010-02-27T12:44:25.000000+0000'::timestamptz", Vertica.quote(DateTime.parse('2010-02-27 12:44:25'))
+    assert_equal "'2010-02-27T12:44:25.000000+0800'::timestamptz", Vertica.quote(DateTime.parse('2010-02-27 12:44:25 +8'))
+
+    assert_equal "'2010-02-27T12:44:25.123400+0000'::timestamptz", Vertica.quote(Time.utc(2010,2, 27, 12, 44, BigDecimal.new('25.1234')))
+    assert_equal "'2010-02-27T12:44:25.123400-0500'::timestamptz", Vertica.quote(Time.new(2010,2, 27, 12, 44, BigDecimal.new('25.1234'), '-05:00'))
+    assert_equal "'2010-02-27T12:44:25.123400+0900'::timestamptz", Vertica.quote(Time.new(2010,2, 27, 12, 44, BigDecimal.new('25.1234'), '+09:00'))
+  end
+
+  def test_quote_array
     assert_equal "NULL, 1, TRUE, 'test'", Vertica.quote([nil, 1, true, 'test'])
   end
 end

data/test/unit/result_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+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),
+      ],
+      rows: [
+        [1, 2],
+        [3, 4],
+      ],
+      tag: 'SELECT'
+    )
+  end
+
+  def test_basics
+    assert_equal 'SELECT', @result.tag
+    assert_equal 2, @result.size
+    refute_predicate @result, :empty?
+  end
+
+  def test_fetch_row
+    assert_equal [1, 2], @result.fetch(0).to_a
+    assert_equal [3, 4], @result.fetch(1).to_a
+
+    assert_raises(IndexError) { @result.fetch(-1234) }
+    assert_raises(IndexError) { @result.fetch(1234) }
+  end
+
+  def test_fetch_row_with_negative_index
+    assert_equal @result.fetch(0), @result.fetch(-(@result.size) + 0)
+    assert_equal @result.fetch(1), @result.fetch(-(@result.size) + 1)
+  end
+
+  def test_fetch_value_by_column_index
+    assert_equal 1, @result.fetch(0, 0)
+    assert_equal 2, @result.fetch(0, 1)
+    assert_raises(IndexError) { @result.fetch(0, 2) }
+    assert_raises(IndexError) { @result.fetch(0, -3) }
+  end
+
+  def test_fetch_value_by_column_name
+    assert_equal 1, @result.fetch(0, :a)
+    assert_equal 2, @result.fetch(0, 'b')
+    assert_raises(KeyError) { @result.fetch(0, :c) }
+  end
+
+  def test_value
+    assert_equal @result.value, @result[0, 0]
+  end
+
+  def test_enumerable
+    sum_a = @result.inject(0) { |carry, row| carry + row[:a] }
+    sum_b = @result.inject(0) { |carry, row| carry + row[1] }
+
+    assert_equal 4, sum_a
+    assert_equal 6, sum_b
+  end
+end