activerecord_athena 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a035d8c2fbb40cec7a7e2b7332e1de34b7dff1adbdd737477425f4ef6d535d2f
+  data.tar.gz: ddeb554be40247d1d9602c2ca40b204fe2b0d0e623177f910b0fd994b416623e
+SHA512:
+  metadata.gz: a02fd84206cebf99e0d54d26b70db80366da546e81a9c2571a550412f327a905542dc4e829b0d27af4d18fdb9a318e249e991b5a1a78b1fc6577da494026dc72
+  data.tar.gz: 66716bb6504915749ca13ee869ff9fa1e49a5cccd1b3f0ab6a5afe0ddeab97afa3562a1928411d6508de3abaf0ed1ce53a70a61b85044ab10230ecb2b79fdcb0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jeremy Hinkle
+
+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,104 @@
+# ActiveRecord Athena Adapter
+
+An ActiveRecord adapter for AWS Athena that enables Rails applications to connect to and query AWS Athena.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord_athena'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install activerecord_athena
+
+## Usage
+
+### Configuration
+
+Add the following to your `database.yml`:
+
+```yaml
+development:
+  adapter: athena
+  database: your_athena_database
+  s3_output_location: s3://your-bucket/query-results/
+  work_group: primary
+  connection_options:
+    aws_config:
+      region: us-east-1
+      access_key_id: <%= ENV['AWS_ACCESS_KEY_ID'] %>
+      secret_access_key: <%= ENV['AWS_SECRET_ACCESS_KEY'] %>
+```
+
+### Basic Usage
+
+```ruby
+# Define a model
+class LogEntry < ActiveRecord::Base
+  self.table_name = "log_entries"
+end
+
+# Query data
+LogEntry.where("timestamp > ?", 1.day.ago).limit(100)
+
+# Raw SQL queries
+ActiveRecord::Base.connection.execute("SELECT * FROM log_entries LIMIT 10")
+```
+
+### Limitations
+
+Due to the nature of AWS Athena, this adapter has several limitations:
+
+- **No migrations**: Athena doesn't support traditional CREATE TABLE statements. Tables are typically created as external tables pointing to S3 data.
+- **No primary keys**: Athena doesn't support primary key constraints.
+- **No foreign keys**: Athena doesn't support foreign key constraints.
+- **No indexes**: Athena doesn't support traditional indexes.
+- **Limited write operations**: Traditional UPDATE/DELETE operations require Iceberg or Delta Lake table formats.
+
+### Supported Operations
+
+- `SELECT` queries with `WHERE`, `ORDER BY`, `LIMIT`, etc.
+- `SHOW TABLES` - list all tables in the database
+- `DESCRIBE table` - get table schema information
+- `DROP TABLE` - remove external tables
+- `INSERT` statements - add new data to tables
+- `UPDATE` statements - limited support (requires Iceberg/Delta Lake tables)
+- `DELETE` statements - limited support (requires Iceberg/Delta Lake tables)
+
+### AWS Configuration
+
+The adapter requires proper AWS credentials and permissions. You can configure these through:
+
+1. Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`)
+2. IAM roles (recommended for EC2/ECS deployments)
+3. AWS credentials file
+4. Direct configuration in `database.yml`
+
+Required permissions:
+- `athena:StartQueryExecution`
+- `athena:GetQueryExecution`
+- `athena:GetQueryResults`
+- `s3:GetObject`
+- `s3:ListBucket`
+- `s3:PutObject` (for query results)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/activerecord_athena.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/active_record/connection_adapters/athena/database_tasks.rb

@@ -0,0 +1,47 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Athena
+      class DatabaseTasks
+        def self.create(config)
+          # Athena databases are typically created through AWS console or CLI
+          # This is a placeholder for future implementation
+          puts "Athena databases should be created through AWS console or CLI"
+        end
+
+        def self.drop(config)
+          # Athena databases are typically dropped through AWS console or CLI
+          # This is a placeholder for future implementation
+          puts "Athena databases should be dropped through AWS console or CLI"
+        end
+
+        def self.purge(config)
+          # Athena doesn't support traditional purge operations
+          puts "Athena doesn't support purge operations"
+        end
+
+        def self.charset(config)
+          "UTF-8"
+        end
+
+        def self.collation(config)
+          nil
+        end
+
+        def self.structure_dump(config, filename)
+          # Athena structure dump would involve listing tables and their schemas
+          # This is a placeholder for future implementation
+          File.write(filename, "-- Athena structure dump placeholder\n")
+        end
+
+        def self.structure_load(config, filename)
+          # Loading structure in Athena would involve creating tables
+          # This is a placeholder for future implementation
+          puts "Structure loading for Athena needs to be implemented"
+        end
+      end
+    end
+  end
+end
+
+# Register the database tasks
+ActiveRecord::Tasks::DatabaseTasks.register_task(/athena/, "ActiveRecord::ConnectionAdapters::Athena::DatabaseTasks")

data/lib/active_record/connection_adapters/athena/schema_dumper.rb

@@ -0,0 +1,78 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Athena
+      class SchemaDumper < ConnectionAdapters::SchemaDumper
+        private
+
+        def header(stream)
+          stream.puts <<~HEADER
+            # This file is auto-generated from the current state of the database. Instead
+            # of editing this file, please use the migrations feature of Active Record to
+            # incrementally modify your database, and then regenerate this schema definition.
+            #
+            # Note that this schema.rb definition is the authoritative source for your
+            # database schema. If you need to create the application database on another
+            # system, you should be using db:schema:load, not running all the migrations
+            # from scratch. The latter is a flawed and unsustainable approach (the more
+            # migrations you'll amass, the slower it'll run and the greater likelihood for
+            # issues).
+            #
+            # It's strongly recommended that you check this file into your version control system.
+
+            ActiveRecord::Schema.define(version: #{ActiveRecord::Migrator.current_version}) do
+          HEADER
+        end
+
+        def trailer(stream)
+          stream.puts "end"
+        end
+
+        def table(table, stream)
+          columns = @connection.columns(table)
+          begin
+            tbl = StringIO.new
+
+            # Athena tables are typically external tables
+            tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+            tbl.print ", force: :cascade"
+            tbl.print ", options: \"EXTERNAL\""
+            tbl.puts " do |t|"
+
+            # Athena doesn't have traditional primary keys, so we skip that logic
+            columns.each do |column|
+              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+              next if column.name == "id"
+              
+              type, colspec = column_spec(column)
+              tbl.print "    t.#{type} #{column.name.inspect}"
+              tbl.print ", #{format_colspec(colspec)}" if colspec.present?
+              tbl.puts
+            end
+
+            tbl.puts "  end"
+            tbl.puts
+
+            indexes(table, tbl)
+
+            tbl.rewind
+            stream.print tbl.read
+          rescue => e
+            stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
+        end
+
+        def indexes(table, stream)
+          # Athena doesn't support traditional indexes
+          # This method is left empty intentionally
+        end
+
+        def foreign_keys(table, stream)
+          # Athena doesn't support foreign keys
+          # This method is left empty intentionally
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/athena/schema_statements.rb

@@ -0,0 +1,188 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Athena
+      module SchemaStatements
+        def tables
+          query = "SHOW TABLES"
+          result = execute(query)
+          result[:rows].map { |row| row[:data].first[:var_char_value] }
+        end
+
+        def data_sources
+          tables
+        end
+
+        def data_source_sql(name = nil, type: nil)
+          if name
+            "SHOW TABLES LIKE '#{name}'"
+          else
+            "SHOW TABLES"
+          end
+        end
+
+        def data_source_exists?(name)
+          tables.include?(name.to_s)
+        end
+
+        def table_exists?(table_name)
+          tables.include?(table_name.to_s)
+        end
+
+        def columns(table_name)
+          # Athena doesn't support quoted table names in DESCRIBE
+          query = "DESCRIBE #{table_name}"
+          result = execute(query)
+          
+          columns = []
+          
+          result[:rows].each do |row|
+            data = row[:data]
+            
+            # Skip empty rows or rows with insufficient data
+            next if data.nil? || data.length < 2
+            
+            # Get the first column value (potential column name)
+            first_col = data[0][:var_char_value]
+            
+            # Skip header rows and comments (lines starting with #)
+            next if first_col.nil? || first_col.start_with?('#') || first_col.strip.empty?
+            
+            # Skip the header row that contains "col_name"
+            next if first_col == "col_name"
+            
+            # Skip partition spec section
+            next if first_col == "field_name"
+            
+            column_name = first_col.strip
+            column_type = data[1][:var_char_value].strip
+            
+            sql_type = column_type
+            type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
+              sql_type: sql_type,
+              type: lookup_cast_type_symbol(sql_type)
+            )
+            
+            columns << ConnectionAdapters::Column.new(
+              column_name,
+              nil, # default value
+              type_metadata,
+              true # nullable - Athena columns are typically nullable
+            )
+          end
+          
+          columns
+        end
+
+        def column_exists?(table_name, column_name, type = nil, **options)
+          columns(table_name).any? { |col| col.name == column_name.to_s }
+        end
+
+        def create_table(table_name, **options)
+          # Athena table creation is complex and typically involves external data sources
+          # This is a placeholder implementation
+          raise NotImplementedError, "CREATE TABLE is not supported for Athena. Use external table creation through AWS console or CLI."
+        end
+
+        def drop_table(table_name, **options)
+          # Athena may not support quoted table names in DROP TABLE
+          execute("DROP TABLE #{table_name}")
+        end
+
+        def rename_table(table_name, new_name)
+          raise NotImplementedError, "RENAME TABLE is not supported for Athena"
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          raise NotImplementedError, "ADD COLUMN is not supported for Athena"
+        end
+
+        def remove_column(table_name, column_name, type = nil, **options)
+          raise NotImplementedError, "REMOVE COLUMN is not supported for Athena"
+        end
+
+        def change_column(table_name, column_name, type, **options)
+          raise NotImplementedError, "CHANGE COLUMN is not supported for Athena"
+        end
+
+        def rename_column(table_name, column_name, new_column_name)
+          raise NotImplementedError, "RENAME COLUMN is not supported for Athena"
+        end
+
+        def add_index(table_name, column_name, **options)
+          raise NotImplementedError, "ADD INDEX is not supported for Athena"
+        end
+
+        def remove_index(table_name, column_name = nil, **options)
+          raise NotImplementedError, "REMOVE INDEX is not supported for Athena"
+        end
+
+        def indexes(table_name)
+          # Athena doesn't support traditional indexes
+          []
+        end
+
+        def primary_key(table_name)
+          # Athena doesn't support primary keys
+          nil
+        end
+
+        def foreign_keys(table_name)
+          # Athena doesn't support foreign keys
+          []
+        end
+
+        private
+
+        def lookup_cast_type_symbol(sql_type)
+          case sql_type.downcase
+          when /^string/i, /^varchar/i, /^char/i
+            :string
+          when /^bigint/i, /^int/i, /^tinyint/i, /^smallint/i
+            :integer
+          when /^double/i, /^float/i
+            :float
+          when /^decimal/i
+            :decimal
+          when /^boolean/i
+            :boolean
+          when /^timestamp/i, /^datetime/i
+            :datetime
+          when /^date/i
+            :date
+          when /^time/i
+            :time
+          when /^binary/i
+            :binary
+          else
+            :string
+          end
+        end
+
+        def lookup_cast_type(sql_type)
+          case sql_type.downcase
+          when /^string/i, /^varchar/i, /^char/i
+            ActiveRecord::Type::String.new
+          when /^bigint/i, /^int/i, /^tinyint/i, /^smallint/i
+            ActiveRecord::Type::Integer.new
+          when /^double/i, /^float/i
+            ActiveRecord::Type::Float.new
+          when /^decimal/i
+            ActiveRecord::Type::Decimal.new
+          when /^boolean/i
+            ActiveRecord::Type::Boolean.new
+          when /^timestamp/i, /^datetime/i
+            ActiveRecord::Type::DateTime.new
+          when /^date/i
+            ActiveRecord::Type::Date.new
+          when /^time/i
+            ActiveRecord::Type::Time.new
+          when /^binary/i
+            ActiveRecord::Type::Binary.new
+          else
+            ActiveRecord::Type::String.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/athena_adapter.rb

@@ -0,0 +1,352 @@
+require "active_record/connection_adapters/abstract_adapter"
+require "aws-sdk-athena"
+require "aws-sdk-s3"
+require "active_record/connection_adapters/athena/schema_statements"
+require "active_record/connection_adapters/athena/database_tasks"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AthenaAdapter < AbstractAdapter
+      include Athena::SchemaStatements
+      ADAPTER_NAME = "Athena"
+
+      def initialize(config)
+        super(config)
+        @connection_options = config[:connection_options] || {}
+        @database = config[:database]
+        @s3_output_location = config[:s3_output_location]
+        @work_group = config[:work_group] || "primary"
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def active?
+        true
+      end
+
+      def reconnect!
+        @athena_client = nil
+        @s3_client = nil
+      end
+
+      def disconnect!
+        # Athena doesn't maintain persistent connections
+      end
+
+      def supports_migrations?
+        false
+      end
+
+      def supports_primary_key?
+        false
+      end
+
+      def supports_bulk_alter?
+        false
+      end
+
+      def supports_foreign_keys?
+        false
+      end
+
+      def supports_views?
+        true
+      end
+
+      def supports_datetime_with_precision?
+        true
+      end
+
+      def supports_json?
+        true
+      end
+
+      def supports_statement_cache?
+        true
+      end
+
+      def supports_lazy_transactions?
+        false
+      end
+
+      def supports_transactions?
+        false
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def native_database_types
+        {
+          primary_key: "string",
+          string: { name: "string" },
+          text: { name: "string" },
+          integer: { name: "bigint" },
+          bigint: { name: "bigint" },
+          float: { name: "double" },
+          decimal: { name: "decimal" },
+          datetime: { name: "timestamp" },
+          time: { name: "time" },
+          date: { name: "date" },
+          binary: { name: "binary" },
+          boolean: { name: "boolean" },
+          json: { name: "string" }
+        }
+      end
+
+      def quote_column_name(name)
+        "\"#{name}\""
+      end
+
+      def quote_table_name(name)
+        "\"#{name}\""
+      end
+
+      def quoted_true
+        "true"
+      end
+
+      def quoted_false
+        "false"
+      end
+
+      def execute(sql, name = nil)
+        log(sql, name) do
+          execute_query(sql)
+        end
+      end
+
+      def exec_query(sql, name = "SQL", binds = [], **kwargs)
+        log(sql, name) do
+          # Replace parameter placeholders with actual values
+          prepared_sql = substitute_binds(sql, binds)
+          query_result = execute_query(prepared_sql)
+
+          if query_result[:rows].any?
+            columns = query_result[:column_info].map { |col| col[:name] }
+            raw_rows = query_result[:rows].map { |row| row[:data].map { |cell| cell[:var_char_value] } }
+
+            # Filter out header row if it matches column names
+            # The first row is often the header row in Athena results
+            data_rows = raw_rows
+            if raw_rows.first && raw_rows.first == columns
+              data_rows = raw_rows.drop(1)
+            end
+
+            ActiveRecord::Result.new(columns, data_rows)
+          else
+            ActiveRecord::Result.new([], [])
+          end
+        end
+      end
+
+      def select_all(arel, name = nil, binds = [], **kwargs)
+        sql = to_sql(arel, binds)
+        exec_query(sql, name, binds)
+      end
+
+      def exec_update(sql, name = nil, binds = [])
+        # Athena doesn't support traditional UPDATE statements
+        # This is a limited implementation that will work for some use cases
+        log(sql, name) do
+          if sql.match?(/^UPDATE/i)
+            # Log a warning about UPDATE limitations
+            ActiveRecord::Base.logger&.warn("UPDATE operations in Athena are limited. Consider using INSERT OVERWRITE or MERGE operations instead.")
+
+            # For now, we'll attempt to execute the UPDATE as-is
+            # This will likely fail unless using Iceberg/Delta Lake tables
+            prepared_sql = substitute_binds(sql, binds)
+            result = execute_query(prepared_sql)
+
+            # Return number of affected rows (Athena doesn't provide this, so we return 0)
+            0
+          else
+            # Handle other modification queries
+            prepared_sql = substitute_binds(sql, binds)
+            execute_query(prepared_sql)
+            0
+          end
+        end
+      end
+
+      def exec_delete(sql, name = nil, binds = [])
+        # Athena doesn't support traditional DELETE statements
+        log(sql, name) do
+          if sql.match?(/^DELETE/i)
+            # Log a warning about DELETE limitations
+            ActiveRecord::Base.logger&.warn("DELETE operations in Athena are limited. Consider using INSERT OVERWRITE with filtered data instead.")
+
+            # For now, we'll attempt to execute the DELETE as-is
+            # This will likely fail unless using Iceberg/Delta Lake tables
+            prepared_sql = substitute_binds(sql, binds)
+            result = execute_query(prepared_sql)
+
+            # Return number of affected rows (Athena doesn't provide this, so we return 0)
+            0
+          else
+            # Handle other modification queries
+            prepared_sql = substitute_binds(sql, binds)
+            execute_query(prepared_sql)
+            0
+          end
+        end
+      end
+
+      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+        # Athena supports INSERT statements
+        log(sql, name) do
+          prepared_sql = substitute_binds(sql, binds)
+          execute_query(prepared_sql)
+
+          # Athena doesn't support returning generated IDs
+          # Return nil for the primary key value
+          nil
+        end
+      end
+
+      # Transaction methods (no-op for Athena)
+      def begin_db_transaction
+        # Athena doesn't support transactions
+        # This is a no-op to satisfy the interface
+      end
+
+      def commit_db_transaction
+        # Athena doesn't support transactions
+        # This is a no-op to satisfy the interface
+      end
+
+      def rollback_db_transaction
+        # Athena doesn't support transactions
+        # This is a no-op to satisfy the interface
+      end
+
+      private
+
+      def athena_client
+        @athena_client ||= Aws::Athena::Client.new(aws_config)
+      end
+
+      def s3_client
+        @s3_client ||= Aws::S3::Client.new(aws_config)
+      end
+
+      def aws_config
+        @connection_options[:aws_config] || {}
+      end
+
+      def substitute_binds(sql, binds)
+        # Handle special case where we have ? placeholders but no binds
+        # This often happens with LIMIT clauses in newer ActiveRecord versions
+        if binds.empty? && sql.include?('?')
+          # For LIMIT clauses, we'll use a reasonable default
+          # In production, this might need more sophisticated handling
+          sql = sql.gsub(/LIMIT \?/, 'LIMIT 1000')
+          return sql
+        end
+
+        return sql if binds.empty?
+
+        # Replace ? placeholders with actual values
+        bind_index = 0
+        sql.gsub('?') do
+          if bind_index < binds.length
+            bind = binds[bind_index]
+            bind_index += 1
+
+            # Handle different types of bind values
+            value = bind.respond_to?(:value) ? bind.value : bind
+            quote(value)
+          else
+            '?'
+          end
+        end
+      end
+
+      def quote(value)
+        case value
+        when String
+          "'#{value.gsub("'", "''")}'"
+        when Integer, Float
+          value.to_s
+        when true
+          'true'
+        when false
+          'false'
+        when nil
+          'NULL'
+        when Date
+          "'#{value.strftime('%Y-%m-%d')}'"
+        when Time, DateTime
+          "'#{value.strftime('%Y-%m-%d %H:%M:%S')}'"
+        else
+          "'#{value.to_s.gsub("'", "''")}'"
+        end
+      end
+
+      def execute_query(sql)
+        query_execution_id = start_query_execution(sql)
+        wait_for_query_completion(query_execution_id)
+        get_query_results(query_execution_id)
+      end
+
+      def start_query_execution(sql)
+        response = athena_client.start_query_execution({
+          query_string: sql,
+          query_execution_context: {
+            database: @database
+          },
+          result_configuration: {
+            output_location: @s3_output_location
+          },
+          work_group: @work_group
+        })
+
+        response.query_execution_id
+      end
+
+      def wait_for_query_completion(query_execution_id)
+        loop do
+          response = athena_client.get_query_execution({
+            query_execution_id: query_execution_id
+          })
+
+          status = response.query_execution.status.state
+
+          case status
+          when "SUCCEEDED"
+            break
+          when "FAILED", "CANCELLED"
+            raise ActiveRecord::StatementInvalid, "Query failed: #{response.query_execution.status.state_change_reason}"
+          else
+            sleep(0.5)
+          end
+        end
+      end
+
+      def get_query_results(query_execution_id)
+        response = athena_client.get_query_results({
+          query_execution_id: query_execution_id
+        })
+
+        {
+          column_info: response.result_set.result_set_metadata.column_info,
+          rows: response.result_set.rows
+        }
+      end
+
+      def to_sql(arel, binds)
+        if arel.respond_to?(:to_sql)
+          arel.to_sql
+        else
+          arel
+        end
+      end
+    end
+  end
+end
+
+# Register the adapter
+ActiveRecord::ConnectionAdapters.register("athena", "ActiveRecord::ConnectionAdapters::AthenaAdapter", "active_record/connection_adapters/athena_adapter")

data/lib/activerecord_athena/version.rb

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

data/lib/activerecord_athena.rb

@@ -0,0 +1,7 @@
+require "activerecord_athena/version"
+require "active_record"
+require "active_record/connection_adapters/athena_adapter"
+
+module ActiverecordAthena
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_athena
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jeremy Hinkle
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-athena
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: An ActiveRecord adapter that enables Rails applications to connect to
+  and query AWS Athena
+email:
+- jchinkle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/active_record/connection_adapters/athena/database_tasks.rb
+- lib/active_record/connection_adapters/athena/schema_dumper.rb
+- lib/active_record/connection_adapters/athena/schema_statements.rb
+- lib/active_record/connection_adapters/athena_adapter.rb
+- lib/activerecord_athena.rb
+- lib/activerecord_athena/version.rb
+homepage: https://github.com/jchinkle/activerecord_athena
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: ActiveRecord adapter for AWS Athena
+test_files: []