vertica 0.9.0.beta7 → 0.9.0.beta8

data/VERSION

@@ -1 +1 @@
-0.9.0.beta7
+0.9.0.beta8

data/lib/vertica/connection.rb

@@ -2,15 +2,12 @@ require 'socket'
 
 class Vertica::Connection
 
-  attr_reader :options, :notices, :transaction_status, :backend_pid, :backend_key, :parameters, :notice_handler
+  attr_reader :options, :notices, :transaction_status, :backend_pid, :backend_key, :parameters, :notice_handler, :session_id
 
   attr_accessor :row_style, :debug
 
   def self.cancel(existing_conn)
-    conn = self.new(existing_conn.options.merge(:skip_startup => true))
-    conn.write Vertica::Messages::CancelRequest.new(existing_conn.backend_pid, existing_conn.backend_key)
-    conn.write Vertica::Messages::Flush.new
-    conn.socket.close
+    existing_conn.cancel
   end
 
   # Opens a connectio the a Vertica server
@@ -64,6 +61,14 @@ class Vertica::Connection
     !opened?
   end
 
+  def busy?
+    !ready_for_query?
+  end
+
+  def ready_for_query?
+    @ready_for_query == true
+  end
+
   def write(message)
     raise ArgumentError, "invalid message: (#{message.inspect})" unless message.respond_to?(:to_bytes)
     puts "=> #{message.inspect}" if @debug
@@ -84,6 +89,25 @@ class Vertica::Connection
     reset_values
   end
   
+  def cancel
+    conn = self.class.new(options.merge(:skip_startup => true))
+    conn.write Vertica::Messages::CancelRequest.new(backend_pid, backend_key)
+    conn.write Vertica::Messages::Flush.new
+    conn.socket.close
+  end
+
+  def interrupt
+    raise Vertica::Error::ConnectionError, "Session cannopt be interrupted because the session ID is not known!" if session_id.nil?
+    conn = self.class.new(options.merge(:interruptable => false, :role => nil, :search_path => nil))
+    response = conn.query("SELECT CLOSE_SESSION(#{Vertica.quote(session_id)})").the_value
+    conn.close
+    return response
+  end
+
+  def interruptable?
+    !session_id.nil?
+  end
+
   def read_message
     type = read_bytes(1)
     size = read_bytes(4).unpack('N').first
@@ -106,28 +130,38 @@ class Vertica::Connection
       @parameters[message.name] = message.value
     when Vertica::Messages::ReadyForQuery
       @transaction_status = message.transaction_status
+      @ready_for_query = true
     else
       raise Vertica::Error::MessageError, "Unhandled message: #{message.inspect}"
     end
   end
   
+  def with_lock(&block)
+    raise Vertica::Error::SynchronizeError, "The connection is in use!" if busy?
+    @ready_for_query = false
+    yield
+  end
 
   def query(sql, options = {}, &block)
-    job = Vertica::Query.new(self, sql, { :row_style => @row_style }.merge(options))
-    job.row_handler = block if block_given?
-    return job.run
+    with_lock do
+      job = Vertica::Query.new(self, sql, { :row_style => @row_style }.merge(options))
+      job.row_handler = block if block_given?
+      job.run
+    end
   end
   
   def copy(sql, source = nil, &block)
-    job = Vertica::Query.new(self, sql, :row_style => @row_style)
-    if block_given?
-      job.copy_handler = block 
-    elsif source && File.exists?(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) }
+    with_lock do
+      job = Vertica::Query.new(self, sql, :row_style => @row_style)
+      if block_given?
+        job.copy_handler = block
+      elsif source && File.exists?(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) }
+      end
+      job.run
     end
-    return job.run
   end
 
   def inspect
@@ -136,10 +170,12 @@ class Vertica::Connection
   end
   
   protected
-  
+
+  COPY_FROM_IO_BLOCK_SIZE = 1024 * 4096
+
   def file_copy_handler(input_file, output)
     File.open(input_file, 'r') do |input|
-      while data = input.read(4096)
+      while data = input.read(COPY_FROM_IO_BLOCK_SIZE)
         output << data
       end
     end
@@ -147,7 +183,7 @@ class Vertica::Connection
   
   def io_copy_handler(input, output)
     until input.eof?
-      output << input.read(4096) 
+      output << input.read(COPY_FROM_IO_BLOCK_SIZE)
     end
   end
 
@@ -175,14 +211,17 @@ class Vertica::Connection
   def initialize_connection
     query("SET SEARCH_PATH TO #{options[:search_path]}") if options[:search_path]
     query("SET ROLE #{options[:role]}") if options[:role]
+    @session_id = query("SELECT session_id FROM v_monitor.current_session").the_value if options[:interruptable]
   end
 
   def reset_values
     @parameters         = {}
+    @session_id         = nil
     @backend_pid        = nil
     @backend_key        = nil
     @transaction_status = nil
     @socket             = nil
+    @ready_for_query    = false
   end
 end
 

