athena-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea56f38290709fb3f5b0351f88cfa946b10d820f
+  data.tar.gz: ab1d16e5143dde991ef413f014c60456a8bacb01
+SHA512:
+  metadata.gz: e8b87e4a1b879ac686194e0a91a8ff4cee7b292056acaf2bf9da2cacc9a78abd44c2ebd9825f2bf51492c7495d9c20efe1ef9aff2356d9b83f22c5969cad0a88
+  data.tar.gz: e1109e094eb8c5c33acb55254784bce9f43db3c012e5ae36d8379db12c00f0d1cf321404a4de07a61f2e97d69e0ca4690d274c724f86a2fa593d94914e6679e1

data/.gitignore

@@ -0,0 +1,5 @@
+jdbc
+pkg
+queries
+results.html
+schemas

data/.projections.json

@@ -0,0 +1,20 @@
+{
+  "test/*_test.rb": {
+    "alternate": [
+      "{}.rb"
+    ],
+    "type": "test"
+  },
+  "lib/amazon_athena/commands/*.rb": {
+    "alternate": [
+      "test/lib/amazon_athena/commands/{}_test.rb"
+    ],
+    "type": "command"
+  },
+  "lib/*.rb": {
+    "alternate": [
+      "test/lib/{}_test.rb"
+    ],
+    "type": "lib"
+  }
+}

data/.ruby-version

@@ -0,0 +1 @@
+jruby-9.1.6.0

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+group :development do
+  gem "pry"
+end
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,75 @@
+PATH
+  remote: .
+  specs:
+    athena-cli (0.0.1)
+      gli (= 2.5.2)
+      jdbc-helper (~> 0.8.2)
+      table_print (~> 1.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aruba (0.14.2)
+      childprocess (~> 0.5.6)
+      contracts (~> 0.9)
+      cucumber (>= 1.3.19)
+      ffi (~> 1.9.10)
+      rspec-expectations (>= 2.99)
+      thor (~> 0.19)
+    builder (3.2.3)
+    childprocess (0.5.9)
+      ffi (~> 1.0, >= 1.0.11)
+    coderay (1.1.1)
+    contracts (0.15.0)
+    cucumber (2.4.0)
+      builder (>= 2.1.2)
+      cucumber-core (~> 1.5.0)
+      cucumber-wire (~> 0.0.1)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 4.0)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.1.2)
+    cucumber-core (1.5.0)
+      gherkin (~> 4.0)
+    cucumber-wire (0.0.1)
+    diff-lcs (1.3)
+    ffi (1.9.18-java)
+    gherkin (4.0.0)
+    gli (2.5.2)
+    insensitive_hash (0.3.3)
+    jdbc-helper (0.8.2)
+      insensitive_hash (>= 0.2.4)
+      sql_helper (~> 0.1.1)
+    method_source (0.8.2)
+    multi_json (1.12.1)
+    multi_test (0.1.2)
+    pry (0.10.4-java)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+      spoon (~> 0.0)
+    rake (10.4.2)
+    rdoc (5.1.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    slop (3.6.0)
+    spoon (0.0.6)
+      ffi
+    sql_helper (0.1.1)
+    table_print (1.5.6)
+    thor (0.19.4)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  aruba (~> 0.14)
+  athena-cli!
+  pry
+  rake (~> 10)
+  rdoc (~> 5.1)
+
+BUNDLED WITH
+   1.14.6

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Wynn Netherland
+
+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,128 @@
+# athena-cli
+
+A CLI for Amazon Athena, powered by JRuby.
+
+[Amazon Athena](https://aws.amazon.com/athena/) allows you to define a schema and query structured data in S3 without the usual Extract-Transform-Load process. This project uses the [JDBC driver](http://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html) and JRuby to bring Athena access to your terminal.
+
+##### _athena-cli is a rapidly evolving work in progress. Some parts of this README are [aspirational](http://tom.preston-werner.com/2010/08/23/readme-driven-development.html)._
+
+#### Installation
+
+Make sure you have JRuby >= 9.1.6.0.
+
+    jruby -v
+
+Clone the repository:
+
+    git clone https://github.com/pengwynn/athena-cli
+
+Install the dependencies:
+
+    bundle install
+
+Build the gem:
+
+    rake gem
+
+Install it locally
+
+    gem install pkg/athena-cli-<version>.gem
+
+##### TODO: Install via Rubygems:
+
+##### Setting up AWS credentials
+
+The app will look for your AWS key and secret in the `AWS_ACCESS_KEY` and `AWS_SECRET_KEY` environment variables. If you use multiple AWS accounts, [awsam](https://github.com/mheffner/awsam) makes that a snap. Otherwise, you'll need to supply your AWS key and secret on every command via `--key` and `--secret` flags.
+
+##### Configuring the JDBC driver
+
+The underlying Java code needs to know where to find your [JDBC
+driver](http://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html#downloading-the-driver). Add the path to your `CLASSPATH` environment variable. Something like:
+
+
+Example:
+
+    export CLASSPATH="$CLASSPATH:~/src/AthenaJDB41-1.0.0.jar"
+
+##### Setting the scratch folder
+
+Athena requires an S3 scratch folder for storing results. You'll need to set the `ATHENA_S3_STAGING_DIR` environment variable or pass via the `--staging-dir` command line flag.
+
+##### Check your settings
+
+    athena-cli doctor
+
+If you're calling it outside the repository folder, you'll want to drop a
+[log4j.xml](https://github.com/pengwynn/athena-cli/blob/master/log4j.xml) file
+into that folder to silence the logger.
+
+### Hacking on athena-cli
+
+If you're running the project form source, be sure and use
+
+    bundle exec bin/athena-cli
+
+so that the dependencies are properly loaded.
+
+### Usage
+
+```
+❯ athena-cli
+NAME
+    athena-cli - CLI for Amazon Athena
+
+SYNOPSIS
+    athena-cli [global options] command [command options] [arguments...]
+
+VERSION
+    0.0.1
+
+GLOBAL OPTIONS
+    --help            - Show this message
+    --key=arg         - AWS Access Key (default: ********)
+    -p, --preview     - Output the SQL statement instead of running
+    --secret=arg      - AWS Secret Key (default: ********)
+    --staging-dir=arg - S3 bucket for staging results (default: none)
+    --version         -
+
+COMMANDS
+    column    - Manage columns in Athena tables
+    database  - Manage Athena databases
+    doctor    - Check for required AWS setup
+    help      - Shows a list of commands or help for one command
+    partition - Manage partitions in Athena tables
+    query     - Run a query from a file or STDIN
+    schema    - Manage Athena schemas
+    table     - Manage tables in Athena databases
+
+```
+
+### TODO
+
+- [ ] Explore more discoverable commands. `show-tables` instead of `table
+    list`
+- [ ] Tests for unhappy paths
+- [ ] Publish to Rubygems
+
+## LICENSE
+
+Copyright (c) 2017 Wynn Netherland
+
+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/Rakefile

@@ -0,0 +1,44 @@
+require 'rake/clean'
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rdoc/task'
+require 'cucumber'
+require 'cucumber/rake/task'
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'Your application title'
+end
+
+spec = eval(File.read('athena-cli.gemspec'))
+
+Gem::PackageTask.new(spec) do |pkg|
+end
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+desc 'Run features'
+Cucumber::Rake::Task.new(:features) do |t|
+  opts = "features --format html -o #{CUKE_RESULTS} --format progress -x"
+  opts += " --tags #{ENV['TAGS']}" if ENV['TAGS']
+  t.cucumber_opts =  opts
+  t.fork = false
+end
+
+desc 'Run features tagged as work-in-progress (@wip)'
+Cucumber::Rake::Task.new('features:wip') do |t|
+  tag_opts = ' --tags ~@pending'
+  tag_opts = ' --tags @wip'
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty -x -s#{tag_opts}"
+  t.fork = false
+end
+
+task :cucumber => :features
+task 'cucumber:wip' => 'features:wip'
+task :wip => 'features:wip'
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => [:test,:features]

data/athena-cli.gemspec

@@ -0,0 +1,26 @@
+# Ensure we require the local version and not one we might have installed already
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require File.join([File.dirname(__FILE__),'lib','amazon_athena','version.rb'])
+spec = Gem::Specification.new do |s| 
+  s.name = 'athena-cli'
+  s.version = AmazonAthena::VERSION
+  s.author = 'Wynn Netherland'
+  s.email = 'wynn.netherland@gmail.com'
+  s.homepage = 'https://wynnnetherland.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'A JRuby-powered CLI for Amazon Athena'
+  s.licenses = ["MIT"]
+  s.files = `git ls-files`.split("
+")
+  s.require_paths << 'lib'
+  s.bindir = 'bin'
+  s.executables << 'athena-cli'
+  s.add_development_dependency('rake', '~> 10')
+  s.add_development_dependency('rdoc', '~> 5.1')
+  s.add_development_dependency('aruba', '~> 0.14')
+  s.add_runtime_dependency('gli','2.5.2')
+  s.add_runtime_dependency('jdbc-helper', '~> 0.8.2')
+  s.add_runtime_dependency('table_print', '~> 1.5 ')
+end

data/bin/athena-cli

@@ -0,0 +1,10 @@
+#!/usr/bin/env jruby
+
+if %x(ruby -v) !~ /jruby/
+  puts "athena-cli requires jruby"
+  exit
+end
+
+require 'amazon_athena/cli'
+
+AmazonAthena::CLI.run(ARGV)

data/features/athena.feature

@@ -0,0 +1,8 @@
+Feature: My bootstrapped app kinda works
+  In order to get going on coding my awesome app
+  I want to have aruba and cucumber setup
+  So I don't have to do it myself
+
+  Scenario: App just runs
+    When I get help for "athena-cli"
+    Then the exit status should be 0

data/features/step_definitions/athena_steps.rb

@@ -0,0 +1,6 @@
+When /^I get help for "([^"]*)"$/ do |app_name|
+  @app_name = app_name
+  step %(I run `#{app_name} help`)
+end
+
+# Add more step definitions here

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require 'aruba/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+end

data/lib/amazon_athena.rb

@@ -0,0 +1,7 @@
+require 'amazon_athena/client'
+require 'amazon_athena/transformer'
+require 'amazon_athena/version.rb'
+
+module AmazonAthena
+
+end

data/lib/amazon_athena/cli.rb

@@ -0,0 +1,406 @@
+require 'gli'
+require 'amazon_athena'
+require 'fileutils'
+require 'table_print'
+
+module AmazonAthena
+  module CLI
+
+    def self.athena
+      AmazonAthena::Client.new \
+        key: self.access_key,
+        secret: self.access_secret,
+        s3_staging_dir: self.staging_folder
+    end
+
+    extend GLI::App
+
+    program_desc 'CLI for Amazon Athena'
+    version AmazonAthena::VERSION
+
+    switch [:p, :preview],
+      :default_value => false,
+      :desc => "Output the SQL statement instead of running",
+      :negatable => false
+
+    flag ["key"],
+      :default_value => ENV["AWS_ACCESS_KEY"],
+      :mask => true,
+      :desc => "AWS Access Key"
+
+    flag ["secret"],
+      :default_value => ENV["AWS_SECRET_KEY"],
+      :mask => true,
+      :desc => "AWS Secret Key"
+
+    flag ["staging-dir"],
+      :default_value => ENV["ATHENA_S3_STAGING_DIR"],
+      :desc => "S3 bucket for staging results"
+
+    desc 'Check for required AWS setup'
+    command :doctor do |c|
+      c.action do |global_options,options,args|
+        puts "Good to go!"
+      end
+    end
+
+    desc 'Manage Athena schemas'
+    command :schema do |c|
+      c.desc "Dump schemas to a local folder"
+      c.command :dump do |add|
+        add.flag :path,
+          :required => true,
+          :desc => "Local path for saving schemas"
+        add.action do |global_options,options,args|
+          path = options[:path]
+
+          unless File.exists?(path)
+            exit_now! "Path #{path} not found"
+          end
+
+          databases = athena.run(AmazonAthena::Commands::ShowDatabases.new)
+          preview = !!global_options[:p]
+
+          databases.each do |db|
+            folder = File.join(path, db)
+            prefix = File.exists?(folder) ? "Exists" : "Creating"
+            render "#{prefix} #{folder}"
+
+            unless preview
+              FileUtils.mkdir_p(folder)
+            end
+
+            tables = athena.run(AmazonAthena::Commands::ShowTables.new(db))
+
+            tables.each do |table|
+              database_table = [db, table].join(".")
+              file = File.join(folder, table) + ".sql"
+              render "Writing #{file}"
+
+              if !preview
+                sql = athena.run(AmazonAthena::Commands::ShowCreateTable.new(database_table))
+
+                File.open(file, 'w') { |f| f.write(sql) }
+              end
+            end
+          end
+
+          # puts global_options, options, args
+        end
+      end
+    end
+
+    desc 'Manage Athena databases'
+    command :database do |c|
+      c.desc "List databases"
+      c.command :list do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowDatabases.new
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Create a new database"
+      c.arg_name "database"
+      c.command :create do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::CreateDatabase.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Drop an existing database"
+      c.arg_name "database"
+      c.command :drop do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::DropDatabase.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.default_command :list
+    end
+
+    desc 'Manage tables in Athena databases'
+    command :table do |c|
+      c.desc "Create table"
+      c.arg_name "[file]"
+      c.command :create do |add|
+        add.flag [:l, :location], :desc => "S3 location - s3://bucket/path/"
+        add.flag [:n, :name], :desc => "Fully qualifed name as: database.table"
+        add.action do |global_options,options,args|
+          ddl = if filename = args.first
+                  exit_now! "File not found" unless File.exists?(filename)
+                  File.read(filename)
+                elsif !STDIN.tty?
+                  $stdin.read
+                end
+
+          exit_now! "Must supply path to file or pass via STDIN" if ddl.to_s.empty?
+
+
+          opts = {
+            :name => options[:name],
+            :location => options[:location]
+          }
+
+          ddl = AmazonAthena::Transformer.transform_table(ddl, opts)
+
+          cmd = AmazonAthena::Commands::CreateTable.new(ddl)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Describe a table"
+      c.arg_name "database.table"
+      c.command :describe do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::DescribeTable.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "List tables in a database"
+      c.arg_name "database"
+      c.command :list do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowTables.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Show table properties"
+      c.arg_name "database.table"
+      c.command :properties do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowTableProperties.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Show table create DDL"
+      c.arg_name "database.table"
+      c.command :show do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowCreateTable.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "Refresh table partitions"
+      c.arg_name "database.table"
+      c.command :repair do |add|
+        add.action do |global_options,options,args|
+          commands = [
+            AmazonAthena::Commands::RepairTable.new(args.first),
+            AmazonAthena::Commands::ShowPartitions.new(args.first),
+          ]
+
+          commands.each do |cmd|
+            render athena.run(cmd, global_options[:p])
+          end
+        end
+      end
+
+      c.desc "Drop table"
+      c.arg_name "database.table"
+      c.command :drop do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::DropTable.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+    end
+
+    desc 'Manage columns in Athena tables'
+    command :column do |c|
+      c.desc "List columns in a table"
+      c.arg_name "database.table"
+      c.command :list do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowColumns.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.default_command :list
+    end
+
+    desc 'Manage partitions in Athena tables'
+    command :partition do |c|
+      c.desc "List partitions in a table"
+      c.arg_name "database.table"
+      c.command :list do |add|
+        add.action do |global_options,options,args|
+          cmd = AmazonAthena::Commands::ShowPartitions.new(args.first)
+
+          render athena.run(cmd, global_options[:p])
+        end
+      end
+
+      c.desc "TODO: Add partition(s) to a table"
+      c.arg_name "database.table"
+      c.arg_name "key=value,key=value:key=value,key=value"
+      c.command :add do |add|
+        add.action do |global_options,options,args|
+          render "NOT IMPLEMENTED"
+        end
+      end
+
+      c.desc "TODO: Drop partition(s) from a table"
+      c.arg_name "database.table"
+      c.arg_name "key=value,key=value:key=value,key=value"
+      c.command :drop do |add|
+        add.action do |global_options,options,args|
+          render "NOT IMPLEMENTED"
+        end
+      end
+
+      c.default_command :list
+    end
+
+    desc 'Run a query from a file or STDIN'
+    arg_name '[file]'
+    command :query do |c|
+      c.action do |global_options,options,args|
+        input = args.first
+        sql = case input
+              when "", NilClass
+                $stdin.read if !STDIN.tty?
+              when String
+                if File.exists?(input)
+                  File.read(input)
+                else
+                  input
+                end
+              else
+                exit_now! "SQL string or file path required"
+              end
+
+        if global_options[:p]
+          render sql
+        else
+          begin
+            render athena.query(sql).map(&:to_h)
+          rescue Exception => e
+            render e.message
+          end
+        end
+      end
+    end
+
+    pre do |global,command,options,args|
+      @access_key     = global[:key]
+      @access_secret  = global[:secret]
+      @staging_folder = global[:"staging-dir"]
+
+
+      self.check_aws_settings
+      self.check_class_path
+
+      true
+    end
+
+    post do |global,command,options,args|
+      # Post logic here
+      # Use skips_post before a command to skip this
+      # block on that command only
+    end
+
+    on_error do |exception|
+      # Error logic here
+      # return false to skip default error handling
+      true
+    end
+
+    def self.access_key
+      @access_key
+    end
+
+    def self.access_secret
+      @access_secret
+    end
+
+    def self.staging_folder
+      @staging_folder
+    end
+
+    def self.class_path
+      ENV['CLASSPATH']
+    end
+
+    def self.check_aws_settings
+      if self.access_key.nil? || self.access_secret.nil?
+        msg = <<~MSG
+          athena-cli needs your AWS credentials. You can pass them via the
+          --key and --secret flags or set AWS_ACCESS_KEY and AWS_SECRET_KEY
+          environment variables.
+        MSG
+        exit_now! msg
+      end
+
+      if self.staging_folder.nil?
+        msg = <<~MSG
+          athena-cli requires an S3 location to use as a scratch folder. 
+          Please provide one via the --staging-dir flag or set the
+          ATHENA_S3_STAGING_DIR environment variable.
+        MSG
+        exit_now! msg, 1
+      end
+    end
+
+    def self.check_class_path
+      unless self.class_path =~ /AthenaJDBC/
+        jar_path =  File.expand_path(File.join([File.dirname(__FILE__),'..', 'jdbc','AthenaJDBC41-1.0.0.jar']))
+        msg = <<~MSG
+        JRuby requires JDBC driver to be in your Java class path.
+        For download instructions, see:
+
+            http://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html
+
+        After downloading, add /path/to/driver.jar to your CLASSPATH environment variable.
+
+        Example:
+
+            export CLASSPATH="$CLASSPATH:~/src/AthenaJDB41-1.0.0.jar"
+        MSG
+        exit_now! msg, 1
+      end
+    end
+
+    def self.details(data)
+      longest_key = data.keys.max_by(&:length)
+      data.each do |key, value|
+        printf "%##{longest_key.length}s %s\n", key, value
+      end
+    end
+
+    def self.render(output)
+      case output
+      when Hash
+        details(output)
+      when String
+        puts output
+      when Array
+        case output.first
+        when Hash
+          tp output
+        else
+          puts output
+        end
+      else
+        return
+      end
+    end
+  end
+end