impala 0.1.2 → 0.1.3

data/Rakefile

@@ -1,18 +1,18 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
 
 task :default => [:test]
 
-task :test do
-  ret = true
-  Dir["test/**/*.rb"].each do |f|
-    ret = ret && ruby(f, '')
-  end
-  exit(ret)
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['test/test_*.rb']
+  t.verbose = true
 end
 
 THRIFT_FILES = FileList['./thrift/*.thrift']
 GENNED_FILES = FileList['./lib/impala/protocol/*']
 
+# eden only works on 1.8, unfortunately =(
 task :gen do
   THRIFT_FILES.each do |f|
     sh "thrift -out lib/impala/protocol --gen rb #{f}"

data/impala.gemspec

@@ -18,8 +18,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency('eden')
   gem.add_development_dependency('pry')
 
-  gem.add_development_dependency('test-unit')
-  gem.add_development_dependency('shoulda')
+  gem.add_development_dependency('minitest', '~> 4.5')
   gem.add_development_dependency('mocha')
 
   gem.add_development_dependency('yard')

data/lib/impala.rb

@@ -21,6 +21,14 @@ module Impala
   class CursorError < StandardError; end
   class ParsingError < StandardError; end
 
+  # Connect to an Impala server. If a block is given, it will close the
+  # connection after calling the block with the collection.
+  # @param [String] host the hostname or IP address of the Impala server
+  # @param [int] port the port that the Impala server is listening on
+  # @yieldparam [Connection] conn the open connection. Will be closed once the block
+  #    finishes
+  # @return [Connection] the open connection, or, if a block is
+  #    passed, the return value of the block
   def self.connect(host=DEFAULT_HOST, port=DEFAULT_PORT)
     connection = Connection.new(host, port)
 

data/lib/impala/connection.rb

@@ -1,7 +1,10 @@
 module Impala
+  # This object represents a connection to an Impala server. It can be used to
+  # perform queries on the database.
   class Connection
     SLEEP_INTERVAL = 0.1
 
+    # Don't instantiate Connections directly; instead, use {Impala.connect}.
     def initialize(host, port)
       @host = host
       @port = port
@@ -9,6 +12,11 @@ module Impala
       open
     end
 
+    def inspect
+      "#<#{self.class} #{@host}:#{@port}#{open? ? '' : ' (DISCONNECTED)'}>"
+    end
+
+    # Open the connection if it's currently closed.
     def open
       return if @connected
 
@@ -22,19 +30,31 @@ module Impala
       @connected = true
     end
 
+    # Close this connection. It can still be reopened with {#open}.
     def close
+      return unless @connected
+
       @transport.close
       @connected = false
     end
 
+    # Returns true if the connection is currently open.
     def open?
       @connected
     end
 
+    # Perform a query and return all the results. This will
+    # load the entire result set into memory, so if you're dealing with lots
+    # of rows, {#execute} may work better.
+    # @param [String] query the query you want to run
+    # @return [Array<Hash>] an array of hashes, one for each row.
     def query(raw_query)
       execute(raw_query).fetch_all
     end
 
+    # Perform a query and return a cursor for iterating over the results.
+    # @param [String] query the query you want to run
+    # @return [Cursor] a cursor for the result rows
     def execute(raw_query)
       raise ConnectionError.new("Connection closed") unless open?
 

data/lib/impala/cursor.rb

@@ -1,4 +1,7 @@
 module Impala
+  # Cursors are used to iterate over result sets without loading them all
+  # into memory at once. This can be useful if you're dealing with lots of
+  # rows. It implements Enumerable, so you can use each/select/map/etc.
   class Cursor
     include Enumerable
 
@@ -11,7 +14,11 @@ module Impala
       @row_buffer = []
 
       @done = false
-      @closed = false
+      @open = true
+    end
+
+    def inspect
+      "#<#{self.class}#{open? ? '' : ' (CLOSED)'}>"
     end
 
     def each
@@ -20,8 +27,12 @@ module Impala
       end
     end
 
+    # Returns the next available row as a hash, or nil if there are none left.
+    # @return [Hash, nil] the next available row, or nil if there are none
+    #    left
+    # @see #fetch_all
     def fetch_row
-      raise CursorError.new("Cursor has expired or been closed") if @closed
+      raise CursorError.new("Cursor has expired or been closed") unless @open
 
       if @row_buffer.empty?
         if @done
@@ -34,15 +45,30 @@ module Impala
       @row_buffer.shift
     end
 
+    # Returns all the remaining rows in the result set.
+    # @return [Array<Hash>] the remaining rows in the result set
+    # @see #fetch_one
     def fetch_all
       self.to_a
     end
 
+    # Close the cursor on the remote server. Once a cursor is closed, you
+    # can no longer fetch any rows from it.
     def close
-      @closed = true
+      @open = false
       @service.close(@handle)
     end
 
+    # Returns true if the cursor is still open.
+    def open?
+      @open
+    end
+
+    # Returns true if there are any more rows to fetch.
+    def has_more?
+      !@done || !@row_buffer.empty?
+    end
+
     private
 
     def fetch_more

data/lib/impala/protocol.rb

@@ -1,6 +1,8 @@
 require 'impala/protocol/impala_service'
 
 module Impala
+  # Taken as a whole, this module contains all the thrift-generated stuff that
+  # defines the Impala protocol.
   module Protocol
   end
 end

data/lib/impala/version.rb

@@ -1,3 +1,3 @@
 module Impala
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/test/test_impala.rb

@@ -1,34 +1,64 @@
 require 'impala'
