rsconn 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c30c89eb0d8df0325b2e030f9456e007b73bd91
+  data.tar.gz: f92be0b7307b051a9ae335b9b23d2d5428bd730a
+SHA512:
+  metadata.gz: 974295630b65b75e56c3c46540fa4201b158dbd2b1abd1e0f78fecf0d45bd06e4adff49bb1c9ed636e00e875c9d51535cd821622028540e0d336fffa27cffa5c
+  data.tar.gz: 17a74642754c11403981bb81105c1fa1a6877914fead77a2c0c71f39a3107cdff04cbd35d3997693cb340a4b0424fcd3fff0aa52c2d4f57989795f3f31ea7a70

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/README.md

@@ -0,0 +1,29 @@
+# rsconn
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rsconn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rsconn
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/deanmorin/rsconn/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+
+task :default => [:spec]
+spec = RSpec::Core::RakeTask.new(:spec)

data/lib/rsconn/jdbc_url.rb

@@ -0,0 +1,18 @@
+module Rsconn
+  class JdbcUrl
+    attr_reader :url, :host, :port, :database
+
+    def initialize(url)
+      @url = url
+      @host = @url.split('//').last.split(':').first
+      @port = @url.split(':').last.split('/').first.to_i
+      @database = @url.split('/').last
+
+      db_type = @url.split(':')[1]
+
+      if db_type != 'postgresql'
+        fail ArgumentError, 'Only works with a "postgresql" JDBC URL'
+      end
+    end
+  end
+end

data/lib/rsconn/logger.rb

@@ -0,0 +1,31 @@
+require 'singleton'
+require 'time'
+
+
+module Rsconn
+  class Logger
+
+    def initialize(options={})
+      @secrets = options.fetch(:secrets, [])
+      @secrets << ENV['AWS_SECRET_ACCESS_KEY'] if ENV['AWS_SECRET_ACCESS_KEY']
+    end
+
+    def log(msg)
+      puts "#{now_utc} | #{hide_secrets(msg)}"
+    end
+
+    private
+
+    def hide_secrets(msg)
+      @secrets.inject(msg) {|message, secret| hide_secret(message, secret) }
+    end
+
+    def hide_secret(msg, secret)
+      msg.sub(secret, '*' * secret.length)
+    end
+
+    def now_utc
+      DateTime.now.new_offset(0).strftime('%Y-%m-%d %H:%M:%S')
+    end
+  end
+end

data/lib/rsconn/postgres.rb

