sc_analytics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 174fbe2000c4f79d76fc86330eac07a14d9f4807
+  data.tar.gz: 51f8eb358ef21862d6ae311e0c8bc45671e45045
+SHA512:
+  metadata.gz: 3ae18c5a68627339343f6d15c6076c161d30dfe87bf98a656a76cd1fc0c01d094a35ec011fbe17b2e242aa0114676a82bc745a9953277bfe960b9ec5b2fc3f19
+  data.tar.gz: 101e0b4cb37f6cda59b7131ee7ac536f1132677f5cb339796ea0f865a3dd8c8e2bdde37668260680e5a492377a0091fed783ef8dd4c4793c8956e3ef65f48f4e

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dave Rowan
+
+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,41 @@
+# ScAnalytics
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sc_analytics`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sc_analytics'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sc_analytics
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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/[USERNAME]/sc_analytics.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!C:/Ruby21-x64/bin/ruby.exe
+
+require "bundler/setup"
+require "sc_analytics"
+include SCAnalytics
+
+# 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

data/bin/run_report.rb

@@ -0,0 +1,22 @@
+require 'sc_analytics'
+include SCAnalytics
+
+report = ARGV[0]
+unless report
+	puts "Please enter the name of the report you wish to run"
+	report = STDIN.gets.strip
+	raise unless report
+end
+
+*report_path, report_name = report.split("/")
+report_name = report_name.sub(/(\.rb)*$/, ".rb")
+
+puts
+job_start = alert("BEGINNING JOB #{report_name.gsub(/\.rb$/,'')}")
+
+Dir.chdir(report_path.join("/")) unless report_path.empty?
+
+instructions = File.read(report_name)
+SCAnalytics.instance_eval(instructions, report_name)
+
+alert("COMPLETED JOB #{report_name} in #{(Time.now - job_start)/60} minutes")

data/bin/setup

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

data/example/db_configs_sample.yml

@@ -0,0 +1,23 @@
+# 
+#
+#
+# db_name:
+#   connection:
+#     type: 
+#     host:  
+#     port:  
+#     service:  
+#   credentials:
+#     username:  
+#     password:  
+####################################################################
+---
+db_name:
+  connection:
+    type: oracle
+    host: scanalytics.com
+    port: 63011
+    service: scanalytics.service.com
+  credentials:
+    username: user
+    password: pass

data/lib/sc_analytics/connections/connection.rb

@@ -0,0 +1,28 @@
+module SCAnalytics
+	module Connections
+
+		Struct.new("QueryResult",:headers,:rows)
+
+		class Connection
+			attr_reader :host, :port, :service, :username
+
+			def initialize(connection_name, options)
+				@connection_name = connection_name
+				@host = options[:connection][:host]
+				@port = options[:connection][:port]
+				@service = options[:connection][:service]
+				@username = options[:credentials][:username]
+				@password = options[:credentials][:password]
+			end
+
+			private
+
+			def connect
+				alert "Connecting to #{@connection_name.to_s} as user #{@username.to_s} . . . "
+				yield
+				alert "Successfully connected to #{@connection_name.to_s} as user #{@username.to_s}!"
+			end
+
+		end
+	end
+end

data/lib/sc_analytics/connections/connection_pool.rb

@@ -0,0 +1,28 @@
+module SCAnalytics
+	module Connections
+		module ConnectionPool
+			@active_connections = {}
+
+			def self.get_connection_to(server_name)
+				establish_connection_to server_name.downcase.to_sym unless @active_connections[server_name.downcase.to_sym]
+
+				@active_connections[server_name.downcase.to_sym]
+			end
+
+			def self.establish_connection_to(server_name)
+				config = Credentials.connection_details server_name
+				@active_connections[server_name] = case Credentials.connection_type(server_name)
+				when "oracle"
+					require 'sc_analytics/connections/oracle'
+					Oracle.new server_name, config
+				when "mysql"
+					Mysql.new server_name, config
+				else
+					raise
+				end
+
+				@active_connections[server_name]
+			end
+		end
+	end
+end

data/lib/sc_analytics/connections/credentials.rb

@@ -0,0 +1,31 @@
+module SCAnalytics
+	module Connections
+		module Credentials
+			include SCAnalytics
+			require 'yaml'
+
+			CONFIGS_FILE = "G:/Rowan/db_configs.yml"
+			@credentials = YAML.load(File.read(CONFIGS_FILE))
+
+			def self.symbolize_keys_for(hsh)
+				hsh = hsh.inject({}) {|new_hsh,(k,v)| new_hsh[k.downcase.to_sym] = v; new_hsh}
+		
+				hsh.keys.each do |k|
+					hsh[k] = symbolize_keys_for hsh[k] if hsh[k].is_a? Hash
+				end
+		
+				hsh
+			end
+
+			@credentials = symbolize_keys_for @credentials
+
+			def self.connection_type(db_name)
+				@credentials[db_name.downcase.to_sym][:connection][:type].downcase
+			end
+
+			def self.connection_details(db_name)
+				@credentials[db_name.downcase.to_sym]
+			end
+		end
+	end
+end

data/lib/sc_analytics/connections/oracle.rb

@@ -0,0 +1,58 @@
+module SCAnalytics
+	module Connections
+		class Oracle < Connection
+			require 'oci8'
+			OCI8::BindType::Mapping[:number_unknown_prec] = OCI8::BindType::BasicNumberType
+
+			def initialize(connection_name, options)
+				super
+
+				parse_db_url
+				connect
+			end
+
+			def define_col_types_for(query, cursor)
+				(query.columns_to_cast || {}).each_pair do |type, cols|
+					cols.each do |col|
+						cursor.define(col, type)
+					end
+				end
+			end
+
+			def get_cursor_for(query)
+				cursor = @client.parse(query.sql)
+			end
+
+			def run(query, cursor)
+				cursor.exec
+				define_col_types_for query, cursor
+
+				headers = cursor.get_col_names
+				results = []
+				
+				while row = cursor.fetch
+					results << row
+				end
+
+				Struct::QueryResult.new(headers, results)
+			end
+
+			def connect
+				super do
+					@client = OCI8.new @username, @password, @db_url
+				end
+			end
+
+			def parse_db_url
+				url = []
+				url << "//#{@host}" if @host
+				url << ":#{@port}" if @port
+				url << "/" if @host
+				url << @service
+
+				@db_url = url.join
+			end
+
+		end
+	end
+end

data/lib/sc_analytics/connections.rb

@@ -0,0 +1,14 @@
+module SCAnalytics
+	module Connections
+		require 'sc_analytics/connections/credentials'
+		require 'sc_analytics/connections/connection_pool'
+		require 'sc_analytics/connections/connection'
+
+		def self.use(server_name)
+			ConnectionPool.get_connection_to server_name
+		end
+
+		def self.test_connections
+		end
+	end
+end

data/lib/sc_analytics/exceptions.rb

@@ -0,0 +1,4 @@
+module SCAnalytics
+	class QueryError < StandardError
+	end
+end

data/lib/sc_analytics/query.rb

@@ -0,0 +1,281 @@
+module SCAnalytics
+
+  class Query
+    require 'erb'
+
+    attr_reader :connection, :results, :query_name, :bind_variables, :csv_file, :combined_csv_file, :csv_dir, :csv_combined_dir, :cursor, :columns_to_cast, :start_time, :end_time
+    attr_accessor :sql, :database, :auto_cast, :concurrent
+    alias_method :result, :results
+    alias_method :name, :query_name
+    alias_method :csv_files, :csv_file
+
+    REQUIRED_PARAMS = [:query_name, :database, :sql]
+    DEFAULT_DATA_DIR = :data_files
+    DEFAULT_SQL_DIR = :sql_queries
+
+    @@total_queries = 0
+
+    def initialize(&block)
+      yield self if block_given?
+      
+      check_params
+      fork_query if @should_fork
+    end
+
+    def bind_variables(var_hash = {})
+      @bind_variables||= {}
+      var_hash.each_pair do |bind_var, value|
+        @bind_variables[bind_var] = value
+      end
+    end
+    alias_method :bind_variable, :bind_variables
+
+    def check_params
+      missing_params = []
+
+      REQUIRED_PARAMS.each do |param|
+        missing_params << param unless instance_variable_get("@#{param}")
+      end
+
+      raise SCAnalytics::QueryError, "must set query parameter#{"s" if missing_params.length > 1 }: #{missing_params.join(", ")}" unless missing_params.empty?
+    end
+
+    def cast_columns(cols, type)
+      @columns_to_cast||= {}
+      @columns_to_cast[type]||= []
+
+      @columns_to_cast[type] << cols
+      @columns_to_cast[type].flatten!
+
+      return nil
+    end
+
+    def database=(*db)
+      @database = db.flatten
+      @should_fork = (@database.size > 1)
+    end
+
+    def default_file_name(combined_file = false)
+      file_names = []
+
+      if combined_file == :combined
+        file_names = "#{@database.join("_")}_#{self.name.gsub(" ","_")}_combined"
+      else
+        @database.each do |db|
+          file_names << "#{db}_#{self.name.gsub(" ","_")}"
+        end
+      end
+
+      file_names
+    end
+    alias_method :default_file_names, :default_file_name
+
+    def forked?
+      @should_fork
+    end
+
+    def export_csv
+      CSV.open(@csv_file.first,"w") do |csv|
+        csv << @results.headers
+      
+        @results.rows.each do |row|
+          csv << row
+        end
+      end
+    end
+
+    def export_csv_combined
+      CSV.open(@combined_csv_file,"w") do |csv|
+        csv << @results.values.first.headers
+      end
+
+      @results.each_value do |qry|
+        CSV.open(@combined_csv_file,"a") do |csv|
+          qry.rows.each do |row|
+            csv << row
+          end
+        end
+      end
+    end
+
+    def name=(query_name)
+      @query_name = query_name.to_s
+    end
+
+    def run
+      unless @should_fork
+        @connection = Connections.use @database.first
+        @cursor = @connection.get_cursor_for self
+        bind_vars_to_cursor if @bind_variables
+
+        @start_time = Time.now
+        alert("Running query #{self.name}")
+
+        @results = @connection.run(self, @cursor)
+
+        @end_time = Time.now
+        alert("Completed query #{self.name} in #{time_elapsed/60} minutes")
+
+        @@total_queries += 1
+
+        export_csv if @to_csv
+      else
+        @results = run_forked_queries
+        export_csv_combined if @to_csv_combined
+      end
+    end
+
+    def sql
+      @sql.result(binding)
+    end
+
+    def sql=(arg)
+      raise SCAnalytics::QueryError, "a SQL statement is already bound to query #{self.name}" if @sql
+
+      file_name = apply_format arg, :suggest => {:ext => :sql}
+      file_name_in_subfolder = apply_format file_name, :suggest => {:dir => DEFAULT_SQL_DIR}
+
+      sql = case 
+      when File.exists?(file_name)
+        File.read(file_name)
+      when File.exists?(file_name_in_subfolder)
+        File.read(file_name_in_subfolder)
+      else
+        # assume that the argument is a sql statement if no file is found
+        arg
+      end
+
+      # remove semi-colon from end of sql statement (if present) because ruby-oci8 does not accept these.
+      # also remove all trailing new lines and white space to make sure we find any trailing semi-colons.
+      while sql.chomp! || sql.chomp!(' ') || sql.chomp!(';'); end
+      @sql = ERB.new(sql)
+    ensure
+      @results = nil
+    end
+
+    def time_elapsed
+      if @start_time && @end_time
+        @end_time - @start_time
+      else
+        nil
+      end
+    end
+
+    def to_csv(*file_names)
+      @to_csv = true
+      @csv_dir = File.expand_path((file_names.last.is_a?(Hash) ? file_names.pop[:csv_dir] : DEFAULT_DATA_DIR).to_s)
+      file_names = default_file_names if file_names.empty?
+      
+      @csv_file = file_names.flatten.map{|file_name| apply_format file_name, :enforce => {:ext => :csv}, :suggest => {:dir => @csv_dir}}
+
+      raise SCAnalytics::QueryError, "must supply one csv file name for each database bound to query #{self.name}" unless @csv_file.length == @database.length
+    end
+
+    def to_csv_combined(*file_name)
+      raise ArgumentError, "too many arguments - #{file_name.length} for 2" if file_name.length > 2
+      raise ArgumentError, "optional second argument must be of type Hash" if file_name.length == 2 && ! file_name.last.is_a?(Hash)
+      @to_csv_combined = true
+      @csv_combined_dir = File.expand_path((file_name.last.is_a?(Hash) ? file_name.pop[:csv_dir] : DEFAULT_DATA_DIR).to_s)
+      file_name = file_name.empty? ? default_file_name(:combined) : file_name.first
+
+      @combined_csv_file = apply_format file_name, :enforce => {:ext => :csv}, :suggest => {:dir => @csv_combined_dir}
+    end
+
+    def self.total_queries
+      @@total_queries
+    end
+
+    private
+
+    def bind_vars_to_cursor
+      @bind_variables.each_pair do |bind_var, value|
+        @cursor.bind_param(":#{bind_var.to_s}", value)
+      end
+    end
+
+    def apply_format(file_name, options = {})
+      unknown_options = []
+      options.keys.each do |option|
+        unknown_options << option unless [:enforce, :suggest].include?(option.to_sym)
+      end
+      raise "unknown format option#{"s" if unknown_options.length > 1}: #{unknown_options.join(", ")}" unless unknown_options.empty?
+
+      options.each_pair do |option, settings|
+        settings.each_pair do |setting, format|
+          file_name = send("#{option.to_s}_#{setting.to_s}".to_sym, file_name, format)
+        end
+      end
+
+      file_name
+    end
+
+    def enforce_ext(file_name, ext)
+      return file_name if file_name.match(/\.#{ext}$/)
+
+      # remove any file extension provided and make sure
+      # that the file_name ends with required extension
+      file_name = file_name.sub(/\.\w+$(?!\.)/i, "")
+      file_name + ".#{ext}"
+    end
+
+    def enforce_dir(file_name, dir)
+      return file_name if File.dirname(file_name) == dir.to_s
+      
+      FileUtils.mkdir_p(dir.to_s)
+      file_name = file_name.sub(File.dirname(file_name), "") unless File.dirname(file_name) == "."
+      "#{dir}/" + file_name
+    end
+
+    def suggest_ext(file_name, ext)
+      return file_name if file_name.match(/\.\w+$(?!\.)/i)
+
+      file_name + ".#{ext}"
+    end
+
+    def suggest_dir(file_name, dir)
+      return file_name unless File.dirname(file_name) == "."
+
+      FileUtils.mkdir_p(dir.to_s)
+      "#{dir}/" + file_name
+    end
+
+    def fork_query
+      @tines = {}
+
+      @database.each_with_index do |db, i|
+        forked_query = self.dup
+        forked_query.database = db
+        forked_query.to_csv(@csv_file[i], :csv_dir => @csv_dir) if @to_csv
+        forked_query.name = "#{db.to_s}_#{self.name}"
+        @tines[db] = forked_query
+      end
+    end
+
+    def run_forked_queries
+      @start_time = Time.now
+
+      results = {}
+      threads = []
+      @tines.each_value do |query|
+        threads << Thread.new do
+          Thread.stop
+          query.run
+          results[query.database.first] = query.results
+        end
+      end
+
+      threads.each{|thread| until thread.stop?; end}
+
+      threads.each do |thread|
+        thread.run
+        thread.join if @concurrent == false
+      end
+
+      threads.each{|thread| thread.join }
+
+      @end_time = Time.now
+      return results
+    end
+
+  end
+end

data/lib/sc_analytics/version.rb

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

data/lib/sc_analytics.rb

@@ -0,0 +1,76 @@
+require 'sc_analytics/version'
+require 'sc_analytics/query'
+require 'sc_analytics/connections'
+require 'sc_analytics/exceptions'
+
+require 'date'
+require 'fileutils'
+require 'csv'
+require 'win32ole'
+require 'thread'
+
+begin
+  # for development environment
+  require 'pry'
+rescue LoadError
+end
+
+module SCAnalytics
+	def run_query(*queries)
+		queries.each{|qry| qry.run }
+  end
+  alias :run_queries :run_query
+  alias :run_in_sequence :run_query
+
+  def run_in_parallel(*queries)
+    queries.each { |query| raise "cannot run forked query #{qry.name} in parallel with other queries" if query.forked? && queries.length > 1 }
+
+    threads = []
+    queries.each do |query|
+      threads << Thread.new do
+        query.run
+      end
+    end
+
+    threads.each{|thread| thread.join }
+  end
+
+  def alert(status)
+  	curr_time = Time.now
+    puts "#{curr_time.strftime("%m/%d/%Y %H:%M:%S")} #{status}"
+    puts
+    return curr_time
+  end
+
+  def open_excel_file(file_name)
+    excel_instance.Workbooks.open("#{Dir.pwd}/#{file_name}")
+    nil
+  end
+
+  def run_excel_macro(macro_name, arg = nil)
+    if arg
+      excel_instance.run(macro_name, arg)
+    else
+      excel_instance.run(macro_name)
+    end
+
+    nil
+  end
+
+  def quit_excel
+    excel_instance.quit
+    nil
+  end
+
+  private
+
+  def excel_instance
+    unless @excel
+      @excel = WIN32OLE.new('Excel.Application')
+      @excel.visible = true
+      #at_exit {@excel.quit}
+    end
+
+    @excel
+  end
+end

data/spec/sc_analytics/query/query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module SCAnalytics
+	describe Query do
+		statement = "SELECT * FROM TABLE"
+		let(:query1) {Query.new do server :wm09; sql statement; end}
+	
+		it "returns the sql statement" do
+			expect(query1.sql).to eq(statement)
+		end
+	end
+end

data/spec/sc_analytics_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe SCAnalytics do
+  it 'has a version number' do
+    expect(SCAnalytics::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'sc_analytics'

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: sc_analytics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dave Rowan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-oci8
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- DRowan99@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/run_report.rb
+- bin/setup
+- example/db_configs_sample.yml
+- lib/sc_analytics.rb
+- lib/sc_analytics/connections.rb
+- lib/sc_analytics/connections/connection.rb
+- lib/sc_analytics/connections/connection_pool.rb
+- lib/sc_analytics/connections/credentials.rb
+- lib/sc_analytics/connections/oracle.rb
+- lib/sc_analytics/exceptions.rb
+- lib/sc_analytics/query.rb
+- lib/sc_analytics/version.rb
+- spec/sc_analytics/query/query_spec.rb
+- spec/sc_analytics_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.3
+signing_key: 
+specification_version: 4
+summary: A gem for easily automating database jobs.
+test_files:
+- spec/sc_analytics/query/query_spec.rb
+- spec/sc_analytics_spec.rb
+- spec/spec_helper.rb