vertica 0.8.1 → 0.9.0.beta1

data/lib/vertica/messages/frontend_messages/ssl_request.rb

@@ -4,9 +4,8 @@ module Vertica
       message_id nil
 
       def to_bytes
-        message_string 80877103.to_network_int32
+        message_string [80877103].pack('N')
       end
-
     end
   end
 end

data/lib/vertica/messages/frontend_messages/startup.rb

@@ -11,15 +11,13 @@ module Vertica
       end
 
       def to_bytes
-        bytes =   [Vertica::PROTOCOL_VERSION.to_network_int32]
-        bytes +=  ['user'.to_cstring, @user.to_cstring] if @user
-        bytes +=  ['database'.to_cstring, @database.to_cstring] if @database
-        bytes +=  ['options'.to_cstring, @options.to_cstring] if @options
-        bytes << 0
-
-        message_string bytes
+        str =  [Vertica::PROTOCOL_VERSION].pack('N')
+        str << ["user", @user].pack('Z*Z*')         if @user
+        str << ["database", @database].pack('Z*Z*') if @database
+        str << ["options", @options].pack('Z*Z*')   if @options
+        str << [].pack('x')
+        message_string str
       end
-
     end
   end
 end

data/lib/vertica/messages/frontend_messages/sync.rb

@@ -1,7 +1,7 @@
 module Vertica
   module Messages
     class Sync < FrontendMessage
-      message_id ?S
+      message_id 'S'
     end
   end
 end

data/lib/vertica/messages/frontend_messages/terminate.rb

@@ -1,7 +1,7 @@
 module Vertica
   module Messages
     class Terminate < FrontendMessage
-      message_id ?X
+      message_id 'X'
     end
   end
 end

data/lib/vertica/messages/message.rb

@@ -8,39 +8,30 @@ module Vertica
 
       def message_string(msg)
         msg = msg.join if msg.is_a?(Array)
-        size = (0.to_network_int32.size + msg.size).to_network_int32
-        m_id = ''.to_byte             #in 1.9 it seems to write out message ids as numbers, handle this here
-        if (message_id)
-          m_id = message_id.chr
-        end
-        "#{m_id}#{size}#{msg}"
+        bytesize = msg.respond_to?(:bytesize) ? 4 + msg.bytesize : 4 + msg.size
+        message_size = [bytesize].pack('N')
+        message_id ? "#{message_id}#{message_size}#{msg}" : "#{message_size}#{msg}"
       end
     end
 
     class BackendMessage < Message
       MessageIdMap = {}
 
-      attr_reader :size
-
-      def self.factory(type, stream, size)
+      def self.factory(type, data)
         #puts "factory reading message #{type} #{size} #{type.class}"
-        if klass = MessageIdMap[type.chr]           #explicitly use the char value, for 1.9 compat
-          klass.new stream, size
+        if klass = MessageIdMap[type]           #explicitly use the char value, for 1.9 compat
+          klass.new data
         else
-          Messages::Unknown.new stream, size
+          Messages::Unknown.new type, data
         end
       end
 
       def self.message_id(message_id)
         super
-        MessageIdMap[message_id.chr] = self          #explicitly use the char value, for 1.9 compat
-      end
-
-      def self.read(stream)
+        MessageIdMap[message_id] = self          #explicitly use the char value, for 1.9 compat
       end
 
-      def initialize(stream, size)
-        @size = size
+      def initialize(data)
       end
     end
 

data/lib/vertica/result.rb

@@ -1,5 +1,8 @@
 module Vertica
   class Result
+    
+    include Enumerable
+    
     attr_reader :columns
     attr_reader :rows
 
@@ -13,7 +16,7 @@ module Vertica
 
     def format_row(row_data)
       row = {}
-      row_data.fields.each_with_index do |field, idx|
+      row_data.values.each_with_index do |field, idx|
         col = columns[idx]
         row[col.name] = col.convert(field)
       end
@@ -27,10 +30,14 @@ module Vertica
     def each_row(&block)
       @rows.each(&block)
     end
+    
+    alias_method :each, :each_row
 
     def row_count
       @rows.size
     end
 
+    alias_method :size, :row_count
+    alias_method :length, :row_count
   end
 end