@@ -0,0 +1,176 @@
+require 'pg'
+require 'rsconn/jdbc_url'
+require 'rsconn/logger'
+
+
+module Rsconn
+  class PG::Result
+    def length
+      ntuples
+    end
+  end
+
+
+  class Postgres
+    attr_reader :conn
+
+    def initialize(jdbc_url, user, password, options={})
+      fail_if_invalid_connection_credentials(jdbc_url, user, password)
+
+      @abort_on_error = options.fetch(:abort_on_error, true)
+      @max_retries = options.fetch(:max_retries, 3)
+      @quiet = options.fetch(:quiet, false)
+      @jdbc_url = JdbcUrl.new(jdbc_url)
+      @user = user
+      @password = password
+      @error_occurred = false
+      @retry_count = 0
+
+      secrets = options.fetch(:secrets, [])
+      @logger = Logger.new(:secrets => secrets)
+
+      init_connection
+    end
+
+    def execute(sql, options={})
+      quiet = options.fetch(:quiet, @quiet)
+
+      log "\n#{sql}\n" unless quiet
+      result = with_error_handling { @conn.exec(sql) }
+
+      cmd = result.cmd_status.split.first
+      affected_rows = result.cmd_tuples
+
+      if %w(INSERT UPDATE DELETE MOVE FETCH).include?(cmd)
+        log "Affected #{affected_rows} row(s)." unless quiet
+      end
+
+      affected_rows
+    end
+
+    def query(sql, options={})
+      quiet = options.fetch(:quiet, @quiet)
+
+      log "\n#{sql}\n" unless quiet
+      result = with_error_handling { @conn.exec(sql) }
+      TypecastResult.new(result).result
+    end
+
+    def execute_script(filename, options={})
+      File.open(filename) do |fh|
+        sql = fh.read
+        sql = remove_comments(sql)
+        sql = substitute_variables(sql)
+        execute_each_statement(sql, options)
+      end
+    end
+
+    def error_occurred?
+      @error_occurred
+    end
+
+    def clear_error_state
+      @error_occurred = false
+    end
+
+    def drop_table_if_exists(table, options={})
+      cascade = options.delete(:cascade) ? ' CASCADE' : ''
+      execute("DROP TABLE IF EXISTS #{table}#{cascade};", options)
+    end
+
+    def drop_view_if_exists(view, options={})
+      cascade = options.delete(:cascade) ? ' CASCADE' : ''
+      execute("DROP VIEW IF EXISTS #{view}#{cascade};", options)
+    end
+
+    def table_exists?(schema, table)
+      sql = <<-SQL
+        SELECT count(*) FROM pg_tables
+        WHERE schemaname = '#{schema}' AND tablename = '#{table}'
+        ;
+      SQL
+      query(sql, :quiet => true).first['count'] == 1
+    end
+
+    private
+
+    def fail_if_invalid_connection_credentials(jdbc_url, user, password)
+      fail ArgumentError, 'jdbc_url needs to be a string' unless jdbc_url.is_a?(String)
+      fail ArgumentError, 'user needs to be a string' unless user.is_a?(String)
+      fail ArgumentError, 'password needs to be a string' unless password.is_a?(String)
+    end
+
+    def init_connection
+      with_error_handling do
+        @conn = PGconn.open(
+          :host => @jdbc_url.host,
+          :port => @jdbc_url.port,
+          :dbname => @jdbc_url.database,
+          :user => @user,
+          :password => @password,
+        )
+      end
+    end
+
+    # errors_to_ignore should only be used where no return value is expected
+    def with_error_handling
+      return_value = yield
+      @retry_count = 0
+      return_value
+
+    rescue PG::Error => e
+      if recoverable_error?(e) && @retry_count < @max_retries
+        @retry_count += 1
+        sleep_time = sleep_time_for_error(e)
+        log "Failed with recoverable error (#{e.class}): #{e}"
+        log "Retry attempt #{@retry_count} will occur after #{sleep_time} seconds"
+        sleep sleep_time
+        retry
+
+      else
+        @retry_count = 0
+        @error_occurred = true
+        log "An error occurred (#{e.class}): #{e}"
+        log e.backtrace.join("\n")
+
+        raise e if @abort_on_error
+      end
+    end
+
+    def recoverable_error?(err_msg)
+      false
+    end
+
+    def sleep_time_for_error(err_msg)
+      60
+    end
+
+    def sql_exception_class
+      fail NotImplementedError, 'sql_exception_class'
+    end
+
+    def remove_comments(sql)
+      lines = sql.split("\n")
+      stripped_lines = lines.reject {|line| starts_with_double_dash?(line) }
+      stripped_lines.join("\n")
+    end
+
+    def starts_with_double_dash?(line)
+      line =~ /\A\s*--/
+    end
+
+    def substitute_variables(sql)
+      sql
+    end
+
+    def execute_each_statement(sql, options={})
+      sql.split(/;\s*$/).each do |statement|
+        execute("#{statement};", options)
+      end
+    end
+
+    def log(msg)
+      @logger.log(msg)
+    end
+  end
+end

data/lib/rsconn/typecast_result.rb

@@ -0,0 +1,65 @@
+module Rsconn
+  class TypecastResult
+    attr_reader :result
+
+    TYPE_BOOLEAN = 16
+    TYPE_BIGINT = 20
+    TYPE_SMALLINT = 21
+    TYPE_INTEGER = 23
+    TYPE_OID = 26
+    TYPE_REAL = 700
+    TYPE_DOUBLE_PRECISION = 701
+    TYPE_MONEY = 790
+    TYPE_NUMERIC = 1700
+    TYPE_DATE = 1082
+    TYPE_TIMESTAMP_WITHOUT_TIME_ZONE = 1114
+    TYPE_TIMESTAMP_WITH_TIME_ZONE = 1184
+
+    def initialize(uncast_result)
+      @uncast_result = uncast_result
+      @result = uncast_result.map {|row| typecast_row(row) }
+    end
+
+    private
+
+    def typecast_row(row)
+      (0...@uncast_result.nfields).each do |index|
+        column = @uncast_result.fname(index)
+        type = @uncast_result.ftype(index)
+        value = row[column]
+
+        row[column] = typecast(type, value)
+      end
+      row
+    end
+
+    def typecast(type, value)
+      case type
+
+      when TYPE_BOOLEAN
+        if value == 't'
+          true
+        elsif value == 'f'
+          false
+        else
+          fail 'unexpected boolean string'
+        end
+
+      when TYPE_BIGINT, TYPE_SMALLINT, TYPE_INTEGER, TYPE_OID
+        value.to_i
+
+      when TYPE_REAL, TYPE_DOUBLE_PRECISION
+        value.to_f
+
+      when TYPE_MONEY, TYPE_NUMERIC
+        BigDecimal.new(value)
+
+      when TYPE_DATE, TYPE_TIMESTAMP_WITHOUT_TIME_ZONE, TYPE_TIMESTAMP_WITH_TIME_ZONE
+        DateTime.strptime(value, '%Y-%m-%d %H:%M:%S')
+
+      else
+        value
+      end
+    end
+  end
+end

