impaler 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in impaler.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LivingSocial Inc
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Impaler
+
+Impaler combines the best of Impala and Hive.  Queries are run on Impala and if it fails there it will fallback to running the query in Hive.  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'impaler'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install impaler
+
+## Usage
+
+Basic Usage
+
+    require 'impaler'
+    c = Impaler.connect(['impala_server:21000'], ['hivethrift_server:10000'])
+    c.query("select count(*) from my_table") # This will run in Impala
+    c.query("select name, collect_set(foo) from my_table") # This will run in Hive (after a quick error on Impala)
+    c.query("select count(*) from my_table", Impaler::HIVE_ONLY) # This is forced to run on Hive
+
+## Contributing
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Test your changes in both connected and unconnected modes (`rspec` and `IMPALA_SERVER=server:21000 HIVETHRIFT_SERVER=server:10000 TEST_TABLE=my_test_table TEST_TABLE_COLUMN=some_test_column rspec`
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/impaler.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'impaler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "impaler"
+  spec.version       = Impaler::VERSION
+  spec.authors       = ["John Meagher","Trent Albright"]
+  spec.email         = ["john.meagher@gmail.com","trent.albright@gmail.com"]
+  spec.description   = %q{Wrapper around Impala and Hive gems}
+  spec.summary       = %q{Run in Impala when possible and fall back to Hive when needed}
+  spec.homepage      = "https://github.com/livingsocial/impaler"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "impala"
+  spec.add_dependency "rbhive"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/impaler.rb

@@ -0,0 +1,42 @@
+require "impaler/version"
+
+require "impaler/manager"
+
+module Impaler
+
+  class ImpalerError < StandardError; end
+  class ConnectionError < ImpalerError; end
+  class QueryError < ImpalerError; end
+
+  class ImpalerDefaultLogger < Logger
+    def initialize
+      super(STDOUT)
+      self.level = Logger::WARN
+    end
+  end
+  DEFAULT_LOGGER = ImpalerDefaultLogger.new()
+
+  # Connect to the servers and optionally execute a block of code
+  # with the servers.
+  # @param [String] host:port for the impala server or an array of host:port to pick from many
+  # @param [String] host:port for the hive thirft server (v1) or an array of host:port to pick from many
+  # @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(impala_servers, hivethrift_servers, logger=Impaler::DEFAULT_LOGGER)
+    manager = Manager.new(impala_servers, hivethrift_servers, logger=logger)
+
+    if block_given?
+      begin
+        ret = yield manager
+      ensure
+        manager.close
+      end
+    else
+      ret = manager
+    end
+
+    ret
+  end
+end

data/lib/impaler/manager.rb

@@ -0,0 +1,164 @@
+require "rbhive"
+require "impala"
+
+module Impaler
+
+  IMPALA_THEN_HIVE = 1
+  HIVE_ONLY = 2
+  IMPALA_ONLY = 3
+
+  class Manager
+
+    def initialize(impala_servers, hivethrift_servers, logger=Impaler::DEFAULT_LOGGER)
+      if impala_servers.nil? and hivethrift_servers.nil? 
+        raise Impaler::ConnectionError.new("No impaler or hive servers were specified, at least one is required")
+      end
+
+      if !impala_servers.nil?
+        if impala_servers.respond_to?(:choice)
+          @impala_servers=impala_servers
+        else 
+          @impala_servers=[impala_servers]
+        end
+
+        impala_server = @impala_servers.choice.split(":")
+        @impala_host = impala_server[0]
+        @impala_port = impala_server[1]
+      end
+
+      if !hivethrift_servers.nil?
+        if hivethrift_servers.respond_to?(:choice)
+          @hivethrift_servers=hivethrift_servers
+        else
+          @hivethrift_servers=[hivethrift_servers]
+        end
+        hivethrift_server = @hivethrift_servers.choice.split(":")
+        @hivethrift_host = hivethrift_server[0]
+        @hivethrift_port = hivethrift_server[1]
+      end
+
+      @logger = logger
+      open
+    end
+
+    def open
+      connected=false
+      if !@impala_host.nil? && !@impala_port.nil?
+        @logger.debug "Impala connection #{@impala_host}:#{@impala_port}"
+        @impala_connection = Impala.connect(@impala_host, @impala_port)
+        @impala_connection.open
+        @impala_connection.refresh
+        connected=true
+      else
+        @impala_connection = nil
+      end
+
+      if !@hivethrift_host.nil? && !@hivethrift_port.nil?
+        @logger.debug "Hivethrift connection #{@hivethrift_host}:#{@hivethrift_port}"
+        @hivethrift_connection = RBHive::Connection.new(@hivethrift_host, @hivethrift_port)
+        @hivethrift_connection.open
+        connected=true
+      else
+        @hivethrift_connection = nil
+      end
+
+      if !connected
+        raise Impaler::ConnectionError.new("All connections failed")
+      end
+    end
+
+    def close
+      if !@impala_connection.nil?
+        @impala_connection.close
+        @impala_connection = nil
+      end
+
+      if !@hivethrift_connection.nil?
+        @hivethrift_connection.close
+        @hivethrift_connection = nil
+      end
+    end
+
+
+    # ###########################################################################
+    # General use methods
+
+    def query(sql, query_mode = Impaler::IMPALA_THEN_HIVE)
+      ret = nil
+      error = nil
+      success = false
+      unless query_mode == Impaler::HIVE_ONLY or @impala_connection.nil? 
+        begin
+          @logger.debug "Trying query in impala"
+          ret = @impala_connection.query(sql)
+          @logger.debug "Successful query in impala"
+          success = true
+        rescue StandardError => e
+          error = e
+          @logger.warn "Impala error: #{e}"
+        end
+      end
+
+      unless @hivethrift_connection.nil? || success || query_mode == Impaler::IMPALA_ONLY 
+        begin
+          @logger.debug "Trying query in hive"
+          ret = @hivethrift_connection.fetch(sql)
+          @logger.debug "Successful query in hive"
+          success = true
+        rescue StandardError => e
+          error = e
+          @logger.warn "Hive error: #{e}"
+        end
+      end
+
+      if !success && !error.nil? 
+        raise error
+      elsif !success 
+        raise Impaler::QueryError.new("Query did not run due to no connections being available")
+      end
+      return ret
+    end
+
+    def set(key, value)
+      # Only run on hive since that's the only one that supports set for now
+      if !@hivethrift_connection.nil?
+        @hivethrift_connection.set(key, value)
+      end
+    end
+
+
+    # ###########################################################################
+    # Helper query methods
+    
+    def row_count(tablename)
+        query("SELECT COUNT(1) c FROM #{tablename}").first[:c]
+    end
+
+
+
+
+
+    # ###########################################################################
+    # Metadata methods
+
+    def columns(tablename)
+      desc = {}
+      (query "describe #{tablename}").each { |col|
+        cname=col[:name] || col[:col_name]
+        ctype=col[:type] || col[:data_type]
+        desc[cname.intern] = ctype.intern
+      }
+      desc
+    end
+
+    def tables(pattern=nil)
+      q = "SHOW TABLES" + ((pattern.nil?) ? "" : " '#{pattern}'")
+      query(q).collect { |table|
+        table[:name] || table[:tab_name]
+      }
+    end
+
+  end
+
+
+end

data/lib/impaler/version.rb

@@ -0,0 +1,3 @@
+module Impaler
+  VERSION = "0.0.1"
+end

data/spec/impaler_connected_spec.rb

@@ -0,0 +1,211 @@
+require 'impaler'
+
+# These tests cover the Impaler interaction with a real impala and hive server.
+# To run these define environment variables for IMPALA_SERVER and HIVETHRIFT_SERVER
+# in the format "server:port".
+
+IMPALA_SERVER=ENV['IMPALA_SERVER']
+HIVETHRIFT_SERVER=ENV['HIVETHRIFT_SERVER']
+has_servers=!IMPALA_SERVER.nil? && !HIVETHRIFT_SERVER.nil?
+IMPALA_SERVERS=[IMPALA_SERVER]
+HIVETHRIFT_SERVERS=[HIVETHRIFT_SERVER]
+
+TEST_TABLE=ENV['TEST_TABLE']
+TEST_TABLE_COLUMN=ENV['TEST_TABLE_COLUMN']
+has_tables=!TEST_TABLE.nil? && !TEST_TABLE_COLUMN.nil?
+
+run_tests=has_tables && has_servers
+
+SKIP_SLOW=!ENV['SKIP_SLOW'].nil?
+
+def connect
+  Impaler.connect(IMPALA_SERVERS, HIVETHRIFT_SERVERS)
+end
+
+def connect_impala
+  Impaler.connect(IMPALA_SERVERS, nil)
+end
+
+def connect_hivethrift
+  Impaler.connect(nil, HIVETHRIFT_SERVERS)
+end
+
+
+describe Impaler, :if => run_tests do 
+  it("Connected skip", :if=>!run_tests) {
+    puts "Skipping connected tests for Impaler, set the environment variables IMPALA_SERVER, HIVETHRIFT_SERVER, TEST_TABLE, and TEST_TABLE_COLUMN to enable these"
+    puts "IMPALA_SERVER and HIVETHRIFT_SERVER are in the format 'server:port'"
+    puts "TEST_TABLE should be a fairly small table for quick tests and TEST_TABLE_COLUMN will be used for some simple test queries where Impala is known to not support the query"
+    puts "Optionally set the environment varialbe SKIP_SLOW=true to skip the hive invocations which are a bit slow"
+  }
+
+
+  describe "connect" do
+    it "connects without error" do
+      expect { Impaler::connect(IMPALA_SERVERS, HIVETHRIFT_SERVERS) }.not_to raise_error
+      expect { Impaler::connect(IMPALA_SERVERS, nil) }.not_to raise_error
+      expect { Impaler::connect(nil, HIVETHRIFT_SERVERS) }.not_to raise_error
+    end
+
+    it "connects with single value server entries without error" do
+      expect { Impaler::connect(IMPALA_SERVER, HIVETHRIFT_SERVER) }.not_to raise_error
+      expect { Impaler::connect(IMPALA_SERVER, nil) }.not_to raise_error
+      expect { Impaler::connect(nil, HIVETHRIFT_SERVER) }.not_to raise_error
+    end
+  end
+
+  describe "close" do
+    it "opens and closes without errors" do
+      expect { connect.close }.not_to raise_error
+      expect { connect_impala.close }.not_to raise_error
+      expect { connect_hivethrift.close }.not_to raise_error
+    end
+
+    it "fails after a close" do
+      expect { 
+        c=connect
+        c.close
+        c.query "select count(*) from #{TEST_TABLE}"
+      }.to raise_error(Impaler::QueryError)
+    end
+  end
+
+  describe "simple query" do
+    it "supports a count(*) query" do
+      c = connect
+      count = (c.query "select count(*) c from #{TEST_TABLE}").first[:c]
+      (c.query "select count(*) c from #{TEST_TABLE}").first[:c].should eq(count)
+      (c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_ONLY).first[:c].should eq(count)
+      (c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_THEN_HIVE).first[:c].should eq(count)
+      if !SKIP_SLOW 
+        (c.query "select count(*) c from #{TEST_TABLE}", Impaler::HIVE_ONLY).first[:c].should eq(count)
+      end
+    end
+
+    it "fails with garbage queries" do
+      c = connect
+      expect { c.query "select sdffdsa from lkjasdfjkhadf", Impaler::IMPALA_ONLY }.to raise_error(Impala::Protocol::Beeswax::BeeswaxException)
+      expect { c.query "select sdffdsa from lkjasdfjkhadf", Impaler::HIVE_ONLY }.to raise_error(HiveServerException)
+      expect { c.query "select sdffdsa from lkjasdfjkhadf" }.to raise_error(HiveServerException)
+    end
+
+  end
+
+  describe "unsupported impala queries", :unless => SKIP_SLOW do
+
+    it "fails when run with impala only" do
+      c = connect
+      expect { c.query "select collect_set(#{TEST_TABLE_COLUMN}) from #{TEST_TABLE}", Impaler::IMPALA_ONLY }.to raise_error(Impala::Protocol::Beeswax::BeeswaxException)
+    end
+
+    it "falls back to hive if impala generates an error" do
+      c = connect
+      expect { c.query "select collect_set(#{TEST_TABLE_COLUMN}) from #{TEST_TABLE}" }.not_to raise_error
+    end
+
+  end
+
+  describe "handles down servers" do
+    it "handles having no impala server" do
+      c = connect_hivethrift
+      expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_ONLY }.to raise_error(Impaler::QueryError)
+      if !SKIP_SLOW 
+        expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::HIVE_ONLY }.not_to raise_error
+        expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_THEN_HIVE }.not_to raise_error
+      end
+    end
+
+    it "handles having no hive server" do
+      c = connect_impala
+      expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::HIVE_ONLY }.to raise_error(Impaler::QueryError)
+      expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_ONLY }.not_to raise_error
+      expect { c.query "select count(*) c from #{TEST_TABLE}", Impaler::IMPALA_THEN_HIVE }.not_to raise_error
+    end
+  end
+
+  describe "query consistency", :unless => SKIP_SLOW do
+
+    it "queries return the same regardless of connection type" do
+      q="select * from #{TEST_TABLE} limit 5"
+      c = connect
+      base = c.query(q)
+
+      t=connect_impala.query(q)
+      expect(t).to eq(base)
+
+      t=connect_hivethrift.query(q)
+      expect(t).to eq(base)
+    end
+  end
+
+  describe "columns method works" do
+
+    it "columns returns the same regardless of connection type" do
+      c = connect
+      base = c.columns(TEST_TABLE)
+
+      t=connect_impala.columns(TEST_TABLE)
+      expect(t).to eq(base)
+
+      t=connect_hivethrift.columns(TEST_TABLE)
+      expect(t).to eq(base)
+    end
+  end
+
+  describe "row_count method works", :unless => SKIP_SLOW do
+
+    it "row_count returns the same regardless of connection type" do
+      c = connect
+      base = c.row_count(TEST_TABLE)
+
+      t=connect_impala.row_count(TEST_TABLE)
+      expect(t).to eq(base)
+
+      t=connect_hivethrift.row_count(TEST_TABLE)
+      expect(t).to eq(base)
+    end
+  end
+
+
+  describe "tables method works" do
+
+    it "appears to work correctly in a basic mode" do
+      t=connect.tables
+      expect(t).to include(TEST_TABLE)
+    end
+
+    it "works with patterns" do
+      t=connect.tables("#{TEST_TABLE[0,2]}*")
+      expect(t).to include(TEST_TABLE)
+
+      t=connect_impala.tables("#{TEST_TABLE[0,2]}*")
+      expect(t).to include(TEST_TABLE)
+
+      t=connect_hivethrift.tables("#{TEST_TABLE[0,2]}*")
+      expect(t).to include(TEST_TABLE)
+    end
+
+    it "tables returns the same regardless of connection type" do
+      c = connect
+      base = c.tables(TEST_TABLE)
+
+      t=connect_impala.tables(TEST_TABLE)
+      expect(t).to eq(base)
+
+      t=connect_hivethrift.tables(TEST_TABLE)
+      expect(t).to eq(base)
+    end
+
+    it "tables returns the same with no args regardless of connection type" do
+      c = connect
+      base = c.tables
+
+      t=connect_impala.tables
+      expect(t).to eq(base)
+
+      t=connect_hivethrift.tables
+      expect(t).to eq(base)
+    end
+  end
+
+end

