vertica 0.9.0.beta3 → 0.9.0.beta4

data/lib/vertica/messages/backend_messages/copy_in_response.rb

@@ -0,0 +1,13 @@
+module Vertica
+  module Messages
+    class CopyInResponse < BackendMessage
+      message_id 'G'
+      
+      def initialize(data)
+        values = data.unpack('Cn*')
+        @format = values[0]
+        @column_formats = values.slice(2..-1)
+      end
+    end
+  end
+end

data/lib/vertica/messages/backend_messages/ready_for_query.rb

@@ -1,12 +1,19 @@
 module Vertica
   module Messages
     class ReadyForQuery < BackendMessage
+      
+      STATUSES = {
+        'I' => :no_transaction,
+        'T' => :in_transaction,
+        'E' => :failed_transaction
+      }
+
       message_id 'Z'
 
       attr_reader :transaction_status
 
       def initialize(data)
-        @transaction_status = data.unpack('a').first
+        @transaction_status = STATUSES[data.unpack('a').first]
       end
     end
   end

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

@@ -6,12 +6,13 @@ module Vertica
       def initialize(portal_name, prepared_statement_name, parameter_values)
         @portal_name = portal_name
         @prepared_statement_name = prepared_statement_name
-        @parameter_values = parameter_values.map(&:to_s)
+        @parameter_values = parameter_values
       end
 
       def to_bytes
         bytes = [@portal_name, @prepared_statement_name, 0, @parameter_values.length].pack('Z*Z*nn')
-        bytes << @parameter_values.map { |val| [val.length, val].pack('Na*') }.join('') << [0].pack('n')
+        bytes << @parameter_values.map { |val| val.nil? ? [-1].pack('N') : [val.length, val].pack('Na*') }.join('')
+        bytes << [0].pack('n')
         message_string bytes
       end
     end

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

@@ -0,0 +1,15 @@
+module Vertica
+  module Messages
+    class CopyData < FrontendMessage
+      message_id 'd'
+      
+      def initialize(data)
+        @data = data
+      end
+      
+      def to_bytes
+        message_string [@data].pack('a*')
+      end      
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Vertica
+  module Messages
+    class CopyDone < FrontendMessage
+      message_id 'c'
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Vertica
+  module Messages
+    class CopyFail < FrontendMessage
+      message_id 'f'
+      
+      def initialize(error_message)
+        @error_message = error_message
+      end
+      
+      def to_bytes
+        message_string [@error_message].pack('Z*')
+      end
+    end
+  end
+end

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

@@ -6,17 +6,17 @@ module Vertica
 
       def initialize(password, auth_method = nil, options = {})
         @password = password
-        @auth_method = auth_method || Messages::Authentication::CLEARTEXT_PASSWORD
+        @auth_method = auth_method || Vertica::Messages::Authentication::CLEARTEXT_PASSWORD
         @options = options
       end
 
       def encoded_password
         case @auth_method
-        when Authentication::CLEARTEXT_PASSWORD
+        when Vertica::Messages::Authentication::CLEARTEXT_PASSWORD
           @password
-        when Authentication::CRYPT_PASSWORD
+        when Vertica::Messages::Authentication::CRYPT_PASSWORD
           @password.crypt(@options[:salt])
-        when Authentication::MD5_PASSWORD
+        when Vertica::Messages::Authentication::MD5_PASSWORD
           require 'digest/md5'
           @password = Digest::MD5.hexdigest(@password + @options[:user])
           @password = Digest::MD5.hexdigest(@password + @options[:salt])

data/lib/vertica/messages/message.rb

@@ -53,13 +53,13 @@ require 'vertica/messages/backend_messages/empty_query_response'
 require 'vertica/messages/backend_messages/notice_response'
 require 'vertica/messages/backend_messages/error_response'
 require 'vertica/messages/backend_messages/no_data'
-require 'vertica/messages/backend_messages/notification_response'
 require 'vertica/messages/backend_messages/parameter_description'
 require 'vertica/messages/backend_messages/parameter_status'
 require 'vertica/messages/backend_messages/parse_complete'
 require 'vertica/messages/backend_messages/portal_suspended'
 require 'vertica/messages/backend_messages/ready_for_query'
 require 'vertica/messages/backend_messages/row_description'
+require 'vertica/messages/backend_messages/copy_in_response'
 require 'vertica/messages/backend_messages/unknown'
 
 require 'vertica/messages/frontend_messages/bind'
@@ -75,3 +75,6 @@ require 'vertica/messages/frontend_messages/ssl_request'
 require 'vertica/messages/frontend_messages/startup'
 require 'vertica/messages/frontend_messages/sync'
 require 'vertica/messages/frontend_messages/terminate'
+require 'vertica/messages/frontend_messages/copy_done'
+require 'vertica/messages/frontend_messages/copy_fail'
+require 'vertica/messages/frontend_messages/copy_data'

data/lib/vertica/query.rb