data/lib/rsconn/version.rb

@@ -0,0 +1,3 @@
+module Rsconn
+  VERSION = '0.0.1'
+end

data/lib/rsconn.rb

@@ -0,0 +1,25 @@
+require 'rsconn/postgres'
+
+
+module Rsconn
+  class Redshift < Postgres
+    attr_reader :query_group, :query_slot_count
+
+    def initialize(jdbc_url, user, password, options={})
+      super
+      @query_group = options.fetch(:query_group, nil)
+      @query_slot_count = options.fetch(:query_slot_count, nil)
+
+      set_query_group(@query_group) if @query_group
+      set_query_slot_count(@query_slot_count) if @query_slot_count
+    end
+
+    def set_query_group(query_group)
+      execute("SET query_group TO #{query_group};")
+    end
+
+    def set_query_slot_count(count)
+      execute("SET wlm_query_slot_count TO #{count};")
+    end
+  end
+end

data/rsconn.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rsconn/version'
+
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rsconn'
+  spec.version       = Rsconn::VERSION
+  spec.authors       = ['Dean Morin']
+  spec.email         = ['morin.dean@gmail.com']
+  spec.summary       = 'Redshift wrapper.'
+  spec.description = <<-EOS
+    Convience wrapper for using Redshift.
+  EOS
+  spec.homepage      = 'http://github.com/deanmorin/rsconn'
+  spec.license       = 'The Unlicense'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 'pg', '~> 0.17'
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'pry', '~> 0.10', '>= 0.10.1'
+  spec.add_development_dependency 'pry-nav', '~> 0.2', '>= 0.2.4'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'rspec-its', '~> 1'
+end

data/spec/custom_matchers.rb

@@ -0,0 +1,11 @@
+module Rsconn
+  RSpec::Matchers.define :only_include_class do |klass|
+    match do |actual|
+      actual.result.all? {|row| row.keys.all? {|key| row[key].class == klass } }
+    end
+
+    failure_message do |actual|
+      "expected every value's class to be '#{klass}'"
+    end
+  end
+end

data/spec/dev_redshift.rb

@@ -0,0 +1,16 @@
+require 'rsconn'
+
+
+module Rsconn
+  class DevRedshift < Redshift
+
+    def initialize(options={})
+      super(
+        ENV['RSCONN_JDBC_URL'],
+        ENV['RSCONN_USER'],
+        ENV['RSCONN_PASSWORD'],
+        options
+      )
+    end
+  end
+end

data/spec/jdbc_url_spec.rb

@@ -0,0 +1,29 @@
+require 'rspec/its'
+require 'rsconn/jdbc_url'
+
+
+module Rsconn
+  describe JdbcUrl do
+    HOST = 'host.redshift.amazonaws.com'
+    PORT = 5439
+    DATABASE = 'dbname'
+    JDBC_URL = "jdbc:postgresql://#{HOST}:#{PORT}/#{DATABASE}"
+    MYSQL_URL = "jdbc:mysql://#{HOST}:#{PORT}/#{DATABASE}"
+
+    describe '#new' do
+
+      context 'when a good url is given' do
+        subject { JdbcUrl.new(JDBC_URL) }
+        its(:url) { should eq(JDBC_URL) }
+        its(:host) { should eq(HOST) }
+        its(:port) { should eq(PORT) }
+        its(:database) { should eq(DATABASE) }
+      end
+
+      context 'when a mysql url is given' do
+        subject { JdbcUrl.new(MYSQL_URL) }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+    end
+  end
+end

data/spec/redshift_spec.rb

@@ -0,0 +1,74 @@
+require_relative 'dev_redshift'
+
+
+module Rsconn
+  describe 'Redshift' do
+
+    before(:all) do
+      @db_conn = DevRedshift.new
+    end
+
+    after(:all) do
+      @db_conn.drop_table_if_exists('test.tmp_drop_if_exists')
+      @db_conn.drop_table_if_exists('test.tmp_test_table')
+      @db_conn.drop_view_if_exists('test.tmp_test_table_vw')
+    end
+
+    describe '#drop_table_if_exists' do
+
+      it 'ignores a missing table' do
+        @db_conn.drop_table_if_exists('test.i_dont_exist')
+        expect(@db_conn.error_occurred?).to be false
+      end
+
+      it 'drops an existing table' do
+        @db_conn.drop_table_if_exists('test.tmp_drop_if_exists')
+        @db_conn.execute('CREATE TABLE test.tmp_drop_if_exists (tmp boolean)')
+        @db_conn.drop_table_if_exists('test.tmp_drop_if_exists')
+        expect(@db_conn.error_occurred?).to be false
+      end
+
+      it 'cascades when :cascade option is true' do
+        @db_conn.execute('CREATE TABLE test.tmp_test_table (tmp boolean)')
+        @db_conn.execute('CREATE VIEW test.tmp_test_table_vw AS SELECT * ' +
+                         'FROM test.tmp_test_table')
+        @db_conn.drop_table_if_exists('test.tmp_test_table', :cascade => true)
+        sql = "SELECT count(*) FROM pg_views WHERE viewname = 'tmp_test_table_vw'"
+
+        count = @db_conn.query(sql).first['count']
+        expect(count).to eq(0)
+      end
+    end
+
+    describe '#drop_view_if_exists' do
+
+      it 'ignores a missing view' do
+        @db_conn.drop_view_if_exists('test.i_dont_exist_vw')
+        expect(@db_conn.error_occurred?).to be false
+      end
+
+      it 'drops an existing view' do
+        @db_conn.drop_table_if_exists('test.tmp_test_table', :cascade => true)
+        @db_conn.execute('CREATE TABLE test.tmp_test_table (tmp boolean)')
+        @db_conn.execute('CREATE VIEW test.tmp_drop_if_exists_vw AS SELECT * ' +
+                         'FROM test.tmp_test_table')
+        @db_conn.drop_view_if_exists('test.tmp_drop_if_exists_vw')
+        @db_conn.execute('DROP TABLE test.tmp_test_table')
+        expect(@db_conn.error_occurred?).to be false
+      end
+    end
+
+    describe '#get_field_by_type' do
+
+      it 'converts booleans correctly' do
+        @db_conn.execute('CREATE TABLE test.tmp_test_table (tmp boolean)')
+        @db_conn.execute('INSERT INTO test.tmp_test_table VALUES (true), (false)')
+        rows = @db_conn.query('SELECT * FROM test.tmp_test_table ORDER BY tmp')
+        @db_conn.drop_table_if_exists('test.tmp_test_table')
+
+        expect(rows[0]['tmp']).to be false
+        expect(rows[1]['tmp']).to be true
+      end
+    end
+  end
+end

data/spec/typecast_result_spec.rb

@@ -0,0 +1,121 @@
+require 'bigdecimal'
+require 'rspec/its'
+require 'rsconn/typecast_result'
+require_relative 'custom_matchers'
+
+
+module Rsconn
+  class ResultStub < Array
+
+    def initialize
+      super(1)
+    end
+
+    def fname(index)
+      self.first.keys[index]
+    end
+
+    def ftype(index)
+      @ftypes[index]
+    end
+
+    def nfields
+      self.first.keys.length
+    end
+  end
+
+  class BooleanResultStub < ResultStub
+    def initialize
+      self[0] = { 'true' => 't', 'false' => 'f' }
+      @ftypes = [TypecastResult::TYPE_BOOLEAN, TypecastResult::TYPE_BOOLEAN]
+    end
+  end
+
+  class BadBooleanResultStub < ResultStub
+    def initialize
+      self[0] = { 'bad' => 'true' }
+      @ftypes = [TypecastResult::TYPE_BOOLEAN]
+    end
+  end
+
+  class IntegerResultStub < ResultStub
+    def initialize
+      self[0] = { 'c1' => '1', 'c2' => '2', 'c3' => '3', 'c4' => '4' }
+      @ftypes = [
+        TypecastResult::TYPE_BIGINT, TypecastResult::TYPE_SMALLINT,
+        TypecastResult::TYPE_INTEGER, TypecastResult::TYPE_OID
+      ]
+    end
+  end
+
+  class FloatResultStub < ResultStub
+    def initialize
+      self[0] = { 'c1' => '-3', 'c2' => '4.111111111111111111' }
+      @ftypes = [TypecastResult::TYPE_REAL, TypecastResult::TYPE_DOUBLE_PRECISION]
+    end
+  end
+
+  class BigDecimalResultStub < ResultStub
+    def initialize
+      self[0] = { 'c1' => '-3', 'c2' => '4.11111111111111111111111111111111111111111111111111' }
+      @ftypes = [TypecastResult::TYPE_MONEY, TypecastResult::TYPE_NUMERIC]
+    end
+  end
+
+  class DateTimeResultStub < ResultStub
+    def initialize
+      self[0] = {
+        'c1' => '1900-01-01 00:00:00',
+        'c2' => '3000-01-01 01:00:00',
+        'c3' => '4000-01-01 23:32:11'
+      }
+      @ftypes = [
+        TypecastResult::TYPE_DATE,
+        TypecastResult::TYPE_TIMESTAMP_WITHOUT_TIME_ZONE,
+        TypecastResult::TYPE_TIMESTAMP_WITH_TIME_ZONE
+      ]
+    end
+  end
+
+
+  describe TypecastResult do
+
+    describe '#new' do
+
+      context "when there's booleans in the results" do
+        subject { TypecastResult.new(BooleanResultStub.new) }
+        let(:expected) { [{ 'true' => true, 'false' => false }] }
+        its(:result) { is_expected.to eq(expected) }
+      end
+
+      context "when there's an bad boolean value in the results" do
+        subject { TypecastResult.new(BadBooleanResultStub.new) }
+        it { expect { subject }.to raise_error(RuntimeError) }
+      end
+
+      context "when there's integers in the results" do
+        subject { TypecastResult.new(IntegerResultStub.new) }
+        let(:expected) { [{ 'c1' => 1, 'c2' => 2, 'c3' => 3, 'c4' => 4 }] }
+        its(:result) { is_expected.to eq(expected) }
+        it { is_expected.to only_include_class(Fixnum) }
+      end
+
+      context "when there's floating point numbers in the results" do
+        subject { TypecastResult.new(FloatResultStub.new) }
+        let(:expected) { [{ 'c1' => -3, 'c2' => 4.111111111111111111.to_f }] }
+        its(:result) { is_expected.to eq(expected) }
+        it { is_expected.to only_include_class(Float) }
+      end
+
+      context "when there's large or non-arbitrary precision numbers in the results" do
+        subject { TypecastResult.new(BigDecimalResultStub.new) }
+        it { is_expected.to only_include_class(BigDecimal) }
+      end
+
+      context "when there's timestamps in the results" do
+        subject { TypecastResult.new(DateTimeResultStub.new) }
+        it { is_expected.to only_include_class(DateTime) }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: rsconn
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dean Morin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: |2
+      Convience wrapper for using Redshift.
+email:
+- morin.dean@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rsconn.rb
+- lib/rsconn/jdbc_url.rb
+- lib/rsconn/logger.rb
+- lib/rsconn/postgres.rb
+- lib/rsconn/typecast_result.rb
+- lib/rsconn/version.rb
+- rsconn.gemspec
+- spec/custom_matchers.rb
+- spec/dev_redshift.rb
+- spec/jdbc_url_spec.rb
+- spec/redshift_spec.rb
+- spec/typecast_result_spec.rb
+homepage: http://github.com/deanmorin/rsconn
+licenses:
+- The Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Redshift wrapper.
+test_files:
+- spec/custom_matchers.rb
+- spec/dev_redshift.rb
+- spec/jdbc_url_spec.rb
+- spec/redshift_spec.rb
+- spec/typecast_result_spec.rb