data/test/functional/connection_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+  
+  def teardown
+    @connection.close if @connection
+  end
+  
+  def test_new_connection
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
+
+    assert !@connection.parameters.empty?
+    assert @connection.backend_pid
+    assert @connection.backend_key
+    assert @connection.transaction_status
+    assert @connection.opened?
+    assert !@connection.closed?
+    
+    # parameters
+    assert @connection.parameters.kind_of?(Hash)
+    assert @connection.parameters.include?('server_version')
+    
+    assert_equal [], @connection.notifications
+  end
+  
+  def test_close_connection
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
+    @connection.close
+
+    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_connection_with_ssl
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:ssl => true))
+
+    assert @connection.ssl?
+    assert !@connection.parameters.empty?
+    assert @connection.backend_pid
+    assert @connection.backend_key
+    assert @connection.transaction_status
+
+    @connection.close
+    
+    assert_equal({}, @connection.parameters)
+    assert_nil @connection.backend_pid
+    assert_nil @connection.backend_key
+    assert_nil @connection.transaction_status
+  end
+
+  def test_reset
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
+    assert !@connection.parameters.empty?
+    assert @connection.backend_pid
+    assert @connection.backend_key
+    assert @connection.transaction_status
+    @connection.reset
+    assert_equal({}, @connection.parameters)
+    assert_nil @connection.backend_pid
+    assert_nil @connection.backend_key
+    assert_nil @connection.transaction_status
+  end
+
+  def test_new_with_error_response
+    assert_raises Vertica::Error::ConnectionError do
+      Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:database => 'nonexistant_db'))
+    end
+  end
+end

data/test/functional/query_test.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+
+class QueryTest < Test::Unit::TestCase
+  
+  def setup
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
+    @connection.query("CREATE TABLE IF NOT EXISTS test_table (id int, name varchar(100))")
+    @connection.query("CREATE PROJECTION IF NOT EXISTS test_table_p (id, name) AS SELECT * FROM test_table SEGMENTED BY HASH(id) ALL NODES OFFSET 1")
+    @connection.query("INSERT INTO test_table VALUES (1, 'matt')")
+    @connection.query("COMMIT")
+  end
+  
+  def teardown
+    @connection.query("DROP TABLE IF EXISTS test_table CASCADE;")
+    @connection.query("COMMIT")
+    @connection.close
+  end
+  
+  def test_select_query_with_results
+    r = @connection.query("SELECT * FROM test_table")
+    assert_equal 1, r.row_count
+    assert_equal 2, r.columns.length
+    assert_equal :in, r.columns[0].data_type
+    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
+    assert_equal [{:id => 1, :name => "matt"}], r.rows
+  end
+  
+  def test_select_query_with_no_results
+    r = @connection.query("SELECT * FROM test_table WHERE 1 != 1")
+    assert_equal 0, r.row_count
+    assert_equal 2, r.columns.length
+    assert_equal :in, r.columns[0].data_type
+    assert_equal :id, r.columns[0].name
+    assert_equal :varchar, r.columns[1].data_type
+    assert_equal :name, r.columns[1].name
+    assert_equal [], r.rows
+  end
+  
+  def test_insert
+    r = @connection.query("INSERT INTO test_table VALUES (2, 'stefanie')")
+    assert_equal 1, r.row_count
+    assert_equal 1, r.columns.length
+    assert_equal :in, r.columns[0].data_type
+    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_table WHERE 1 != 1")
+    assert_equal 1, r.row_count
+    assert_equal 1, r.columns.length
+    assert_equal :in, r.columns[0].data_type
+    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_table WHERE id = 1")
+    assert_equal 1, r.row_count
+    assert_equal 1, r.columns.length
+    assert_equal :in, r.columns[0].data_type
+    assert_equal :OUTPUT, r.columns[0].name
+    assert_equal [{:OUTPUT => 1}], r.rows
+  end
+  
+  def test_empty_query
+    assert_raises ArgumentError do
+      @connection.query("")
+    end
+    assert_raises ArgumentError do
+      @connection.query(nil)
+    end
+  end
+
+  # FIXME: now hangs forever
+  # def test_non_query
+  #   @connection.query("--just a comment")
+  # end
+  
+  def test_sql_error
+    assert_raises Vertica::Error::QueryError do 
+      @connection.query("SELECT * FROM nonexisting")
+    end
+    assert_raises Vertica::Error::QueryError do 
+      @connection.query("BLAH")
+    end
+  end
+  
+  def test_cancel
+    Vertica::Connection.cancel(@connection)
+  end
+
+  # def test_prepared_statement_with_no_params
+  #   @connection.prepare("my_ps", "SELECT * FROM test_table")
+  #   r = @connection.execute_prepared("my_ps")
+  #   assert_equal 1, r.row_count
+  #   assert_equal 2, r.columns.length
+  #   assert_equal :in, r.columns[0].data_type
+  #   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_prepared_statement_with_one_param
+  #   c = Vertica::Connection.new(TEST_CONNECTION_HASH)
+  #   c.prepare("my_ps", "SELECT * FROM test_table WHERE id = ?", 1)
+  #   r = c.execute_prepared("my_ps", 1)
+  #   assert_equal 1, r.row_count
+  #   assert_equal 2, r.columns.length
+  #   assert_equal :in, r.columns[0].data_type
+  #   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
+  #   c.close    
+  # end
+  # 
+  # def test_prepared_statement_with_two_params
+  #   c = Vertica::Connection.new(TEST_CONNECTION_HASH)
+  #   c.prepare("my_ps", "SELECT * FROM test_table WHERE id = ? OR id = ?", 2)
+  #   r = c.execute_prepared("my_ps", 1, 3)
+  #   assert_equal 1, r.row_count
+  #   assert_equal 2, r.columns.length
+  #   assert_equal :in, r.columns[0].data_type
+  #   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
+  #   c.close
+  # end
+
+  def test_cleanup_after_select
+    5.times do
+      r = @connection.query("SELECT * FROM test_table")
+      assert_equal 1, r.row_count
+      assert_equal 2, r.columns.length
+      assert_equal :in, r.columns[0].data_type
+      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
+  end
+end

