sql_runner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0fe73046f6047d45f926dcc2a2dfe481698d6c27
+  data.tar.gz: fdabc17b0da986f3e0f1676dbc35d1b74ca0510c
+SHA512:
+  metadata.gz: 539aa4ac64c12629feb865ffde679507bc00a0951353261c42fbd4fcf547228593d2bc0675cf792c94f065ff908c9b8eb1f8239f673f883ff07d2c4789fa73aa
+  data.tar.gz: 014fa997673cd75e241ca74e667d7f3fb31b7b40acb1a044c0f983272cd7543e8b61e31bbdebb092b362ae0771c73109776d491608981a47019bec73c28059ce

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/examples/**/*.html

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+cache: bundler
+sudo: false
+rvm:
+- 2.3.1
+before_install:
+- gem install bundler
+- createdb test
+notifications:
+  email: false
+env:
+  global:
+    secure: S5CYGmnmHV6FE/P0W2H7sEJwR3jGcuW97wIzNLBSDkl1Nvmc2NAw6WynoqOGSEVafmauVjX+w+gOkF2UgJImBYwDjwGmSVcKSPj1SWuuT648pq5mJjW4kyS/lKnA8PaiqS1nMVAbGHtZjH3cEG0w0oFPilDN7nsCCzm4kztkRWtZgHhGPc/UU0EYjsGkUVq3gsYFNm09dzMxzmg9U8jdOLUM354mxP2FKqBQ795/HkEXtb5mGSKnSBWB4jdk9enmBe/M6/Vvo9X98drz4GRVdHpvy5LvWPwYSvwKNprErPcIasLxONOUXTEzA45/RSJZBLUuGlrNu7f9tA9JNbrUaVRp+vnhRpue5nNYIowPUVOnjxfE/qgx3X4k5K26pbO6wKfhdDYRK6Qh85rYNuHpd0caiEoTJJlXQp6sTo/wKQI5p9BF4b3FRG1RtCoMbjLFrQin4l0JwILoAyGyTbk50XdQvwDDlFs1lGiGxe0AK0lxX6s5yqdykaXkx5qwTSuWZqFc+9+bAEy6TNzEqBuT+r1mxIfVep8bNxynDLRg26NibGAFHzMHuqgEM4mLeOUkKnBDv1LghRJ0fzhroINJHAj5KBp145r6iJSVR7xRjKJpQptpIZ3asi5Xl37sQb98+p+1Pg4Wwzn9Y8lEyx49lml7oppDvabcbOCTy0LFuuk=

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+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.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at fnando.vieira@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nando Vieira
+
+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,196 @@
+# SQLRunner
+
+[![Travis-CI](https://travis-ci.org/fnando/sql_runner.png)](https://travis-ci.org/fnando/sql_runner)
+[![Code Climate](https://codeclimate.com/github/fnando/sql_runner/badges/gpa.svg)](https://codeclimate.com/github/fnando/sql_runner)
+[![Test Coverage](https://codeclimate.com/github/fnando/sql_runner/badges/coverage.svg)](https://codeclimate.com/github/fnando/sql_runner/coverage)
+[![Gem](https://img.shields.io/gem/v/sql_runner.svg)](https://rubygems.org/gems/sql_runner)
+[![Gem](https://img.shields.io/gem/dt/sql_runner.svg)](https://rubygems.org/gems/sql_runner)
+
+SQLRunner allows you to load your queries out of SQL files, without using ORMs. Available only for PostgreSQL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "sql_runner"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sql_runner
+
+## Usage
+
+Run raw queries:
+
+```ruby
+SQLRunner.connect("postgresql:///test?application_name=myapp")
+
+SQLRunner.execute("SELECT 1")
+#=> <PG:Result:0x007fdf8d3475f0>
+
+SQLRunner.execute("SELECT 1").values
+#=> [["1"]]
+
+SQLRunner.execute("SELECT :number::integer", number: 1).values
+#=> [["1"]]
+```
+
+Run SQL files:
+
+```ruby
+SQLRunner.root_dir = "#{__dir__}/sql"
+
+class GetMembers < SQLRunner::Query
+  # by default will use root_dir/get_members.sql
+end
+```
+
+Specify custom SQL:
+
+```ruby
+class GetMembers < SQLRunner::Query
+  query "SELECT * FROM members ORDER BY created_at"
+end
+```
+
+Specify custom connection:
+
+```ruby
+class GetMembers < SQLRunner::Query
+  connect "postgresql:///another_database"
+end
+```
+
+Specify other options:
+
+```ruby
+class GetMembers < SQLRunner::Query
+  query_name "users" #=> will load root_dir/users.sql
+  root_dir "/some/path"
+end
+```
+
+### Plugins
+
+#### Load just one record
+
+```ruby
+class FindUserByEmail < SQLRunner::Query
+  plugin :one
+  query "SELECT * FROM users WHERE email = :email LIMIT 1"
+end
+
+FindUserByEmail.call(email: "john@example.com")
+#=> {"id" => 1, "email" => "john@example.com"}
+
+FindUserByEmail.call(email: "invalid")
+#=> nil
+
+FindUserByEmail.call!(email: "invalid")
+#=> raise exception SQLRunner::RecordNotFound
+```
+
+#### Use a model
+
+```ruby
+require "virtus"
+
+class UserModel
+  include Virtus.model
+
+  attribute :id, String
+  attribute :email, String
+  attribute :name, String
+end
+
+class FindUserByEmail < SQLRunner::Query
+  plugin :one
+  plugin model: UserModel
+  query "SELECT * FROM users WHERE email = :email LIMIT 1"
+end
+
+FindUserByEmail.call(email: "john@example.com")
+#=> <UserModel:0x007fdf8c2c1280>
+```
+
+#### Avoid calling .to_a in collections
+
+```ruby
+class FindUsers < SQLRunner::Query
+  plugin :many
+  query "SELECT * FROM users"
+end
+
+FindUsers.call
+#=> [{"id" => "1", "email" => "john@example.com"}]
+```
+
+### Adding new plugins
+
+First you have to create a class/module that implements the `.activate(target, options)` class method. The following example overrides the `call(**bind_vars)` method by using `Module.prepend`.
+
+```ruby
+module ReverseRecords
+  def self.activate(target, options)
+    target.singleton_class.prepend self
+  end
+
+  def call(**bind_vars)
+    super(**bind_vars).to_a.reverse
+  end
+end
+
+# Register the plugin.
+SQLRunner::Query.register_plugin :reverse, ReverseRecords
+
+class Users < SQLRunner::Query
+  query "SELECT * FROM users ORDER BY created_at ASC"
+  plugin :reverse
+end
+
+Users.call
+```
+
+If you plugin can receive options, you can call it as `plugin reverse: options`, where `options` can be anything (e.g. `Hash`, `Array`, `Object`, etc).
+
+## Benchmarks
+
+You won't gain too much performance by using this gem. These are the results against ActiveRecord using different wrapping libraries like [virtus](https://rubygems.org/gems/virtus) and [dry-types](https://rubygems.org/gems/dry-types).
+
+Loading just one record:
+
+```
+  sql_runner - find one (raw)      :     5518.6 i/s
+  sql_runner - find one (dry-types):     5015.4 i/s - same-ish: difference falls within error
+  sql_runner - find one (virtus)   :     4746.2 i/s - 1.16x slower
+activerecord - find one            :     3468.5 i/s - 1.59x slower
+```
+
+Loading several records:
+
+```
+  sql_runner - find many (raw)      :     6808.2 i/s
+  sql_runner - find many (dry-types):     5251.4 i/s - same-ish: difference falls within error
+  sql_runner - find many (virtus)   :     4145.6 i/s - 1.64x slower
+activerecord - find many            :     2731.5 i/s - 2.49x slower
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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/fnando/sql_runner. 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 [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.warning = false
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sql_runner"
+
+# 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/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/examples/bench.rb

@@ -0,0 +1,93 @@
+$LOAD_PATH.push File.expand_path("#{__dir__}/../lib")
+require "sql_runner"
+require "virtus"
+require "benchmark/ips"
+require "active_record"
+require "dry-types"
+
+GC.disable
+
+connection_string = "postgres:///test?connect_timeout=2&application_name=myapp"
+SQLRunner.connect connection_string
+SQLRunner.pool = 25
+SQLRunner.timeout = 10
+SQLRunner.root_dir = "#{__dir__}/sql"
+
+ActiveRecord::Base.establish_connection("#{connection_string}&prepared_statements=false&pool=25")
+
+module Types
+  include Dry::Types.module
+end
+
+class User < ActiveRecord::Base
+end
+
+class UserDry < Dry::Types::Struct
+  module Builder
+    def self.new(attrs)
+      attrs = attrs.each_with_object({}) do |(key, value), buffer|
+        buffer[key.to_sym] = value
+      end
+
+      UserDry.new(attrs)
+    end
+  end
+
+  attribute :id, Types::String
+  attribute :name, Types::String
+  attribute :email, Types::String
+end
+
+class UserVirtus
+  include Virtus.model
+
+  attribute :id, String
+  attribute :name, String
+  attribute :email, String
+end
+
+class FindUserDry < SQLRunner::Query
+  query_name "find_user"
+  plugin :one
+  plugin model: UserDry::Builder
+end
+
+class FindUserVirtus < SQLRunner::Query
+  query_name "find_user"
+  plugin :one
+  plugin model: UserVirtus
+end
+
+class FindUser < SQLRunner::Query
+  plugin :one
+end
+
+class UsersVirtus < SQLRunner::Query
+  plugin model: UserVirtus
+  query_name "users"
+end
+
+class UsersDry < SQLRunner::Query
+  plugin model: UserDry::Builder
+  query_name "users"
+end
+
+class Users < SQLRunner::Query
+  query_name "users"
+end
+
+Benchmark.ips do |x|
+  x.report("activerecord - find one            ") { User.find_by_email("me@fnando.com") }
+  x.report("  sql_runner - find one (dry-types)") { FindUserDry.call(email: "me@fnando.com") }
+  x.report("  sql_runner - find one (virtus)   ") { FindUserVirtus.call(email: "me@fnando.com") }
+  x.report("  sql_runner - find one (raw)      ") { FindUser.call(email: "me@fnando.com") }
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("activerecord - find many            ") { User.all.to_a }
+  x.report("  sql_runner - find many (virtus)   ") { UsersVirtus.call }
+  x.report("  sql_runner - find many (dry-types)") { UsersDry.call }
+  x.report("  sql_runner - find many (raw)      ") { Users.call }
+  x.compare!
+end

data/examples/profiling.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.push File.expand_path("#{__dir__}/../lib")
+require "sql_runner"
+require "ruby-prof"
+
+connection_string = "postgres:///test?connect_timeout=2&application_name=myapp"
+SQLRunner.connect connection_string
+SQLRunner.pool = 25
+SQLRunner.timeout = 10
+SQLRunner.root_dir = "#{__dir__}/sql"
+
+class FindUser < SQLRunner::Query
+  plugin :one
+end
+
+result = RubyProf.profile do
+  FindUser.call email: "me@fnando.com"
+end
+
+File.open("examples/profiling.html", "w") do |io|
+  RubyProf::CallStackPrinter.new(result).print(io)
+end

data/examples/sql/create_user.sql

@@ -0,0 +1 @@
+INSERT INTO users (name, email) VALUES (:name, :email) RETURNING *

data/examples/sql/delete_all_users.sql

@@ -0,0 +1 @@
+DELETE FROM users RETURNING *

data/examples/sql/find_user.sql

@@ -0,0 +1 @@
+SELECT * FROM users WHERE email = :email

data/examples/sql/users.sql

@@ -0,0 +1 @@
+SELECT * FROM users

data/examples/test.rb

@@ -0,0 +1,93 @@
+$LOAD_PATH.push File.expand_path("#{__dir__}/../lib")
+require "sql_runner"
+require "virtus"
+
+SQLRunner.connect "postgres:///test?connect_timeout=2&application_name=myapp"
+SQLRunner.pool = 25
+SQLRunner.timeout = 10
+SQLRunner.root_dir = "#{__dir__}/sql"
+
+result = SQLRunner.execute "select application_name from pg_stat_activity where pid = pg_backend_pid();"
+p result.to_a
+
+result = SQLRunner.execute <<-SQL, name: "john", age: 18
+select
+  'hello'::text as message,
+  :name::text as name,
+  :age::integer as age,
+  :name::text as name2
+SQL
+p result.to_a
+
+class Users < SQLRunner::Query
+end
+
+module NumericModel
+  def self.new(attrs)
+    attrs.values.first.to_i
+  end
+end
+
+class Numbers < SQLRunner::Query
+  plugin model: NumericModel
+  plugin :many
+
+  query <<-SQL
+    SELECT n FROM generate_series(1, 10) n
+  SQL
+end
+
+class User
+  include Virtus.model
+
+  attribute :id, String
+  attribute :name, String
+  attribute :email, Integer
+end
+
+class Customer < User
+end
+
+class FindUser < SQLRunner::Query
+  plugins :one
+  plugin model: User
+end
+
+class FindAllUsers < SQLRunner::Query
+  plugins :many
+  plugin model: User
+end
+
+class CreateUser < SQLRunner::Query
+  plugin :one
+  plugin model: User
+end
+
+class DeleteAllUsers < SQLRunner::Query
+  plugin :many
+  plugin model: User
+end
+
+class FindCustomer < SQLRunner::Query
+  query_name "find_user"
+  plugin model: Customer
+  plugins :one
+end
+
+p DeleteAllUsers.call
+p CreateUser.call(name: "Nando Vieira", email: "me@fnando.com")
+p CreateUser.call(name: "John Doe", email: "john@example.com")
+p Numbers.call
+p Users.call.to_a
+p FindUser.call(email: "me@fnando.com")
+p FindUser.call(email: "' OR 1=1 --me@fnando.com")
+p FindUser.call!(email: "me@fnando.com")
+p FindCustomer.call!(email: "me@fnando.com")
+
+begin
+  FindUser.call!(email: "me@fnando.coms")
+rescue SQLRunner::RecordNotFound => error
+  p error
+end
+
+SQLRunner.disconnect

data/lib/sql_runner.rb

@@ -0,0 +1,27 @@
+require "uri"
+require "connection_pool"
+
+module SQLRunner
+  require "sql_runner/version"
+  require "sql_runner/connection"
+  require "sql_runner/adapters"
+  require "sql_runner/runner"
+  require "sql_runner/query"
+  require "sql_runner/query/one"
+  require "sql_runner/query/model"
+  require "sql_runner/query/many"
+  require "sql_runner/configuration"
+
+  extend Configuration
+  extend Runner
+
+  Adapters.register("postgres", Adapters::PostgreSQL)
+  Adapters.register("postgresql", Adapters::PostgreSQL)
+
+  Query.register_plugin :one, Query::One
+  Query.register_plugin :many, Query::Many
+  Query.register_plugin :model, Query::Model
+
+  self.timeout = ENV.fetch("SQL_CONNECTION_TIMEOUT", 5)
+  self.pool    = ENV.fetch("SQL_CONNECTION_POOL", 5)
+end

data/lib/sql_runner/adapters.rb

@@ -0,0 +1,20 @@
+module SQLRunner
+  UnsupportedDatabase = Class.new(StandardError)
+  MissingDependency   = Class.new(StandardError)
+
+  module Adapters
+    require "sql_runner/adapters/postgresql"
+
+    ADAPTERS = {}
+
+    def self.register(name, adapter)
+      ADAPTERS[name] = adapter
+    end
+
+    def self.find(name)
+      ADAPTERS
+        .fetch(name) { fail UnsupportedDatabase, "#{name} is not supported by SQLRunner" }
+        .tap {|adapter| adapter.load }
+    end
+  end
+end

data/lib/sql_runner/adapters/postgresql.rb

@@ -0,0 +1,94 @@
+module SQLRunner
+  module Adapters
+    class PostgreSQL
+      InvalidPreparedStatement = Class.new(StandardError)
+
+      def self.load
+        require "pg"
+      rescue LoadError
+        fail MissingDependency, "make sure the pg gem is available"
+      end
+
+      def initialize(connection_string)
+        @connection_string = connection_string
+        connect
+      end
+
+      def connect(started = Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        @connection = PG.connect(@connection_string)
+      rescue PG::ConnectionBad
+        ended = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        if ended - started < SQLRunner.timeout
+          sleep 0.1
+          connect(started)
+        else
+          raise
+        end
+      end
+
+      def disconnect
+        @connection && @connection.close && (@connection = nil)
+      end
+
+      def reconnect
+        disconnect
+        connect
+      end
+
+      def connection
+        @connection
+      end
+
+      def execute(query, **bind_vars)
+        query, bindings = parse(query)
+        args = extract_args(query, bindings, bind_vars)
+        @connection.exec_params(query, args)
+      rescue PG::ConnectionBad
+        reconnect
+        execute(query, **bind_vars)
+      end
+
+      def active?
+        @connection && @connection.status == PG::Connection::CONNECTION_OK
+      rescue PGError
+        false
+      end
+
+      def to_s
+        %[#<#{self.class.name} #{"0x00%x" % (object_id << 1)}>]
+      end
+
+      def inspect
+        to_s
+      end
+
+      def parse(query)
+        bindings = {}
+        count = 0
+
+        parsed_query = query.gsub(/(:?):([a-zA-Z]\w*)/) do |match|
+          next match if $1 == ":" # skip type casting
+
+          name = match[1..-1]
+          sym_name = name.to_sym
+
+          if (!index = bindings[sym_name])
+            index = (count += 1)
+            bindings[sym_name] = index
+          end
+
+          "$#{index}"
+        end
+
+        [parsed_query, bindings]
+      end
+
+      private def extract_args(query, bindings, bind_vars)
+        bindings.each_with_object([]) do |(name, position), buffer|
+          buffer[position - 1] = bind_vars.fetch(name) { fail InvalidPreparedStatement, "missing value for :#{name} in #{query}" }
+        end
+      end
+    end
+  end
+end

data/lib/sql_runner/configuration.rb

@@ -0,0 +1,7 @@
+module SQLRunner
+  module Configuration
+    attr_accessor :root_dir
+    attr_accessor :timeout
+    attr_accessor :pool
+  end
+end

data/lib/sql_runner/connection.rb

@@ -0,0 +1,28 @@
+module SQLRunner
+  module Connection
+    def self.call(connection_string)
+      uri = URI.parse(connection_string)
+      adapter = Adapters.find(uri.scheme)
+
+      ConnectionPool.new(timeout: SQLRunner.timeout, size: SQLRunner.pool) do
+        adapter.new(connection_string)
+      end
+    end
+
+    def with_connection(&block)
+      connection_pool.with(&block)
+    end
+
+    def connect(connection_string)
+      @connection_pool = Connection.call(connection_string)
+    end
+
+    def disconnect
+      connection_pool && connection_pool.shutdown {|conn| conn.disconnect } && (@connection_pool = nil)
+    end
+
+    def connection_pool
+      @connection_pool
+    end
+  end
+end

data/lib/sql_runner/query.rb

@@ -0,0 +1,70 @@
+module SQLRunner
+  RecordNotFound     = Class.new(StandardError)
+  PluginNotFound     = Class.new(StandardError)
+  InvalidPluginOrder = Class.new(StandardError)
+
+  class Query
+    extend Runner
+
+    PLUGINS = {}
+
+    def self.query_name(*values)
+      @query_name = values.first if values.any?
+      @query_name || (@query_name = query_name_from_class)
+    end
+
+    def self.query_name_from_class
+      name
+        .gsub("::", "/")
+        .gsub(/([a-z0-9])([A-Z])/) { "#{$1}_#{$2.downcase}" }
+        .downcase
+    end
+
+    def self.query(*value)
+      @query = value.first if value.any?
+      @query || (@query = File.read(File.join(root_dir, "#{query_name}.sql")))
+    end
+
+    def self.connection_pool
+      @connection_pool || SQLRunner.connection_pool
+    end
+
+    def self.root_dir(*value)
+      @root_dir = value.first if value.any?
+      @root_dir || SQLRunner.root_dir
+    end
+
+    def self.call(**bind_vars)
+      execute(query, **bind_vars)
+    end
+
+    def self.register_plugin(name, mod)
+      PLUGINS[name] = mod
+    end
+
+    def self.plugin(*names)
+      plugins *names
+    end
+
+    def self.plugins(*names)
+      names = prepare_plugins_with_options(names)
+
+      names.each do |name, options|
+        plugin = PLUGINS.fetch(name) { fail PluginNotFound, "#{name.inspect} wasn't found" }
+        plugin.activate(self, options)
+      end
+    end
+
+    def self.prepare_plugins_with_options(plugins)
+      return plugins unless plugins.last.kind_of?(Hash)
+
+      plugins_with_options = plugins.pop
+
+      plugins_with_options.each do |(name, options)|
+        plugins << [name.to_sym, options]
+      end
+
+      plugins
+    end
+  end
+end

data/lib/sql_runner/query/many.rb

@@ -0,0 +1,13 @@
+module SQLRunner
+  class Query
+    module Many
+      def self.activate(target, _options)
+        target.singleton_class.prepend self
+      end
+
+      def call(**bind_vars)
+        super(**bind_vars).to_a
+      end
+    end
+  end
+end

data/lib/sql_runner/query/model.rb

@@ -0,0 +1,24 @@
+module SQLRunner
+  class Query
+    module Model
+      def self.activate(target, model)
+        target.singleton_class.class_eval do
+          attr_accessor :model
+        end
+
+        target.model = model
+        target.singleton_class.prepend self
+      end
+
+      def call(**bind_vars)
+        result = super(**bind_vars)
+        return unless result
+        return model.new(result) if result.kind_of?(Hash)
+
+        result.to_a.map do |attrs|
+          model.new(attrs)
+        end
+      end
+    end
+  end
+end

data/lib/sql_runner/query/one.rb

@@ -0,0 +1,18 @@
+module SQLRunner
+  class Query
+    module One
+      def self.activate(target, _options)
+        target.singleton_class.prepend self
+      end
+
+      def call(**bind_vars)
+        result = super(**bind_vars)
+        result.to_a.first
+      end
+
+      def call!(**bind_vars)
+        call(**bind_vars) or fail SQLRunner::RecordNotFound, "#{name}: record was not found with #{bind_vars.inspect} arguments"
+      end
+    end
+  end
+end

data/lib/sql_runner/runner.rb

@@ -0,0 +1,11 @@
+module SQLRunner
+  module Runner
+    include Connection
+
+    def execute(query, **bind_vars)
+      with_connection do |conn|
+        conn.execute(query, **bind_vars)
+      end
+    end
+  end
+end

data/lib/sql_runner/version.rb

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

data/sql_runner.gemspec

@@ -0,0 +1,28 @@
+require "./lib/sql_runner/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sql_runner"
+  spec.version       = SQLRunner::VERSION
+  spec.authors       = ["Nando Vieira"]
+  spec.email         = ["fnando.vieira@gmail.com"]
+
+  spec.summary       = "SQLRunner allows you to load your queries out of SQL files, without using ORMs. Available only for PostgreSQL."
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/fnando/sql_runner"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "connection_pool"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest-utils"
+  spec.add_development_dependency "pry-meta"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: sql_runner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nando Vieira
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: minitest-utils
+  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-meta
+  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: pg
+  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: mocha
+  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: codeclimate-test-reporter
+  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'
+description: SQLRunner allows you to load your queries out of SQL files, without using
+  ORMs. Available only for PostgreSQL.
+email:
+- fnando.vieira@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/bench.rb
+- examples/profiling.rb
+- examples/sql/create_user.sql
+- examples/sql/delete_all_users.sql
+- examples/sql/find_user.sql
+- examples/sql/users.sql
+- examples/test.rb
+- lib/sql_runner.rb
+- lib/sql_runner/adapters.rb
+- lib/sql_runner/adapters/postgresql.rb
+- lib/sql_runner/configuration.rb
+- lib/sql_runner/connection.rb
+- lib/sql_runner/query.rb
+- lib/sql_runner/query/many.rb
+- lib/sql_runner/query/model.rb
+- lib/sql_runner/query/one.rb
+- lib/sql_runner/runner.rb
+- lib/sql_runner/version.rb
+- sql_runner.gemspec
+homepage: https://github.com/fnando/sql_runner
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: SQLRunner allows you to load your queries out of SQL files, without using
+  ORMs. Available only for PostgreSQL.
+test_files: []