-require 'test-unit'
-require 'shoulda'
+require 'minitest/autorun'
 require 'mocha'
 
-class TestImpala < Test::Unit::TestCase
-  include Mocha
+describe 'Impala.connect' do
+  before do
+    Thrift::Socket.expects(:new).with('host', 12345)
+    Thrift::BufferedTransport.expects(:new).once.returns(stub(:open => nil))
+    Thrift::BinaryProtocol.expects(:new).once
+    Impala::Protocol::ImpalaService::Client.expects(:new).once
+  end
+
+  it 'should return an open connection when passed a block' do
+    connection = Impala.connect('host', 12345)
+    assert_equal(Impala::Connection, connection.class)
+    assert_equal(true, connection.open?)
+  end
 
-  context 'Impala.connect' do
-    setup do
-      Thrift::Socket.expects(:new).with('host', 12345)
-      Thrift::BufferedTransport.expects(:new).once.returns(stub(:open => nil))
-      Thrift::BinaryProtocol.expects(:new).once
-      Impala::Protocol::ImpalaService::Client.expects(:new).once
+  it 'should return the results of the query when given a block with a query, and then close tho connection' do
+    Impala::Connection.any_instance.stubs(:query => 'result')
+    Impala::Connection.any_instance.expects(:close).once
+
+    ret = Impala.connect('host', 12345) do |conn|
+      conn.query('query')
     end
 
-    should 'return an open connection when passed a block' do
-      connection = Impala.connect('host', 12345)
-      assert_equal(Impala::Connection, connection.class)
-      assert_equal(true, connection.open?)
+    assert_equal('result', ret)
+  end
+end
+
+describe Impala::Connection do
+  describe '#sanitize_query' do
+    before do
+      Impala::Connection.any_instance.stubs(:open)
+      @connection = Impala::Connection.new('test', 1234)
     end
 
-    should 'return the results of the query when given a block with a query, and then close tho connection' do
-      Impala::Connection.any_instance.stubs(:query => 'result')
-      Impala::Connection.any_instance.expects(:close).once
+    it 'should downcase the command but nothing else' do
+      query = 'SELECT blah FROM Blah'
+      assert_equal('select blah FROM Blah', @connection.send(:sanitize_query, query))
+    end
 
-      ret = Impala.connect('host', 12345) do |conn|
-        conn.query('query')
-      end
+    it 'should reject empty or invalid queries' do
+      assert_raises(Impala::InvalidQueryError) { @connection.send(:sanitize_query, '')}
+      assert_raises(Impala::InvalidQueryError) { @connection.send(:sanitize_query, 'HERRO herro herro')}
+    end
+  end
+
+  describe '#wait_for_result' do
+    before do
+      Impala::Connection.any_instance.stubs(:open)
+      @connection = Impala::Connection.new('test', 1234)
+      @service = stub(:get_state => nil)
+      @connection.instance_variable_set('@service', @service)
+    end
 
-      assert_equal('result', ret)
+    it 'should close the handle if an exception is raised, and then re-raise' do
+      handle = stub()
+      @service.expects(:close).with(handle).once
+      @service.expects(:get_state).raises(StandardError)
+      assert_raises(StandardError) { @connection.send(:wait_for_result, handle) }
     end
   end
 end

data/test/test_impala_connected.rb

@@ -0,0 +1,47 @@
+require 'impala'
+require 'minitest/autorun'
+require 'mocha'
+
+# these are tests that require an available Impala server. To run them,
+# declare a IMPALA_SERVER env var, e.g. `IMPALA_SERVER=localhost:21000 rake`
+IMPALA_SERVER = ENV['IMPALA_SERVER']
+
+def connect
+  parts = IMPALA_SERVER.split(':')
+  if parts.length != 2 || parts.any? { |p| p.empty? }
+    raise "Invalid IMPALA_SERVER: #{IMPALA_SERVER}"
+  end
+
+  host, port = parts
+  Impala.connect(host, port)
+end
+
+describe 'connected tests' do
+  before do
+    skip unless IMPALA_SERVER
+    @connection = connect
+  end
+
+  it 'can successfully connect' do
+    assert_instance_of(Impala::Connection, @connection)
+    assert(@connection.open?, "the connection should be open")
+  end
+
+  it 'can run a basic query' do
+    ret = @connection.query('SELECT 1 AS a')
+    assert_equal([{:a=>1}], ret, "the result should be a list of hashes")
+  end
+
+  # TODO: this test sucks because there's no way to get multiple records
+  # with a literal select. perhaps there should be importable test data?
+  it 'can get a cursor and fetch one row at a time' do
+    cursor = @connection.execute('SELECT 1 AS a')
+    assert_instance_of(Impala::Cursor, cursor, "the result should be a cursor")
+
+    row = cursor.fetch_row
+    assert_equal({:a=>1}, row, "the row should be a hash")
+
+    assert_equal(false, cursor.has_more?, "has_more? should be false")
+    assert_nil(cursor.fetch_row, "subsequent calls to fetch_row should be nil")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: impala
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thrift
@@ -76,37 +76,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.5'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -242,6 +226,7 @@ files:
 - lib/impala/protocol/types_types.rb
 - lib/impala/version.rb
 - test/test_impala.rb
+- test/test_impala_connected.rb
 - thrift/Data.thrift
 - thrift/DataSinks.thrift
 - thrift/Descriptors.thrift
@@ -290,4 +275,5 @@ specification_version: 3
 summary: A ruby client for Cloudera's Impala
 test_files:
 - test/test_impala.rb
+- test/test_impala_connected.rb
 has_rdoc: