vertica 0.11.4 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e07644b7c78ebdd916a6217ec0ee06663e45192
-  data.tar.gz: faaf32f0340c205bcbc3483b6a5d463d55932bf7
+  metadata.gz: 8a40a34bb03e1ca8ad79adeb83e8573146675288
+  data.tar.gz: e80aa43026917a4e59da7f794c4d45d23153c297
 SHA512:
-  metadata.gz: be92da24d4ffda0a4de1df5898723f04a6ee6a60d2f704277bc44ad80ec4f2c281ac0ba9b1dbe27df94e7629b4321153d4361afcca5a57b22162fc0a44ec111f
-  data.tar.gz: 921509af156198086b7c490a2400671e68032c1a49d35f8046dab99204a440de679b848307f8659b34140dc7cb88fb256669508eb3a0c1b219d1fe150cd8702b
+  metadata.gz: e1430c2ed8107e26c1a0724d2f0c0ea9e3d21122958e2b9d2b5550a478e83f3a207dc6620a8aa05eb3e76793651237e683769b8ec2c3c4896a8460762b6508be
+  data.tar.gz: fe886807f5aa39f036dd7d975889fd989283f92068b7a357fa0e479c8af12c016b13a05f6eaa76f104087261ec88b88b2b1e1fa805710aeecf18dbb03f136e39

data/.gitignore

@@ -4,4 +4,6 @@ Gemfile.lock
 test/connection.yml
 *.rbc
 .yardoc/
-doc/
+doc/
+vagrant/vertica*.deb
+vagrant/.vagrant/

data/.travis.yml

@@ -1,8 +1,18 @@
 language: ruby
 rvm:
-  - "2.0"
-  - "2.1"
-  - "2.2"
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1
+  - jruby-9.1.1.0
+  - jruby-head
+  - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: ruby-head
+  fast_finish: true
 
 before_install:
   - sudo wget -nv https://s3.amazonaws.com/circle-support-bucket/vertica_7.0.1-0_amd64.deb
@@ -14,6 +24,7 @@ before_install:
   - sudo -u dbadmin /opt/vertica/bin/adminTools -t stop_db --database ci -p dbadmin
   - sudo -u dbadmin sh -c 'echo "EnableSSL = 1" > /home/dbadmin/ci/v_ci_node0001_catalog/vertica.conf'
   - sudo -u dbadmin /opt/vertica/bin/adminTools -t start_db --database ci -p dbadmin
+  - gem update bundler
 
 before_script:
   - cp ./test/connection.yml.example ./test/connection.yml

data/README.md

@@ -6,8 +6,8 @@ about Vertica at http://www.vertica.com.
 - Connecting, including over SSL.
 - Executing queries, with results as streaming rows or buffered resultsets.
 - `COPY table FROM STDIN` statement to load data from your application.
-- Confirmed to work with Ruby 1.9, 2.0, and 2.1 and with Vertica version 6.x,
-  and 7.x.
+- Confirmed to work with Ruby 1.9, 2.0, and 2.1; JRuby 1.7.23 and 9.0.4.0; and
+  with Vertica version 6.x, and 7.x.
 - The library is thread-safe as of version 0.11. However, you can only run one
   statement at the time per connection, because the protocol is stateful.
 

data/lib/vertica/column.rb

@@ -21,44 +21,53 @@ module Vertica
       end
     end
 