data/lib/vertica/error.rb

@@ -0,0 +1,31 @@
+# Main class for exceptions relating to Vertica.
+class Vertica::Error < StandardError
+  
+  class ConnectionError < Vertica::Error; end
+  class MessageError < Vertica::Error; end
+  class SynchronizeError < Vertica::Error; end
+  class EmptyQueryError < Vertica::Error; end
+    
+  class QueryError < Vertica::Error
+    
+    attr_reader :error_response
+    
+    def initialize(error_response)
+      @error_response = error_response
+      super(error_response.error_message)
+    end
+    
+    def self.from_error_response(error_response)
+      klass = QUERY_ERROR_CLASSES[error_response.sqlstate] || self
+      klass.new(error_response)
+    end
+  end
+  
+  QUERY_ERROR_CLASSES = {
+    '55V03' => (LockFailure     = Class.new(Vertica::Error::QueryError)),
+    '53200' => (OutOfMemory     = Class.new(Vertica::Error::QueryError)),
+    '42601' => (SyntaxError     = Class.new(Vertica::Error::QueryError)),
+    '42V01' => (MissingRelation = Class.new(Vertica::Error::QueryError)),
+    '42703' => (MissingColumn   = Class.new(Vertica::Error::QueryError))
+  }
+end

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

@@ -4,18 +4,18 @@ module Vertica
       message_id 'N'
       
       FIELDS_DEFINITIONS = [
-        { :type => 'q', :name => "Internal Query" },
-        { :type => 'S', :name => "Severity" },
-        { :type => 'M', :name => "Message" },
-        { :type => 'C', :name => "Sqlstate" },
-        { :type => 'D', :name => "Detail" },
-        { :type => 'H', :name => "Hint" },
-        { :type => 'P', :name => "Position" },
-        { :type => 'W', :name => "Where" },
-        { :type => 'p', :name => "Internal Position" },
-        { :type => 'R', :name => "Routine" },
-        { :type => 'F', :name => "File" },
-        { :type => 'L', :name => "Line" }
+        { :type => 'q', :name => "Internal Query", :method => :internal_query },
+        { :type => 'S', :name => "Severity", :method => :severity },
+        { :type => 'M', :name => "Message", :method => :message },
+        { :type => 'C', :name => "Sqlstate", :method => :sqlstate },
+        { :type => 'D', :name => "Detail", :method => :detail },
+        { :type => 'H', :name => "Hint", :method => :hint },
+        { :type => 'P', :name => "Position", :method => :position },
+        { :type => 'W', :name => "Where", :method => :where },
+        { :type => 'p', :name => "Internal Position", :method => :internal_position },
+        { :type => 'R', :name => "Routine", :method => :routine },
+        { :type => 'F', :name => "File", :method => :file },
+        { :type => 'L', :name => "Line", :method => :line }
       ]
       
       FIELDS = Hash[*FIELDS_DEFINITIONS.map { |f| [f[:type], f[:name]] }.flatten]
@@ -37,6 +37,12 @@ module Vertica
         end
         ordered_values.compact.join(', ')
       end
+      
+      FIELDS_DEFINITIONS.each do |field_def|
+        define_method(field_def[:method]) do
+          @values[field_def[:name]]
+        end
+      end
     end
   end
 end

data/lib/vertica/query.rb

@@ -18,9 +18,9 @@ class Vertica::Query
     begin
       case message = @connection.read_message
       when Vertica::Messages::ErrorResponse
-        error = message.error_message
+        error = Vertica::Error::QueryError.from_error_response(message)
       when Vertica::Messages::EmptyQueryResponse
-        error = "The provided query was empty."
+        error = Vertica::Error::EmptyQueryError.new("A SQL string was expected, but the given string was blank or only contained SQL comments.")
       when Vertica::Messages::CopyInResponse
         handle_copy_from_stdin
       when Vertica::Messages::RowDescription, Vertica::Messages::CommandComplete
@@ -30,7 +30,7 @@ class Vertica::Query
       end
     end until message.kind_of?(Vertica::Messages::ReadyForQuery)
     
-    raise Vertica::Error::QueryError, error unless error.nil?
+    raise error unless error.nil?
     return result
   end
   

data/lib/vertica.rb

@@ -7,12 +7,6 @@ require 'bigdecimal'
 # prevent SQL injection.
 module Vertica
   
-  class Error < StandardError
-    class ConnectionError < Error; end
-    class MessageError < Error; end
-    class QueryError < Error; end
-  end
-
   # The version number of this library.
   VERSION = File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION])).strip
 
@@ -57,4 +51,5 @@ module Vertica
   end
 end
 
+require 'vertica/error'
 require 'vertica/connection'

data/test/functional/connection_test.rb

@@ -62,13 +62,18 @@ class ConnectionTest < Test::Unit::TestCase
     assert_nil @connection.backend_key
     assert_nil @connection.transaction_status
   end