@@ -0,0 +1,84 @@
+class Vertica::Query
+
+  attr_reader :connection, :sql
+  attr_accessor :row_handler, :copy_handler, :row_style
+
+  def initialize(connection, sql, options = {})
+    @connection, @sql = connection, sql
+    
+    @row_style    = options[:row_style] || @connection.row_style || :hash
+    @row_handler  = options[:row_handler] 
+    @copy_handler = options[:copy_handler]
+  end
+  
+  
+  def run
+    @connection.write Vertica::Messages::Query.new(@sql)
+    result, error = nil, nil
+    begin
+      case message = @connection.read_message
+      when Vertica::Messages::ErrorResponse
+        error = message.error_message
+      when Vertica::Messages::EmptyQueryResponse
+        error = "The provided query was empty."
+      when Vertica::Messages::CopyInResponse
+        handle_copy_from_stdin
+      when Vertica::Messages::RowDescription, Vertica::Messages::CommandComplete
+        result = retreive_result(message, Vertica::Result.new(row_style))
+      else
+        @connection.process_message(message)
+      end
+    end until message.kind_of?(Vertica::Messages::ReadyForQuery)
+    
+    raise Vertica::Error::QueryError, error unless error.nil?
+    return result
+  end
+  
+  def copy_data(data)
+    @connection.write Vertica::Messages::CopyData.new(data)
+    return self
+  end
+  
+  alias_method :<<, :copy_data  
+  
+  protected
+  
+  def handle_copy_from_stdin
+    if copy_handler.nil?
+      @connection.write Vertica::Messages::CopyFail.new('no handler provided')
+    else
+      begin
+        if copy_handler.call(self) == :rollback
+          @connection.write Vertica::Messages::CopyFail.new("rollback")
+        else
+          @connection.write Vertica::Messages::CopyDone.new
+        end
+      rescue => e
+        @connection.write Vertica::Messages::CopyFail.new(e.message)
+        raise
+      end
+    end
+  end
+  
+  def retreive_result(message, result)
+    until message.kind_of?(Vertica::Messages::CommandComplete)
+      case message
+      when Vertica::Messages::RowDescription
+        result.descriptions = message
+      when Vertica::Messages::DataRow
+        record = result.format_row(message)
+        result.add_row(record) if buffer_rows?
+        @row_handler.call(record) if @row_handler
+      else
+        @connection.process_message(message)
+      end
+      message = @connection.read_message
+    end
+    result.tag = message.tag
+    return result
+  end
+  
+  def buffer_rows?
+    @row_handler.nil? && @copy_handler.nil?
+  end
+end

data/lib/vertica/result.rb

@@ -1,58 +1,54 @@
-module Vertica
-  class Result
-    
-    include Enumerable
-    
-    attr_reader :columns
-    attr_reader :rows
-
-    attr_accessor
-
-    def initialize(row_style = :hash)
-      @row_style = row_style
-      @rows = []
-    end
+class Vertica::Result
+  include Enumerable
+  
+  attr_reader :columns
+  attr_reader :rows
+  attr_accessor :tag, :notice
+
+  def initialize(row_style = :hash)
+    @row_style = row_style
+    @rows = []
+  end
 
-    def descriptions=(message)
-      @columns = message.fields.map { |fd| Column.new(fd) }
-    end
+  def descriptions=(message)
+    @columns = message.fields.map { |fd| Vertica::Column.new(fd) }
+  end
 
-    def format_row_as_hash(row_data)
-      row = {}
-      row_data.values.each_with_index do |value, idx|
-        col = columns[idx]
-        row[col.name] = col.convert(value)
-      end
-      row
-    end
-    
-    def format_row(row_data)
-      send("format_row_as_#{@row_style}", row_data)
+  def format_row_as_hash(row_data)
+    row = {}
+    row_data.values.each_with_index do |value, idx|
+      col = columns[idx]
+      row[col.name] = col.convert(value)
     end
-    
-    def format_row_as_array(row_data)
-      row = []
-      row_data.values.each_with_index do |value, idx|
-        row << columns[idx].convert(value)
-      end
-      row
-    end
-
-    def add_row(row_data)
-      @rows << format_row(row_data)
+    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)
     end
+    row
+  end
 
-    def each_row(&block)
-      @rows.each(&block)
-    end
-    
-    alias_method :each, :each_row
+  def add_row(row)
+    @rows << row
+  end
 
-    def row_count
-      @rows.size
-    end
+  def each_row(&block)
+    @rows.each(&block)
+  end
+  
+  alias_method :each, :each_row
 
-    alias_method :size, :row_count
-    alias_method :length, :row_count
+  def row_count
+    @rows.size
   end
+
+  alias_method :size, :row_count
+  alias_method :length, :row_count
 end

data/test/functional/connection_test.rb

@@ -5,7 +5,7 @@ class ConnectionTest < Test::Unit::TestCase
   def teardown
     @connection.close if @connection
   end
-  
+
   def test_new_connection
     @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
 
@@ -19,8 +19,6 @@ class ConnectionTest < Test::Unit::TestCase
     # parameters
     assert @connection.parameters.kind_of?(Hash)
     assert @connection.parameters.include?('server_version')