-    DATA_TYPE_CONVERSIONS = [
-      [:unspecified,  nil],
-      [:tuple,        nil],
-      [:pos,          nil],
-      [:record,       nil],
-      [:unknown,      nil],
-      [:bool,         lambda { |s| s == 't' }],
-      [:integer,      lambda { |s| s.to_i }],
-      [:float,        FLOAT_CONVERTER],
-      [:char,         STRING_CONVERTER],
-      [:varchar,      STRING_CONVERTER],
-      [:date,         lambda { |s| Date.new(*s.split("-").map{|x| x.to_i}) }],
-      [:time,         nil],
-      [:timestamp,    lambda { |s| DateTime.parse(s, true) }],
-      [:timestamp_tz, lambda { |s| DateTime.parse(s, true) }],
-      [:interval,     nil],
-      [:time_tz,      nil],
-      [:numeric,      lambda { |s| BigDecimal.new(s) }],
-      [:bytea,        nil],
-      [:rle_tuple,    nil]
-    ]
+    DATA_TYPE_CONVERSIONS = {
+      0   => [:unspecified,  nil],
+      1   => [:tuple,        nil],
+      2   => [:pos,          nil],
+      3   => [:record,       nil],
+      4   => [:unknown,      nil],
+      5   => [:bool,         lambda { |s| s == 't' }],
+      6   => [:integer,      lambda { |s| s.to_i }],
+      7   => [:float,        FLOAT_CONVERTER],
+      8   => [:char,         STRING_CONVERTER],
+      9   => [:varchar,      STRING_CONVERTER],
+      10  => [:date,         lambda { |s| Date.new(*s.split("-").map{|x| x.to_i}) }],
+      11  => [:time,         nil],
+      12  => [:timestamp,    lambda { |s| DateTime.parse(s, true) }],
+      13  => [:timestamp_tz, lambda { |s| DateTime.parse(s, true) }],
+      14  => [:interval,     nil],
+      15  => [:time_tz,      nil],
+      16  => [:numeric,      lambda { |s| BigDecimal.new(s) }],
+      17  => [:bytea,        lambda { |s| s.gsub(/\\([0-3][0-7][0-7])/) { $1.to_i(8).chr }} ],
+      18  => [:rle_tuple,    nil],
+      115 => [:long_varchar, STRING_CONVERTER],
+    }
 
-    DATA_TYPES = DATA_TYPE_CONVERSIONS.map { |t| t[0] }
+    DATA_TYPES = DATA_TYPE_CONVERSIONS.values.map { |t| t[0] }
 
     def initialize(col)
-      @type_modifier    = col[:type_modifier]
-      @format           = col[:format_code] == 0 ? :text : :binary
-      @table_oid        = col[:table_oid]
-      @name             = col[:name].to_sym
-      @attribute_number = col[:attribute_number]
-      @data_type        = DATA_TYPE_CONVERSIONS[col[:data_type_oid]][0]
-      @converter        = DATA_TYPE_CONVERSIONS[col[:data_type_oid]][1]
-      @size             = col[:data_type_size]
+      @type_modifier    = col.fetch(:type_modifier)
+      @format           = col.fetch(:format_code) == 0 ? :text : :binary
+      @table_oid        = col.fetch(:table_oid)
+      @name             = col.fetch(:name).to_sym
+      @attribute_number = col.fetch(:attribute_number)
+      @size             = col.fetch(:data_type_size)
+
+      @data_type, @converter = column_type_from_oid(col.fetch(:data_type_oid))
     end
 
     def convert(s)
       return unless s
       @converter ? @converter.call(s) : s
     end
+
+    private
+
+    def column_type_from_oid(oid)
+      DATA_TYPE_CONVERSIONS.fetch(oid) do |unknown_oid|
+        raise Vertica::Error::UnknownTypeError, "Unknown type OID: #{unknown_oid}"
+      end
+    end
   end
 end

data/lib/vertica/connection.rb

@@ -14,8 +14,10 @@ class Vertica::Connection
   # @param [Hash] options The connection options to use.
   def initialize(options = {})
     reset_values
+    @notice_handler = nil
 
     @options = {}
+    @debug = false
 
     options.each { |key, value| @options[key.to_s.to_sym] = value if value}
 
@@ -162,7 +164,7 @@ class Vertica::Connection
     job = Vertica::Query.new(self, sql, :row_style => @row_style)
     if block_given?
       job.copy_handler = block
-    elsif source && File.exists?(source.to_s)
+    elsif source && File.exist?(source.to_s)
       job.copy_handler = lambda { |data| file_copy_handler(source, data) }
     elsif source.respond_to?(:read) && source.respond_to?(:eof?)
       job.copy_handler = lambda { |data| io_copy_handler(source, data) }
@@ -216,7 +218,7 @@ class Vertica::Connection
         io_select(wait_error)
         retry
       end
-    end 
+    end
     bytes
   end
 
@@ -227,7 +229,7 @@ class Vertica::Connection
     io_select(wait_error)
     retry
   end
-  
+
   def io_select(exception)
     readers, writers = nil, nil
     readers = [socket] if exception.is_a?(IO::WaitReadable)

data/lib/vertica/error.rb

@@ -1,13 +1,14 @@
 # Main class for exceptions relating to Vertica.
 class Vertica::Error < StandardError