data/spec/impaler_spec.rb

@@ -0,0 +1,91 @@
+require 'impaler'
+
+# These tests cover the internals of the Impaler library in isolation as much as possible
+
+describe Impaler do
+  before(:each) do
+    RBHive::Connection.any_instance.stub(:open).and_return(true)
+    Impala::Connection.any_instance.stub(:open).and_return(true)
+    Impala::Connection.any_instance.stub(:refresh).and_return(true)
+  end
+
+  describe "connect" do
+    it "fails with no servers" do
+      expect { Impaler::connect(nil, nil) }.to raise_error(Impaler::ConnectionError)
+    end
+
+    it "handles valid server strings" do
+
+      impala_server = "impala"
+      impala_port = "123"
+      hivethrift_server = "hivethrift"
+      hivethrift_port = "456"
+
+      verify = lambda{|conn, check_impala, check_hivethrift| 
+        if check_impala 
+          conn.instance_variable_get(:@impala_host).should eq(impala_server)
+          conn.instance_variable_get(:@impala_port).should eq(impala_port)
+        end
+        if check_hivethrift 
+          conn.instance_variable_get(:@hivethrift_host).should eq(hivethrift_server)
+          conn.instance_variable_get(:@hivethrift_port).should eq(hivethrift_port)
+        end
+      }
+
+      #Impaler::Manager.any_instance.stub(:open).and_return(true)
+      impala = "#{impala_server}:#{impala_port}"
+      hivethrift = "#{hivethrift_server}:#{hivethrift_port}"
+
+      verify.call( Impaler.connect( impala, nil ), true, false)
+      verify.call( Impaler.connect( nil, hivethrift ), false, true)
+      verify.call( Impaler.connect( impala, hivethrift ), true, true)
+    end
+
+  end
+
+  describe "handles errors" do
+     let(:conn) { Impaler.connect("impala:999","hive:999") }
+     let(:impala_conn) { Impaler.connect("impala:999",nil) }
+     let(:hive_conn) { Impaler.connect(nil,"hive:999") }
+     let(:q) { "select count(*) from foo" }
+     let(:q_return) { [{:c=>1}] }
+
+     it "handles the no error state and uses impala" do
+       Impala::Connection.any_instance.stub(:query).and_return(q_return)
+       RBHive::Connection.any_instance.stub(:fetch).and_raise(StandardError)
+       conn.query(q).should eq(q_return)
+     end
+
+     it "handles an impala error and falls back to hive" do
+       Impala::Connection.any_instance.stub(:query).and_raise(StandardError)
+       RBHive::Connection.any_instance.stub(:fetch).and_return(q_return)
+       conn.query(q).should eq(q_return)
+     end
+
+     it "failure of both throws an error" do
+       Impala::Connection.any_instance.stub(:query).and_raise(StandardError)
+       RBHive::Connection.any_instance.stub(:fetch).and_raise(StandardError)
+       expect { conn.query(q) }.to raise_error(StandardError)
+     end
+
+     it "impala only throws an error if impala errs" do
+       Impala::Connection.any_instance.stub(:query).and_raise(StandardError)
+       RBHive::Connection.any_instance.stub(:fetch).and_return(q_return)
+       expect { impala_conn.query(q) }.to raise_error(StandardError)
+     end
+
+     it "skipping impala works" do
+       Impala::Connection.any_instance.stub(:query).and_return([])
+       RBHive::Connection.any_instance.stub(:fetch).and_return(q_return)
+       conn.query(q, Impaler::HIVE_ONLY).should eq(q_return)
+     end
+
+     it "skipping hive works" do
+       Impala::Connection.any_instance.stub(:query).and_raise(StandardError)
+       RBHive::Connection.any_instance.stub(:fetch).and_return(q_return)
+       expect { conn.query(q, Impaler::IMPALA_ONLY) }.to raise_error(StandardError)
+     end
+  end
+
+
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: impaler
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- John Meagher
+- Trent Albright
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-09-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: impala
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rbhive
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Wrapper around Impala and Hive gems
+email: 
+- john.meagher@gmail.com
+- trent.albright@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- impaler.gemspec
+- lib/impaler.rb
+- lib/impaler/manager.rb
+- lib/impaler/version.rb
+- spec/impaler_connected_spec.rb
+- spec/impaler_spec.rb
+has_rdoc: true
+homepage: https://github.com/livingsocial/impaler
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Run in Impala when possible and fall back to Hive when needed
+test_files: 
+- spec/impaler_connected_spec.rb
+- spec/impaler_spec.rb