athens 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '02197372c02d45a05efd88997b4cd8c01d66c869eafd6ca867f86da791ffe7b4'
+  data.tar.gz: 1753f4f6986c4fedf82f09d9a6d9ebe0b9fb630d59261011fc3c0667108e4ed0
+SHA512:
+  metadata.gz: facc871951901270b2b61410ae471cd6d62fcb33d2a914da76855e41fbccfb5039ee4e0d086deced77bcf39bf8c07fe865c635d6659093a2acac181291c78c2a
+  data.tar.gz: feca9c73d6145784b74dc4ce5442c2b764efda51719ff58e5fa6896d8dfd89186224d7aaa4f9ae282d58043bf5aa4f0e3576998d40ec0d9983c51d917d6d8022

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/.vagrant/
+/ubuntu-xenial-16.04-cloudimg-console.log

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 / 2019-03-01
+
+* Initial release!

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at TODO: Write your email address. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in athens.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    athens (0.1.0)
+      aws-sdk-athena (~> 1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aws-eventstream (1.0.1)
+    aws-partitions (1.136.0)
+    aws-sdk-athena (1.7.0)
+      aws-sdk-core (~> 3, >= 3.39.0)
+      aws-sigv4 (~> 1.0)
+    aws-sdk-core (3.46.0)
+      aws-eventstream (~> 1.0)
+      aws-partitions (~> 1.0)
+      aws-sigv4 (~> 1.0)
+      jmespath (~> 1.0)
+    aws-sigv4 (1.0.3)
+    jmespath (1.4.0)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  athens!
+  bundler (~> 1.17)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,14 @@
+        DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+                    Version 2, December 2004 
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net> 
+
+ Everyone is permitted to copy and distribute verbatim or modified 
+ copies of this license document, and changing it is allowed as long 
+ as the name is changed. 
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+  

data/README.md

@@ -0,0 +1,150 @@
+# Athens
+
+Athens is a wrapper around the standard AWS athena sdk, with a much simpler interface for executing queries and processing results.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'athens'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install athens
+
+## Usage
+
+### Quickstart
+
+There are two main classes for Athens, the `Connection` and the `Query`.  First "open" a connection to the database:
+
+```ruby
+conn = Athens::Connection.new(database: 'sample')
+```
+
+Then start a query:
+```ruby
+query = conn.execute("SELECT * FROM mytable")
+```
+
+That kicks off an Athena query in the background.  If you want you can just wait for it to finish:
+```ruby
+query.wait
+# or
+query.wait(5) # Wait 5 seconds at most
+```
+
+When your query is done, grab the results as an array:
+```ruby
+results = query.to_a
+# [
+#   ['column_1', 'column_2', 'column_3'], 
+#   [15, 'data', true], 
+#   [20, 'foo', false],
+#   ...
+# ]
+```
+
+Or as a hash (which is really an array where each row is a hash):
+```ruby
+results = query.to_h
+# [
+#   {'column_1': 15, 'column_2': 'data', 'column_3': true}, 
+#   {'column_1': 20, 'column_2': 'foo', 'column_3': false},
+#   ...
+# ]
+```
+
+Athens attempts to parse the sql data types into their ruby equivalents, although there's currently no support for the more complex Array/Map types.
+
+### Configuration
+
+Configure your AWS settings in an `Athens.configure` block (in rails put this in `config/initializers/athens.rb`):
+
+```ruby
+Athens.configure do |config|
+  config.output_location = "s3://my-bucket/my-folder/athena/results/"  # Required
+  config.aws_access_key = 'access'     # Optional
+  config.aws_secret_key = 'secret'     # Optional
+  config.aws_region     = 'us-east-1'  # Optional
+end
+```
+
+The aws parameters are all "optional", in that you can omit those in favor of any of the standard AWS configuration options (i.e. IAM Roles, environment variables, .aws/credentials files).
+
+You can also override the AWS client configuration on a per-connection basis:
+
+```ruby
+conn = Athens::Connection.new(aws_client_override: {})
+```
+
+Take a look at the [AWS Athena SDK](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Athena/Client.html#initialize-instance_method) for a list of all the available options.
+
+### Advanced Usage
+
+Providing a database name to the connection is optional, if you omit the name you'll have to specify it in your query:
+
+```ruby
+conn = Athens::Connection.new(database 'sample')
+query = conn.execute("SELECT * FROM mytable")
+
+# or
+
+conn = Athens::Connection.new
+query = conn.execute("SELECT * FROM sample.mytable")
+```
+
+While waiting for a query to finish, you could get one of two exceptions:
+
+```ruby
+conn = Athens::Connection.new(database 'sample')
+query = conn.execute("SELECT * FROM mytable")
+
+begin
+  query.wait()
+rescue Athens::QueryFailedError => qfe
+  # Query returned a failure message, qfe.message has details
+rescue Athens::QueryCancelledError => qce
+  # Query was canceled (usually by the user), qce.message has details
+end
+```
+
+When a query is running you can do a few things:
+
+```ruby
+conn = Athens::Connection.new(database: 'sample')
+query = conn.execute("SELECT * FROM mytable")
+
+query.state  # Returns one of QUEUED, RUNNING, SUCCEEDED, FAILED, or CANCELLED (https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Athena/Types/QueryExecutionStatus.html#state-instance_method)
+query.state_reason  # Further details from AWS about the state
+query.query_execution_id  # The id of the query returned from AWS
+query.cancel   # Attempts to cancel an in-progress query, returns true or false (if the query has already finished this will return false)
+
+query.to_a(header_row: false)  # If you want your query results returned without a header row of column names
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+If you want you can use Vagrant instead, there's already a `Vagrantfile` so a simple `vagrant up` should get you setup.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/getletterpress/athens. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [WTFPL License](http://www.wtfpl.net/).
+
+## Code of Conduct
+
+Everyone interacting in the Athens project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/getletterpress/athens/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/Vagrantfile

@@ -0,0 +1,38 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Provisioning script
+$script = <<SCRIPT
+  echo "*** Updating packages"
+
+  sudo DEBIAN_FRONTEND=noninteractive apt-get install -y aptitude
+  sudo DEBIAN_FRONTEND=noninteractive aptitude update
+  sudo DEBIAN_FRONTEND=noninteractive aptitude -y safe-upgrade
+
+  echo "*** Installing new packages"
+  sudo DEBIAN_FRONTEND=noninteractive aptitude install -y curl git-core vim
+
+  if rvm -v 2>/dev/null; then
+    echo "*** rvm already installed, skipping"
+  else
+    echo "*** Installing rvm"
+    gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
+    curl -sSL https://get.rvm.io | bash -s stable --ruby
+    echo "gem: --no-document" > ~/.gemrc
+
+    echo "*** Finished installing rvm"
+  fi
+
+  echo "*********************"
+  echo "PROVISIONING FINISHED"
+  echo "*********************"
+SCRIPT
+
+
+Vagrant.configure('2') do |config|
+  config.vm.box      = "ubuntu/xenial64"
+  config.vm.hostname = 'athens-dev'
+
+  # Provision the machine with the shell script above
+  config.vm.provision "shell", inline: $script, privileged: false
+end

data/athens.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "athens/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "athens"
+  spec.version       = Athens::VERSION
+  spec.authors       = ["Chris Schulte"]
+  spec.email         = ["chris@oceanbreezesoftware.com"]
+
+  spec.summary       = %q{Run simple SQL queries in AWS Athena}
+  spec.description   = %q{Allows you to easily access AWS Athena databases and run queries}
+  spec.homepage      = "https://github.com/getletterpress/athens"
+  spec.license       = "WTFPL"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/getletterpress/athens"
+    spec.metadata["changelog_uri"] = "https://github.com/getletterpress/athens/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.4'
+
+  spec.add_dependency "aws-sdk-athena", "~> 1"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "athens"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/athens.rb

@@ -0,0 +1,25 @@
+require "athens/error"
+require "athens/version"
+require "athens/configuration"
+require "athens/connection"
+require "athens/query"
+
+require 'aws-sdk-athena'
+
+module Athens
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/athens/configuration.rb

@@ -0,0 +1,15 @@
+module Athens
+  class Configuration
+    attr_accessor :aws_access_key, 
+                  :aws_secret_key,
+                  :aws_region,
+                  :output_location
+
+    def initialize
+      @aws_access_key = nil
+      @aws_secret_key = nil
+      @aws_region = nil
+      @output_location = nil
+    end
+  end
+end

data/lib/athens/connection.rb

@@ -0,0 +1,55 @@
+require 'bigdecimal'
+
+module Athens
+  class Connection
+    attr_reader :database_name
+    attr_reader :client
+
+    def initialize(database: nil, aws_client_override: {})
+      @database_name = database
+
+      client_config = { 
+        access_key_id: Athens.configuration.aws_access_key,
+        secret_access_key: Athens.configuration.aws_secret_key,
+        region: Athens.configuration.aws_region
+      }.merge(aws_client_override).compact
+
+      @client = Aws::Athena::Client.new(client_config)
+    end
+
+    # Runs a query against Athena, returning an Athens::Query object
+    # that you can use to wait for it to finish or get the results
+    def execute(query)
+      if @database_name
+        resp = @client.start_query_execution(
+          query_string: query,
+          query_execution_context: context,
+          result_configuration: result_config
+        )
+      else
+        resp = @client.start_query_execution(
+          query_string: query,
+          result_configuration: result_config
+        )
+      end        
+
+      return Athens::Query.new(self, resp.query_execution_id)
+    end
+
+    private
+
+      def context 
+        Aws::Athena::Types::QueryExecutionContext.new(database: @database_name)
+      end
+
+      def result_config
+        Aws::Athena::Types::ResultConfiguration.new(
+          output_location: Athens.configuration.output_location,
+          encryption_configuration: {
+            encryption_option: "SSE_S3"
+          }
+        )
+      end
+
+  end
+end

data/lib/athens/error.rb

@@ -0,0 +1,8 @@
+module Athens
+  class Error < StandardError; end
+
+  class QueryFailedError < Error; end
+  class QueryCancelledError < Error; end
+  class InvalidRequestError < Error; end
+
+end

data/lib/athens/query.rb

@@ -0,0 +1,186 @@
+module Athens
+  class Query
+    attr_reader :query_execution_id
+
+    def initialize(connection, query_execution_id)
+      @connection = connection
+      @query_execution_id = query_execution_id
+      @state = nil
+      @state_reason = nil
+      @cancelled = false
+
+      @results = nil
+      @hash_results = nil
+
+      version = RUBY_VERSION.split('.').map {|v| v.to_i}
+      @decimal_without_new = (version[0] >= 2 && version[1] >= 5)
+    end
+
+    def state
+      refresh_state if state_needs_refresh?
+      @state
+    end
+
+    def state_reason
+      refresh_state if state_needs_refresh?
+      @state_reason
+    end
+
+    def wait(max_seconds = nil)
+      if max_seconds.nil?
+        stop_at = nil
+      else
+        stop_at = Time.now + max_seconds
+      end
+
+      while true
+        if stop_at != nil && Time.now > stop_at
+          return false
+        end
+
+        refresh_state
+
+        if @state == 'SUCCEEDED'
+          return true
+        elsif @state == 'FAILED'
+          raise QueryFailedError.new(@state_reason)
+        elsif state == 'CANCELLED'
+          raise QueryCancelledError.new(@state_reason)
+        end
+
+        # Wait a bit and check again
+        sleep(0.25)
+      end
+    end
+
+    def cancel
+      unless @cancelled
+        resp = @connection.client.stop_query_execution({
+          query_execution_id: @query_execution_id
+        })
+        @cancelled = true
+        refresh_state
+      end
+
+      if @state == 'CANCELLED'
+        return true
+      else
+        return false
+      end
+    end
+
+    def to_a(header_row: true)
+      raise InvalidRequestError.new("Query must be in SUCCEEDED state to return results") unless @state == 'SUCCEEDED'
+
+      if @results.nil?
+        # Need to load and map all of the rows from the original result
+        @results = []
+        result = @connection.client.get_query_results({query_execution_id: @query_execution_id})
+
+        metadata = result.result_set.result_set_metadata
+        first = true
+
+        while true
+          rows = result.result_set.rows
+          break if rows.empty?
+
+          if first
+            @results << rows.shift.data.map {|col| col.var_char_value}
+            first = false
+          end
+
+          rows.each do |row|
+            @results << map_types(metadata, row)
+          end
+
+          if result.next_token
+            result = @connection.client.get_query_results({
+              query_execution_id: @query_execution_id,
+              next_token: result.next_token
+            })
+          else
+            # No more rows, break out and return our mapped data
+            break
+          end
+        end
+      end
+
+      if header_row
+        return @results
+      else
+        return @results[1, @results.size]
+      end
+    end
+
+    def to_h
+      if @hash_results.nil?
+        all_rows = self.to_a(header_row: true)
+
+        headers = all_rows.shift
+
+        @hash_results = []
+
+        unless headers.nil?
+          all_rows.each do |row|
+            map = {}
+            headers.each_with_index do |header, index|
+              map[header] = row[index]
+            end
+            @hash_results << map
+          end
+        end
+      end
+
+      return @hash_results
+    end
+
+    private
+      def state_needs_refresh?
+        @state.nil? || (['QUEUED', 'RUNNING'].include?(@state))
+      end
+
+      def refresh_state
+        resp = @connection.client.get_query_execution({query_execution_id: @query_execution_id})
+
+        @state = resp.query_execution.status.state
+        @state_reason = resp.query_execution.status.state_change_reason
+      end
+
+      def map_types(metadata, row)
+        mapped = []
+
+        metadata.column_info.each_with_index do |col, index|
+          data = row.data[index].var_char_value
+
+          case col.type
+          when 'tinyint', 'smallint', 'int', 'integer', 'bigint'
+            mapped << data.to_i
+          when 'timestamp'
+            mapped << Time.parse(data)
+          when 'varchar'
+            mapped << data
+          when 'float', 'double'
+            mapped << data.to_f
+          when 'decimal'
+            if @decimal_without_new
+              mapped << BigDecimal(data)
+            else
+              mapped << BigDecimal.new(data)
+            end
+          when 'date'
+            mapped << Date.parse(data)
+          when 'boolean'
+            mapped << (data == "true")
+          else
+            puts "WARNING: Unsupported type: #{col.type}, defaulting to string"
+            mapped << data
+          end
+        end
+
+        return mapped
+      end    
+
+
+  end
+end
+

data/lib/athens/version.rb

@@ -0,0 +1,3 @@
+module Athens
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: athens
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Schulte
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-athena
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Allows you to easily access AWS Athena databases and run queries
+email:
+- chris@oceanbreezesoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- Vagrantfile
+- athens.gemspec
+- bin/console
+- bin/setup
+- lib/athens.rb
+- lib/athens/configuration.rb
+- lib/athens/connection.rb
+- lib/athens/error.rb
+- lib/athens/query.rb
+- lib/athens/version.rb
+homepage: https://github.com/getletterpress/athens
+licenses:
+- WTFPL
+metadata:
+  homepage_uri: https://github.com/getletterpress/athens
+  source_code_uri: https://github.com/getletterpress/athens
+  changelog_uri: https://github.com/getletterpress/athens/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Run simple SQL queries in AWS Athena
+test_files: []