-  
+
   class ConnectionError < Vertica::Error; end
   class SSLNotSupported < ConnectionError; end
   class InterruptImpossible < Vertica::Error; end
   class MessageError < Vertica::Error; end
   class EmptyQueryError < Vertica::Error; end
   class TimedOutError < ConnectionError; end
-    
+  class UnknownTypeError < Vertica::Error; end
+
   class SynchronizeError < Vertica::Error
     attr_reader :running_job, :requested_job
 
@@ -18,24 +19,25 @@ class Vertica::Error < StandardError
   end
 
   class QueryError < Vertica::Error
-    
+
     attr_reader :error_response, :sql
-    
+
     def initialize(error_response, sql)
       @error_response, @sql = error_response, sql
-      super("#{error_response.error_message}, SQL: #{one_line_sql.inspect}" )
+      utf8_encoded_error = error_response.error_message.encode('utf-8', :invalid => :replace, :undef => :replace)
+      super("#{utf8_encoded_error}, SQL: #{one_line_sql.inspect}" )
     end
-    
+
     def one_line_sql
-      @sql.gsub(/[\r\n]+/, ' ')
+      @sql.to_s.encode('utf-8', :invalid => :replace, :undef => :replace).gsub(/[\r\n]+/, ' ')
     end
-    
+
     def self.from_error_response(error_response, sql)
       klass = QUERY_ERROR_CLASSES[error_response.sqlstate] || self
       klass.new(error_response, sql)
     end
   end
-  
+
   QUERY_ERROR_CLASSES = {
     '55V03' => (LockFailure           = Class.new(Vertica::Error::QueryError)),
     '53000' => (InsufficientResources = Class.new(Vertica::Error::QueryError)),

data/lib/vertica/query.rb

@@ -7,7 +7,7 @@ class Vertica::Query
     @connection, @sql = connection, sql
     
     @row_style    = options[:row_style] || @connection.row_style || :hash
-    @row_handler  = options[:row_handler] 
+    @row_handler  = options[:row_handler]
     @copy_handler = options[:copy_handler]
 
     @error  = nil
@@ -15,8 +15,8 @@ class Vertica::Query
   end
 
   def run
-    @connection.write_message Vertica::Messages::Query.new(sql)
-    
+    @connection.write_message(Vertica::Messages::Query.new(sql))
+
     begin
       process_message(message = @connection.read_message)
     end until message.kind_of?(Vertica::Messages::ReadyForQuery)
@@ -24,20 +24,20 @@ class Vertica::Query
     raise error unless error.nil?
     return result
   end
-  
+
   def write(data)
-    @connection.write_message Vertica::Messages::CopyData.new(data)
+    @connection.write_message(Vertica::Messages::CopyData.new(data))
     return self
   end
-  
+
   alias_method :<<, :write
 
   def to_s
     @sql
   end
-  
+
   protected
-  
+
   def process_message(message)
     case message
     when Vertica::Messages::ErrorResponse
@@ -56,19 +56,19 @@ class Vertica::Query
       @connection.process_message(message)
     end
   end
-  
+
   def handle_copy_from_stdin
     if copy_handler.nil?
-      @connection.write_message Vertica::Messages::CopyFail.new('no handler provided')
+      @connection.write_message(Vertica::Messages::CopyFail.new('no handler provided'))
     else
       begin
         if copy_handler.call(self) == :rollback
-          @connection.write_message Vertica::Messages::CopyFail.new("rollback")
+          @connection.write_message(Vertica::Messages::CopyFail.new("rollback"))
         else
-          @connection.write_message Vertica::Messages::CopyDone.new
+          @connection.write_message(Vertica::Messages::CopyDone.new)
         end
       rescue => e
-        @connection.write_message Vertica::Messages::CopyFail.new(e.message)
+        @connection.write_message(Vertica::Messages::CopyFail.new(e.message))
       end
     end
   end
@@ -78,7 +78,7 @@ class Vertica::Query
     result.add_row(record) if buffer_rows?
     row_handler.call(record) if row_handler
   end
-  
+
   def buffer_rows?
     row_handler.nil? && copy_handler.nil?
   end

data/lib/vertica/result.rb

@@ -1,6 +1,6 @@
 class Vertica::Result
   include Enumerable
-  
+
   attr_reader :columns
   attr_reader :rows
   attr_accessor :tag, :notice
@@ -17,20 +17,20 @@ class Vertica::Result
   def format_row_as_hash(row_data)
     row = {}
     row_data.values.each_with_index do |value, idx|
-      col = columns[idx]
+      col = columns.fetch(idx)
       row[col.name] = col.convert(value)
     end
     row
   end
-  
+
   def format_row(row_data)
     send("format_row_as_#{@row_style}", row_data)
   end
-  
+
   def format_row_as_array(row_data)
     row = []
     row_data.values.each_with_index do |value, idx|
-      row << columns[idx].convert(value)
+      row << columns.fetch(idx).convert(value)
     end
     row
   end
@@ -42,11 +42,11 @@ class Vertica::Result
   def each_row(&block)
     @rows.each(&block)
   end
-  
+
   def empty?
     @rows.empty?
   end
-  
+
   def the_value
     if empty?
       nil
@@ -58,7 +58,7 @@ class Vertica::Result
   def [](row, col = nil)
     col.nil? ? row[row] : rows[row][col]
   end
-  
+
   alias_method :each, :each_row
 
   def row_count

data/lib/vertica/version.rb

@@ -1,3 +1,3 @@
 module Vertica
-  VERSION = "0.11.4"
+  VERSION = "0.12.0"
 end

data/test/functional/connection_test.rb

@@ -1,42 +1,14 @@
 require 'test_helper'
 
 class ConnectionTest < Minitest::Test
-  
-  def teardown
-    @connection.close if @connection
-  end
-
-  def assert_valid_open_connection(connection)
-    assert connection.opened?
-    assert !connection.closed?
-
-    # connection variables
-    assert connection.backend_pid
-    assert connection.backend_key
-    assert connection.transaction_status
-    
-    # parameters
-    assert connection.parameters.kind_of?(Hash)
-    assert connection.parameters.include?('server_version')
-  end
-
-  def assert_valid_closed_connection(connection)
-    assert !connection.opened?
-    assert connection.closed?
-    assert_equal({}, connection.parameters)
-    assert_nil connection.backend_pid
-    assert_nil connection.backend_key
-    assert_nil connection.transaction_status
-  end
-
   def test_opening_and_closing_connection
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
     assert_valid_open_connection(connection)
 
     connection.close
-    assert_valid_closed_connection(connection)    
+    assert_valid_closed_connection(connection)
   end
-  
+
   def test_connection_with_ssl
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:ssl => true))
     assert_valid_open_connection(connection)