data/test/test_helper.rb

@@ -1,16 +1,10 @@
-require "test/unit"
+require 'rubygems'
+require 'bundler/setup'
 
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require "vertica"
+require 'yaml'
+require 'test/unit'
 
-class Test::Unit::TestCase
+require 'vertica'
 
-  TEST_CONNECTION_HASH = {
-    :user     => '',
-    :password => '',
-    :host     => '',
-    :port     => '',
-    :database => ''
-  }
-
-end
+hash = YAML.load(File.read(File.expand_path("../connection.yml", __FILE__)))
+TEST_CONNECTION_HASH = hash.inject(Hash.new) { |carry, (k, v)| carry[k.to_sym] = v; carry }

data/test/unit/backend_message_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+class BackendMessageTest < Test::Unit::TestCase
+  
+  def test_cleartext_authentication_message
+    msg = Vertica::Messages::Authentication.new("\x00\x00\x00\x03")
+    assert_equal Vertica::Messages::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")
+    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")
+    assert_equal 126424, msg.pid
+    assert_equal 46408201, msg.key
+  end
+  
+  def test_ready_for_query_message
+    msg = Vertica::Messages::ReadyForQuery.new("I")
+    assert_equal 'I', 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)
+    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", 
+      "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_notice_response_message
+    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)
+    
+    assert_equal msg.values, {
+      "Severity" => "INFO", 
+      "Sqlstate" => "00000",
+      "Message"  => "cannot commit; no transaction in progress",
+      "File"     => "/scratch_a/release/vbuild/vertica/Commands/PGCall.cpp",
+      "Line"     => "3502",
+      "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")
+    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
+    }
+    
+    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")
+    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
+    }
+    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
+    }
+  end
+  
+  def test_data_row_message
+    msg = Vertica::Messages::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")
+    assert_equal ['1', 'matt'], msg.values
+  end
+  
+  def test_command_complete_message
+    msg = Vertica::Messages::CommandComplete.new("CREATE TABLE\x00")
+    assert_equal "CREATE TABLE", msg.tag
+    assert_nil msg.rows
+    assert_nil msg.oid
+  end
+end