+  
+  def test_interrupt_connection
+    @connection = Vertica::Connection.new(TEST_CONNECTION_HASH.merge(:interruptable => true))
+    assert @connection.interruptable?
+  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
-
+  
   def test_connection_inspect_should_not_print_password
     @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
     inspected_string = @connection.inspect

data/test/functional/query_test.rb

@@ -4,15 +4,19 @@ class QueryTest < Test::Unit::TestCase
   
   def setup
     @connection = Vertica::Connection.new(TEST_CONNECTION_HASH)
-    @connection.query("CREATE TABLE IF NOT EXISTS test_ruby_vertica_table (id int, name varchar(100))")
+    @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
-    @connection.query("DROP TABLE IF EXISTS test_ruby_vertica_table CASCADE;")
-    @connection.close
+    if @connection.ready_for_query?
+      @connection.close
+    elsif @connection.interruptable?
+      @connection.interrupt
+    end
   end
   
   def test_select_query_with_results_as_hash
@@ -81,13 +85,13 @@ class QueryTest < Test::Unit::TestCase
   end
   
   def test_empty_query
-    assert_raises Vertica::Error::QueryError do
+    assert_raises Vertica::Error::EmptyQueryError do
       @connection.query("")
     end
-    assert_raises Vertica::Error::QueryError do
+    assert_raises Vertica::Error::EmptyQueryError do
       @connection.query(nil)
     end
-    assert_raises Vertica::Error::QueryError do 
+    assert_raises Vertica::Error::EmptyQueryError do 
       @connection.query("-- just a SQL comment")
     end
   end
@@ -106,10 +110,13 @@ class QueryTest < Test::Unit::TestCase
   end  
   
   def test_sql_error
-    assert_raises Vertica::Error::QueryError do 
-      @connection.query("SELECT * FROM nonexistingfdg")
+    assert_raises Vertica::Error::MissingColumn do 
+      @connection.query("SELECT asad FROM test_ruby_vertica_table")
+    end
+    assert_raises Vertica::Error::MissingRelation do 
+      @connection.query("SELECT * FROM nonexisting_dsfdfsdfsdfs")
     end
-    assert_raises Vertica::Error::QueryError do 
+    assert_raises Vertica::Error::SyntaxError do 
       @connection.query("BLAH")
     end
   end
@@ -153,15 +160,65 @@ class QueryTest < Test::Unit::TestCase
     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
+  
+  def test_query_mutex
+    mutex = Mutex.new
+    values = []
+    t1 = Thread.new do
+      mutex.synchronize do
+        3.times { values << @connection.query("SELECT 1").the_value }
+      end
+    end
+    t2 = Thread.new do
+      mutex.synchronize do
+        3.times { values << @connection.query("SELECT 2").the_value }
+      end
+    end
+    t3 = Thread.new do
+      mutex.synchronize do
+        3.times { values << @connection.query("SELECT 3").the_value }
+      end
+    end
+
+    t1.join
+    t2.join
+    t3.join
+
+    assert_equal values.sort, [1,1,1,2,2,2,3,3,3]
+  end
+  
+  def test_raise_on_synchronisity_problems
+    assert_raise(Vertica::Error::SynchronizeError) do
+      @connection.query("SELECT 1 UNION SELECT 2") do |record|
+        @connection.query("SELECT 3")
+      end
+    end
+  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))
+    assert interruptable.interruptable?
+    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')") } 
+        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
 end

data/test/unit/backend_message_test.rb

@@ -41,7 +41,16 @@ class BackendMessageTest < Test::Unit::TestCase
     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
+  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)
+
+    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)
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vertica
 version: !ruby/object:Gem::Version
-  version: 0.9.0.beta7
+  version: 0.9.0.beta8
   prerelease: 6
 platform: ruby
 authors:
@@ -11,12 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-15 00:00:00.000000000 -05:00
-default_executable: 
+date: 2012-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153826360 !ruby/object:Gem::Requirement
+  requirement: &2157181100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -24,10 +23,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153826360
+  version_requirements: *2157181100
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2153825660 !ruby/object:Gem::Requirement
+  requirement: &2157194780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -35,7 +34,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153825660
+  version_requirements: *2157194780
 description: Query Vertica with ruby
 email: sprsquish@gmail.com
 executables: []
@@ -53,6 +52,7 @@ files:
 - lib/vertica.rb
 - lib/vertica/column.rb
 - lib/vertica/connection.rb
+- lib/vertica/error.rb
 - lib/vertica/messages/backend_messages/authentication.rb
 - lib/vertica/messages/backend_messages/backend_key_data.rb
 - lib/vertica/messages/backend_messages/bind_complete.rb
@@ -97,7 +97,6 @@ files:
 - test/unit/backend_message_test.rb
 - test/unit/frontend_message_test.rb
 - test/unit/quoting_test.rb
-has_rdoc: true
 homepage: http://github.com/sprsquish/vertica
 licenses: []
 post_install_message: 
@@ -118,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Pure ruby library for interacting with Vertica