@@ -45,8 +17,8 @@ class ConnectionTest < Minitest::Test
     connection.close
     assert_valid_closed_connection(connection)
     assert !connection.ssl?
-    
-  rescue Vertica::Error::SSLNotSupported => e
+
+  rescue Vertica::Error::SSLNotSupported
     puts "\nThe test server doesn't support SSL, so SSL connections could not be tested."
   end
 
@@ -61,7 +33,7 @@ class ConnectionTest < Minitest::Test
     assert original_backend_key != connection.backend_key
     assert_equal :no_transaction, connection.transaction_status
   end
-  
+
   def test_interruptable_connection
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:interruptable => true))
     assert connection.interruptable?, "The connection should be interruptable!"
@@ -72,7 +44,7 @@ class ConnectionTest < Minitest::Test
       Vertica::Connection.new(TEST_CONNECTION_HASH.merge('database' => 'nonexistant_db'))
     end
   end
-  
+
   def test_connection_inspect_should_not_print_password
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
     inspected_string = connection.inspect
@@ -100,7 +72,7 @@ class ConnectionTest < Minitest::Test
       end
     end
 
-    assert_raises(Vertica::Error::ConnectionError) {connection.query('select 1')}
+    assert_raises(Vertica::Error::ConnectionError) { connection.query('select 1') }
     assert connection.closed?
   end
 
@@ -120,12 +92,37 @@ class ConnectionTest < Minitest::Test
     connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
     t = Thread.new { connection.query("SELECT sleep(1)") }
     sleep(0.1)
-    
+
     assert connection.busy?, "The connection should be busy while executing a query"
     assert_raises(Vertica::Error::SynchronizeError) { connection.query('SELECT 1') }
-    
+
     t.join
     assert connection.ready_for_query?, "The connection should be available again."
     connection.close
   end
+
+  private
+
+  def assert_valid_open_connection(connection)
+    assert connection.opened?
+    assert !connection.closed?
+
+    # connection variables
+    assert connection.backend_pid
+    assert connection.backend_key
+    assert connection.transaction_status
+
+    # parameters
+    assert connection.parameters.kind_of?(Hash)
+    assert connection.parameters.include?('server_version')
+  end
+
+  def assert_valid_closed_connection(connection)
+    assert !connection.opened?
+    assert connection.closed?
+    assert_equal({}, connection.parameters)
+    assert_nil connection.backend_pid
+    assert_nil connection.backend_key
+    assert_nil connection.transaction_status
+  end
 end

data/test/functional/query_test.rb

@@ -1,18 +1,16 @@
 require 'test_helper'
 require 'zlib'
-class TestError < StandardError; end
 
 class QueryTest < Minitest::Test
-  
   def setup
     @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
-    @connection.query("DROP TABLE IF EXISTS test_ruby_vertica_table CASCADE;")    
+    @connection.query("DROP TABLE IF EXISTS test_ruby_vertica_table CASCADE;")
     @connection.query("CREATE TABLE test_ruby_vertica_table (id int, name varchar(100))")
     @connection.query("CREATE PROJECTION IF NOT EXISTS test_ruby_vertica_table_p (id, name) AS SELECT * FROM test_ruby_vertica_table SEGMENTED BY HASH(id) ALL NODES OFFSET 1")
     @connection.query("INSERT INTO test_ruby_vertica_table VALUES (1, 'matt')")
     @connection.query("COMMIT")
   end
-  
+
   def teardown
     if @connection.ready_for_query?
       @connection.close
@@ -20,7 +18,7 @@ class QueryTest < Minitest::Test
       @connection.interrupt
     end
   end
-  
+
   def test_select_query_with_results_as_hash
     r = @connection.query("SELECT * FROM test_ruby_vertica_table")
     assert_equal 1, r.row_count
@@ -29,10 +27,10 @@ class QueryTest < Minitest::Test
     assert_equal :id, r.columns[0].name
     assert_equal :varchar, r.columns[1].data_type
     assert_equal :name, r.columns[1].name
-    
+
     assert_equal [{:id => 1, :name => "matt"}], r.rows
   end
-  
+
   def test_select_query_with_results_as_array
     @connection.row_style = :array
     r = @connection.query("SELECT * FROM test_ruby_vertica_table")
@@ -42,11 +40,32 @@ class QueryTest < Minitest::Test
     assert_equal :id, r.columns[0].name
     assert_equal :varchar, r.columns[1].data_type
     assert_equal :name, r.columns[1].name
-    
+
     assert_equal [[1, "matt"]], r.rows
   end
-  
-  
+
+  def test_select_query_with_streaming_results
+    result = []
+    @connection.query("SELECT 1 AS a, 2 AS b UNION ALL SELECT 3, 4", row_style: :hash) do |row|
+      result << row
+    end
+
+    assert_equal 2, result.length
+    assert_equal 1, result[0].fetch(:a)
+    assert_equal 2, result[0].fetch(:b)
+    assert_equal 3, result[1].fetch(:a)
+    assert_equal 4, result[1].fetch(:b)
+  end
+
+  def test_select_query_with_zero_streaming_results
+    result = []
+    @connection.query("SELECT 'impossible' WHERE 1=2", row_style: :hash) do |row|
+      result << row
+    end
+
+    assert_equal 0, result.length
+  end
+
   def test_select_query_with_no_results
     r = @connection.query("SELECT * FROM test_ruby_vertica_table WHERE 1 != 1")
     assert_equal 0, r.row_count
@@ -57,7 +76,7 @@ class QueryTest < Minitest::Test
     assert_equal :name, r.columns[1].name
     assert_equal [], r.rows
   end
-  
+
   def test_insert
     r = @connection.query("INSERT INTO test_ruby_vertica_table VALUES (2, 'stefanie')")
     assert_equal 1, r.row_count
@@ -66,8 +85,8 @@ class QueryTest < Minitest::Test
     assert_equal :OUTPUT, r.columns[0].name
     assert_equal [{:OUTPUT => 1}], r.rows
   end
-  
-  
+
+
   def test_delete_of_no_rows
     r = @connection.query("DELETE FROM test_ruby_vertica_table WHERE 1 != 1")
     assert_equal 1, r.row_count
@@ -76,7 +95,7 @@ class QueryTest < Minitest::Test
     assert_equal :OUTPUT, r.columns[0].name
     assert_equal [{:OUTPUT => 0}], r.rows
   end
-  
+
   def test_delete_of_a_row
     r = @connection.query("DELETE FROM test_ruby_vertica_table WHERE id = 1")
     assert_equal 1, r.row_count
@@ -85,7 +104,7 @@ class QueryTest < Minitest::Test
     assert_equal :OUTPUT, r.columns[0].name
     assert_equal [{:OUTPUT => 1}], r.rows
   end
-  
+
   def test_empty_query
     assert_raises Vertica::Error::EmptyQueryError do
       @connection.query("")
@@ -93,11 +112,11 @@ class QueryTest < Minitest::Test
     assert_raises Vertica::Error::EmptyQueryError do
       @connection.query(nil)
     end
-    assert_raises Vertica::Error::EmptyQueryError do 
+    assert_raises Vertica::Error::EmptyQueryError do
       @connection.query("-- just a SQL comment")
     end
   end
-  
+
   def test_cleanup_after_select
     3.times do
       r = @connection.query("SELECT * FROM test_ruby_vertica_table")
@@ -109,8 +128,8 @@ class QueryTest < Minitest::Test
       assert_equal :name, r.columns[1].name
       assert_equal [{:id => 1, :name => "matt"}], r.rows
     end
-  end  
-  
+  end
+
   def test_read_timeout
     assert_raises(Vertica::Error::TimedOutError) do
       @connection.options[:read_timeout] = 0.0001
@@ -119,13 +138,13 @@ class QueryTest < Minitest::Test
   end
 
   def test_sql_error
-    assert_raises Vertica::Error::MissingColumn do 
-      @connection.query("SELECT asad FROM test_ruby_vertica_table")
+    assert_raises(Vertica::Error::MissingColumn) do
+      @connection.query("SELECT missing FROM test_ruby_vertica_table")
     end
-    assert_raises Vertica::Error::MissingRelation do 
+    assert_raises(Vertica::Error::MissingRelation) do
       @connection.query("SELECT * FROM nonexisting_dsfdfsdfsdfs")
     end
-    assert_raises Vertica::Error::SyntaxError do 
+    assert_raises(Vertica::Error::SyntaxError) do
       @connection.query("BLAH")
     end
   end
@@ -134,40 +153,40 @@ class QueryTest < Minitest::Test
     @connection.copy "COPY test_ruby_vertica_table FROM STDIN" do |data|
       data.write "11|#{"a" * 1_000_000}\n"
     end
-    
+
     result = @connection.query("SELECT id FROM test_ruby_vertica_table ORDER BY id", :row_style => :array)
     assert_equal 2, result.length
   end
-  
+
   def test_copy_in_with_customer_handler
     @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
-    
+
     result = @connection.query("SELECT * FROM test_ruby_vertica_table ORDER BY id", :row_style => :array)
     assert_equal 4, result.length
     assert_equal [[1, "matt"], [11, "Stuff"], [12, "More stuff"], [13, "Final stuff"]], result.rows
   end
-  
+
   def test_copy_in_with_gzip
     @connection.copy "COPY test_ruby_vertica_table FROM STDIN GZIP" do |data|
-       gz = Zlib::GzipWriter.new(data)
-       gz << "11|Stuff\n12|More stuff\n13|Final stuff\n"
-       gz.close
+      gz = Zlib::GzipWriter.new(data)
+      gz << "11|Stuff\n12|More stuff\n13|Final stuff\n"
+      gz.close
     end
-    
+
     result = @connection.query("SELECT * FROM test_ruby_vertica_table ORDER BY id", :row_style => :array)
     assert_equal 4, result.length
     assert_equal [[1, "matt"], [11, "Stuff"], [12, "More stuff"], [13, "Final stuff"]], result.rows
-  end  
-  
+  end
+
   def test_copy_with_ruby_exception
     2.times do
       begin
         @connection.copy "COPY test_ruby_vertica_table FROM STDIN" do |data|
           data.write "11|#{"a" * 10}\n"
-          raise TestError
+          raise "some error"
         end
       rescue Vertica::Error::CopyFromStdinFailed
       end
@@ -176,7 +195,7 @@ class QueryTest < Minitest::Test
       assert_equal 1, result.length
     end
   end
- 
+
   def test_copy_with_backend_exception
     2.times do
       begin
@@ -206,14 +225,14 @@ class QueryTest < Minitest::Test
     assert_equal 4, result.length
     assert_equal [[1, "matt"], [11, "Stuff"], [12, "More stuff"], [13, "Final stuff"]], result.rows
   end