-    
-    assert_equal [], @connection.notifications
   end
   
   def test_close_connection
@@ -67,7 +65,7 @@ class ConnectionTest < Test::Unit::TestCase
 
   def test_new_with_error_response
     assert_raises Vertica::Error::ConnectionError do
-      Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:database => 'nonexistant_db'))
+      Vertica::Connection.new(TEST_CONNECTION_HASH.merge('database' => 'nonexistant_db'))
     end
   end
 end

data/test/functional/query_test.rb

@@ -4,20 +4,19 @@ 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("CREATE TABLE IF NOT EXISTS 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
-    @connection.query("DROP TABLE IF EXISTS test_table CASCADE;")
-    @connection.query("COMMIT")
+    @connection.query("DROP TABLE IF EXISTS test_ruby_vertica_table CASCADE;")
     @connection.close
   end
   
   def test_select_query_with_results_as_hash
-    r = @connection.query("SELECT * FROM test_table")
+    r = @connection.query("SELECT * FROM test_ruby_vertica_table")
     assert_equal 1, r.row_count
     assert_equal 2, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -27,10 +26,10 @@ class QueryTest < Test::Unit::TestCase
     
     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_table")
+    r = @connection.query("SELECT * FROM test_ruby_vertica_table")
     assert_equal 1, r.row_count
     assert_equal 2, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -40,10 +39,10 @@ class QueryTest < Test::Unit::TestCase
     
     assert_equal [[1, "matt"]], r.rows
   end
-
+  
   
   def test_select_query_with_no_results
-    r = @connection.query("SELECT * FROM test_table WHERE 1 != 1")
+    r = @connection.query("SELECT * FROM test_ruby_vertica_table WHERE 1 != 1")
     assert_equal 0, r.row_count
     assert_equal 2, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -54,7 +53,7 @@ class QueryTest < Test::Unit::TestCase
   end
   
   def test_insert
-    r = @connection.query("INSERT INTO test_table VALUES (2, 'stefanie')")
+    r = @connection.query("INSERT INTO test_ruby_vertica_table VALUES (2, 'stefanie')")
     assert_equal 1, r.row_count
     assert_equal 1, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -64,7 +63,7 @@ class QueryTest < Test::Unit::TestCase
   
   
   def test_delete_of_no_rows
-    r = @connection.query("DELETE FROM test_table WHERE 1 != 1")
+    r = @connection.query("DELETE FROM test_ruby_vertica_table WHERE 1 != 1")
     assert_equal 1, r.row_count
     assert_equal 1, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -73,7 +72,7 @@ class QueryTest < Test::Unit::TestCase
   end
   
   def test_delete_of_a_row
-    r = @connection.query("DELETE FROM test_table WHERE id = 1")
+    r = @connection.query("DELETE FROM test_ruby_vertica_table WHERE id = 1")
     assert_equal 1, r.row_count
     assert_equal 1, r.columns.length
     assert_equal :integer, r.columns[0].data_type
@@ -82,75 +81,20 @@ class QueryTest < Test::Unit::TestCase
   end
   
   def test_empty_query
-    assert_raises ArgumentError do
+    assert_raises Vertica::Error::QueryError do
       @connection.query("")
     end
-    assert_raises ArgumentError do
+    assert_raises Vertica::Error::QueryError 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")
+      @connection.query("-- just a SQL comment")
     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 :integer, 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 :integer, 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 :integer, 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")
+    3.times do
+      r = @connection.query("SELECT * FROM test_ruby_vertica_table")
       assert_equal 1, r.row_count
       assert_equal 2, r.columns.length
       assert_equal :integer, r.columns[0].data_type
@@ -159,5 +103,53 @@ class QueryTest < Test::Unit::TestCase
       assert_equal :name, r.columns[1].name
       assert_equal [{:id => 1, :name => "matt"}], r.rows
     end
+  end  
+  
+  def test_sql_error
+    assert_raises Vertica::Error::QueryError do 
+      @connection.query("SELECT * FROM nonexistingfdg")
+    end
+    assert_raises Vertica::Error::QueryError do 
+      @connection.query("BLAH")
+    end
+  end
+  
+  def test_copy_in_with_customer_handler
+    @connection.copy "COPY test_ruby_vertica_table FROM STDIN" do |data|
+      data.copy_data "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_file
+    filename = File.expand_path('../../resources/test_ruby_vertica_table.csv', __FILE__)
+    @connection.copy "COPY test_ruby_vertica_table FROM STDIN", filename
+    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_io
+    io = StringIO.new("11|Stuff\r\n12|More stuff\n13|Final stuff\n")
+    @connection.copy "COPY test_ruby_vertica_table FROM STDIN", io
+    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_cancel
+    Vertica::Connection.cancel(@connection)
+    # TODO: actually test whether this works.
+  end
+  
+  def test_notice_handler
+    notice_received = false
+    @connection.on_notice { |notice| notice_received = true }
+    @connection.query('COMMIT')
+    assert notice_received
   end
 end