-  
+
   def test_notice_handler
     notice_received = false
     @connection.on_notice { |notice| notice_received = true }
     @connection.query('COMMIT')
     assert notice_received
   end
-  
+
   def test_query_mutex
     mutex = Mutex.new
     values = []
@@ -239,7 +258,7 @@ class QueryTest < Minitest::Test
 
     assert_equal values.sort, [1,1,1,2,2,2,3,3,3]
   end
-  
+
   def test_raise_when_connection_is_in_use
     assert_raises(Vertica::Error::SynchronizeError) do
       @connection.query("SELECT 1 UNION SELECT 2") do |record|
@@ -247,7 +266,19 @@ class QueryTest < Minitest::Test
       end
     end
   end
-  
+
+  def test_sql_with_non_unicode_characters
+    assert_raises(Vertica::Error::MissingColumn) do
+      sql = "select あ".encode('EUC-JP').force_encoding('BINARY')
+      @connection.query(sql)
+    end
+
+    sql = "select 'あ'".encode('EUC-JP')
+    result = @connection.query(sql)
+    assert_equal "\xA4\xA2", result.the_value
+    assert_equal Encoding::UTF_8, result.the_value.encoding
+  end
+
   def test_interrupting_connections
     before = @connection.query("SELECT COUNT(1) FROM test_ruby_vertica_table").the_value
     interruptable = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:interruptable => true))
@@ -255,16 +286,16 @@ class QueryTest < Minitest::Test
     t = Thread.new do
       Thread.current[:error_occurred] = false
       begin
-        10.times { |n| interruptable.query("INSERT INTO test_ruby_vertica_table VALUES (#{n}, 'interrupt test')") } 
+        10.times { |n| interruptable.query("INSERT INTO test_ruby_vertica_table VALUES (#{n}, 'interrupt test')") }
         interruptable.query("COMMIT")
       rescue Vertica::Error::ConnectionError
         Thread.current[:error_occurred] = true
       end
     end
-    
+
     interruptable.interrupt
     t.join
-    
+
     assert t[:error_occurred], "Expected an exception to occur"
     assert_equal before, @connection.query("SELECT COUNT(1) FROM test_ruby_vertica_table").the_value
   end

data/test/functional/value_conversion_test.rb

@@ -2,13 +2,13 @@
 require 'test_helper'
 
 class ValueConversionTest < Minitest::Test
-  
+
   def setup
     @connection = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:row_style => :array))
 
     @connection.query <<-SQL
       CREATE TABLE IF NOT EXISTS conversions_table (
-        "int_field" int, 
+        "int_field" int,
         "string_field" varchar(100),
         "date_field" date,
         "timestamp_field" timestamp,
@@ -16,46 +16,73 @@ class ValueConversionTest < Minitest::Test
         "interval_field" interval,
         "boolean_field" boolean,
         "float_field" float,
-        "float_zero" 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 "INSERT INTO conversions_table VALUES (123, 'hello world', '2010-01-01', '2010-01-01 12:00:00', '12:00:00', INTERVAL '1 DAY', TRUE, 1.0, 0.0)"
-    result = @connection.query "SELECT *,
-                                       float_field / float_zero as infinity,
-                                       float_field / float_zero - float_field / float_zero as nan
-                                FROM conversions_table LIMIT 1"
+    @connection.query <<-SQL
+      INSERT INTO conversions_table VALUES (
+          123,
+          'hello world',
+          '2010-01-01',
+          '2010-01-01 12:00:00',
+          '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'), 
+      123,
+      'hello world',
+      Date.parse('2010-01-01'),
       DateTime.parse('2010-01-01 12:00:00'),
-      "12:00:00", 
-      "1", 
+      "12:00:00",
+      "1",
       true,
       1.0,
       0.0,
+      ['d09fd180d0b8d0b2d0b5d1822c2068656c6c6f21'].pack('H*'),
+      'hello world',
       Float::INFINITY,
       Float::NAN], result.rows.first
   end
-  
+
   def test_nil_conversions
-    @connection.query "INSERT INTO conversions_table VALUES (NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)"
+    @connection.query "INSERT INTO conversions_table VALUES (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], result.rows.first
+    assert_equal [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil], result.rows.first
   end
-  
+
   def test_string_encoding
     assert_equal 'åßç∂ë', @connection.query("SELECT 'åßç∂ë'").the_value
   end
+
+  def test_binary_encoding
+    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
 end

data/test/test_helper.rb

@@ -17,4 +17,4 @@ else
   puts "for your Vertica test database in order to run the test suite."
   puts
   exit(1)
-end
+end

data/test/unit/column_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+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
+    }
+
+    column = Vertica::Column.new(field_description)
+    assert_equal :OUTPUT, column.name
+    assert_equal :integer, column.data_type
+    assert_equal 8, column.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
+    }
+
+    assert_raises(Vertica::Error::UnknownTypeError) { Vertica::Column.new(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,
+      :type_modifier    => 8,
+      :format_code      => 0
+    }
+
+    column = Vertica::Column.new(field_description)
+    assert_equal :integer, column.data_type
+    assert_equal 1234, column.convert('1234')
+  end
+end

data/vagrant/Vagrantfile

@@ -0,0 +1,40 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+vertica_version = Dir['vertica_*.deb'].first
+if vertica_version.nil?
+  raise "Please place a vertica .deb pacakge in the \`vagrant\` folder."
+end
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "puphpet/ubuntu1404-x64"
+
+  # Disable automatic box update checking. If you disable this, then
+  # boxes will only be checked for updates when the user runs
+  # `vagrant box outdated`. This is not recommended.
+  # config.vm.box_check_update = false
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  config.vm.network "forwarded_port", guest: 5433, host: 5433
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network "private_network", ip: "192.168.33.10"
+
+  config.vm.provision "shell", path: "setup_vertica.sh"
+
+  config.vm.provider "vmware_fusion" do |v|
+    v.vmx["memsize"] = "2048"
+    v.vmx["numvcpus"] = "2"
+  end
+end

data/vagrant/setup_vertica.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -ex
+
+: ${VERTICA_VERSION:=7.2.3-0}
+
+apt-get install dialog pstack sysstat mcelog -y
+
+dpkg -i /vagrant/vertica_${VERTICA_VERSION}_amd64.deb
+/opt/vertica/sbin/install_vertica --failure-threshold HALT --accept-eula --dba-user-password dbadmin --license CE -s localhost
+
+sudo -u dbadmin /opt/vertica/bin/adminTools -t create_db --database ci -s localhost -p dbadmin
+# sudo -u dbadmin openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /home/dbadmin/ci/v_ci_node0001_catalog/server.key -out /home/dbadmin/ci/v_ci_node0001_catalog/server.crt -batch
+# sudo -u dbadmin chmod 600 /home/dbadmin/ci/v_ci_node0001_catalog/server.key /home/dbadmin/ci/v_ci_node0001_catalog/server.crt
+# sudo -u dbadmin /opt/vertica/bin/adminTools -t stop_db --database ci -p dbadmin
+# sudo -u dbadmin sh -c 'echo "EnableSSL = 1" > /home/dbadmin/ci/v_ci_node0001_catalog/vertica.conf'
+# sudo -u dbadmin /opt/vertica/bin/adminTools -t start_db --database ci -p dbadmin

data/vertica.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.name        = "vertica"
   s.summary     = "Pure Ruby library for interacting with Vertica"
   s.description = "Query Vertica with ruby"
-  s.homepage    = "https://github.com/sprsquish/vertica"
+  s.homepage    = "https://github.com/wvanbergen/vertica"
   s.license     = "MIT"
   s.version     = Vertica::VERSION
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vertica
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.12.0
 platform: ruby
 authors:
 - Jeff Smick
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2016-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -119,10 +119,13 @@ files:
 - test/resources/test_ruby_vertica_table.csv
 - test/test_helper.rb
 - test/unit/backend_message_test.rb
+- test/unit/column_test.rb
 - test/unit/frontend_message_test.rb
 - test/unit/quoting_test.rb
+- vagrant/Vagrantfile
+- vagrant/setup_vertica.sh
 - vertica.gemspec
-homepage: https://github.com/sprsquish/vertica
+homepage: https://github.com/wvanbergen/vertica
 licenses:
 - MIT
 metadata: {}
@@ -142,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: Pure Ruby library for interacting with Vertica
@@ -154,6 +157,7 @@ test_files:
 - test/resources/test_ruby_vertica_table.csv
 - test/test_helper.rb
 - test/unit/backend_message_test.rb
+- test/unit/column_test.rb
 - test/unit/frontend_message_test.rb
 - test/unit/quoting_test.rb
 has_rdoc: