ensql 0.6.0 → 0.6.5

data/ensql.gemspec

@@ -3,15 +3,15 @@
 require_relative "lib/ensql/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "ensql"
-  spec.version       = Ensql::VERSION
-  spec.authors       = ["Daniel Fone"]
-  spec.email         = ["daniel@fone.net.nz"]
-
-  spec.summary       = "Write SQL the safe and simple way"
-  spec.description   = "Ditch your ORM and embrace the power and simplicity of writing plain SQL again."
-  spec.homepage      = "https://github.com/danielfone/ensql"
-  spec.license       = "MIT"
+  spec.name = "ensql"
+  spec.version = Ensql::VERSION
+  spec.authors = ["Daniel Fone"]
+  spec.email = ["daniel@fone.net.nz"]
+
+  spec.summary = "Write SQL the safe and simple way"
+  spec.description = "Escape your ORM and embrace the power and simplicity of writing plain SQL again."
+  spec.homepage = "https://github.com/danielfone/ensql"
+  spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
@@ -25,8 +25,14 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "connection_pool", ">= 0.9.3", "<3"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov", "~> 0.21.2"
+  spec.add_development_dependency "yard", "~> 0.9.26"
 end

data/gemfiles/maintained.gemfile

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This specifies the oldest maintained versions of our dependencies
+#
+
+source "https://rubygems.org"
+
+ruby "~> 2.5.0"
+
+# Specify your gem's dependencies in ensql.gemspec
+gemspec path: "../"
+
+# Optional runtime dependencies
+group :adapters do
+  require_relative "../lib/ensql/version"
+  gem "activerecord", "~> 5.2.0"
+  gem "sequel", "~> 5.9"
+  gem "sqlite3"
+  gem "pg"
+  gem "sequel_pg"
+end

data/gemfiles/maintained.gemfile.lock

@@ -0,0 +1,81 @@
+PATH
+  remote: ..
+  specs:
+    ensql (0.6.5)
+      connection_pool (>= 0.9.3, < 3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.4.5)
+      activesupport (= 5.2.4.5)
+    activerecord (5.2.4.5)
+      activemodel (= 5.2.4.5)
+      activesupport (= 5.2.4.5)
+      arel (>= 9.0)
+    activesupport (5.2.4.5)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    concurrent-ruby (1.1.8)
+    connection_pool (2.2.3)
+    diff-lcs (1.4.4)
+    docile (1.3.5)
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.4)
+    pg (1.2.3)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    sequel (5.42.0)
+    sequel_pg (1.14.0)
+      pg (>= 0.18.0, != 1.2.0)
+      sequel (>= 4.38.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.2)
+    sqlite3 (1.4.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
+    yard (0.9.26)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-18
+  x86_64-linux
+
+DEPENDENCIES
+  activerecord (~> 5.2.0)
+  ensql!
+  pg
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  sequel (~> 5.9)
+  sequel_pg
+  simplecov (~> 0.21.2)
+  sqlite3
+  yard (~> 0.9.26)
+
+RUBY VERSION
+   ruby 2.5.8p224
+
+BUNDLED WITH
+   2.2.9

data/gemfiles/minimum.gemfile

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#
+# This specifies the oldest compatible versions of our dependencies
+#
+
+source "https://rubygems.org"
+
+ruby "2.4.0"
+
+# Specify your gem's dependencies in ensql.gemspec
+gemspec path: "../"
+
+# Downgrade simplecov for ruby 2.4 compat
+gem "simplecov", "~> 0.18.5"
+gem "connection_pool", "0.9.3"
+
+# Optional runtime dependencies
+group :adapters do
+  require_relative "../lib/ensql/version"
+  gem "activerecord", Ensql::SUPPORTED_ACTIVERECORD_VERSIONS.to_s.scan(/\d+.\d+/).first
+  gem "sequel", Ensql::SUPPORTED_SEQUEL_VERSIONS.to_s.scan(/\d+.\d+/).first
+  gem "sqlite3", "~> 1.3.6" # AR version constraint
+  gem "pg", Ensql::SUPPORTED_PG_VERSIONS.to_s.scan(/\d+.\d+/).first
+  gem "sequel_pg"
+end

data/gemfiles/minimum.gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: ..
+  specs:
+    ensql (0.6.5)
+      connection_pool (>= 0.9.3, < 3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.0.0)
+      activesupport (= 5.0.0)
+    activerecord (5.0.0)
+      activemodel (= 5.0.0)
+      activesupport (= 5.0.0)
+      arel (~> 7.0)
+    activesupport (5.0.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (7.1.4)
+    concurrent-ruby (1.1.8)
+    connection_pool (0.9.3)
+    diff-lcs (1.4.4)
+    docile (1.3.5)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.4)
+    pg (0.19.0)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    sequel (5.9.0)
+    sequel_pg (1.14.0)
+      pg (>= 0.18.0, != 1.2.0)
+      sequel (>= 4.38.0)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
+    sqlite3 (1.3.13)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
+    yard (0.9.26)
+
+PLATFORMS
+  x86_64-darwin-18
+  x86_64-linux
+
+DEPENDENCIES
+  activerecord (= 5.0)
+  connection_pool (= 0.9.3)
+  ensql!
+  pg (= 0.19)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  sequel (= 5.9)
+  sequel_pg
+  simplecov (~> 0.18.5)
+  sqlite3 (~> 1.3.6)
+  yard (~> 0.9.26)
+
+BUNDLED WITH
+   2.2.9

data/lib/ensql.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "ensql/version"
+require_relative "ensql/adapter"
 require_relative "ensql/sql"
+require_relative "ensql/transaction"
+require_relative "ensql/load_sql"
 
 #
 # Primary interface for loading, interpolating and executing SQL statements
@@ -24,46 +27,13 @@ require_relative "ensql/sql"
 #     Ensql.sql('select * from users where id = %{id}', id: 1).first_row # => { "id" => 1, "email" => "test@example.com" }
 #
 module Ensql
-  # Wrapper for errors raised by Ensql
-  class Error < StandardError; end
-
   class << self
-
     # (see SQL)
     # @return [Ensql::SQL] SQL statement
-    def sql(sql, params={})
+    def sql(sql, params = {})
       SQL.new(sql, params)
     end
 
-    # Path to search for *.sql queries in, defaults to "sql/". For example, if
-    # {sql_path} is set to 'app/queries', `load_sql('users/active')` will read
-    # 'app/queries/users/active.sql'.
-    # @see .load_sql
-    #
-    # @example
-    #   Ensql.sql_path = Rails.root.join('app/queries')
-    #
-    def sql_path
-      @sql_path ||= 'sql'
-    end
-    attr_writer :sql_path
-
-    # Load SQL from a file within {sql_path}. This is the recommended way to
-    # manage SQL in a non-trivial project. For details of how to write
-    # interpolation placeholders, see {SQL}.
-    #
-    # @see .sql_path=
-    # @return [Ensql::SQL]
-    #
-    # @example
-    #   Ensql.load_sql('users/activity', report_params)
-    #   Ensql.load_sql(:upsert_users, imported_users_attrs)
-    #
-    def load_sql(name, params={})
-      path = File.join(sql_path, "#{name}.sql")
-      SQL.new(File.read(path), params, name)
-    end
-
     # Convenience method to interpolate and run the supplied SQL on the current
     # adapter.
     # @return [void]
@@ -72,38 +42,8 @@ module Ensql
     #   Ensql.run("DELETE FROM users WHERE id = %{id}", id: user.id)
     #   Ensql.run("ALTER TABLE test RENAME TO old_test")
     #
-    def run(sql, params={})
+    def run(sql, params = {})
       SQL.new(sql, params).run
     end
-
-    # Connection adapter to use. Must implement the interface defined in
-    # {Ensql::Adapter}. If not specified, it will try to autoload an adapter
-    # based on the availability of Sequel or ActiveRecord, in that order.
-    #
-    # @example
-    #     require 'sequel'
-    #     Ensql.adapter # => Ensql::SequelAdapter
-    #     Ensql.adapter = Ensql::ActiveRecordAdapter # override adapter
-    #     Ensql.adapter = CustomMSSQLAdapater # supply your own adapter
-    #
-    def adapter
-      @adapter ||= autoload_adapter
-    end
-    attr_writer :adapter
-
-  private
-
-    def autoload_adapter
-      if defined? Sequel
-        require_relative 'ensql/sequel_adapter'
-        SequelAdapter
-      elsif defined? ActiveRecord
-        require_relative 'ensql/active_record_adapter'
-        ActiveRecordAdapter
-      else
-        raise Error, "Couldn't autodetect an adapter, please specify manually."
-      end
-    end
-
   end
 end

data/lib/ensql/active_record_adapter.rb

@@ -1,60 +1,104 @@
 # frozen_string_literal: true
 
-require_relative 'version'
-require_relative 'adapter'
+require_relative "version"
+require_relative "adapter"
+require_relative "pool_wrapper"
 
 # Ensure our optional dependency has a compatible version
-gem 'activerecord', Ensql::ACTIVERECORD_VERSION
-require 'active_record'
+gem "activerecord", Ensql::SUPPORTED_ACTIVERECORD_VERSIONS
+require "active_record"
 
 module Ensql
   #
-  # Implements the {Adapter} interface for ActiveRecord. Requires an
-  # ActiveRecord connection to be configured and established. Uses
-  # ActiveRecord::Base for the connection.
+  # Wraps an ActiveRecord connection pool to implement the {Adapter} interface
+  # for ActiveRecord. Requires an ActiveRecord connection to be configured and
+  # established. By default, uses the connection pool on ActiveRecord::Base.
+  # Other pools can be passed to the constructor.
   #
   # @example
   #   require 'active_record'
   #   ActiveRecord::Base.establish_connection(adapter: 'postgresql', database: 'mydb')
-  #   Ensql.adapter = Ensql::ActiveRecordAdapter
+  #   Ensql.adapter = Ensql::ActiveRecordAdapter.new
+  #   # Use database configuration for the Widget model instead
+  #   Ensql.adapter = Ensql::ActiveRecordAdapter.new(Widget)
   #
-  # @see Adapter
-  # @see ACTIVERECORD_VERSION Required gem version
+  # @see SUPPORTED_ACTIVERECORD_VERSIONS
   #
-  module ActiveRecordAdapter
-    extend Adapter
-
-    # @!visibility private
-    def self.fetch_rows(sql)
-      result = connection.exec_query(sql)
-      result.map do |row|
-        # Deserialize column types if needed
-        row.each_with_object({}) do |(column, value), hash|
-          hash[column] = result.column_types[column] ? result.column_types[column].deserialize(value) : value
-        end
+  class ActiveRecordAdapter
+    include Adapter
+
+    # Wrap the raw connections from an Active Record connection pool. This
+    # allows us to safely checkout the underlying database connection for use in
+    # a database specific adapter.
+    #
+    #     Ensql.adapter = MySqliteAdapter.new(ActiveRecordAdapter.pool)
+    #
+    # @param base [Class] an ActiveRecord class to source connections from
+    # @return [PoolWrapper] a pool adapter for raw connections
+    def self.pool(base = ActiveRecord::Base)
+      PoolWrapper.new do |client_block|
+        base.connection_pool.with_connection { |connection| client_block.call connection.raw_connection }
       end
     end
 
-    # @!visibility private
-    def self.run(sql)
-      connection.execute(sql)
+    # Support deprecated class method interface
+    class << self
+      require "forwardable"
+      extend Forwardable
+
+      delegate [:literalize, :run, :fetch_count, :fetch_each_row, :fetch_rows, :fetch_first_column, :fetch_first_field, :fetch_first_row] => :new
     end
 
-    # @!visibility private
-    def self.fetch_count(sql)
-      connection.exec_update(sql)
+    # @param base [Class] an ActiveRecord class to source connections from
+    def initialize(base = ActiveRecord::Base)
+      @base = base
     end
 
-    # @!visibility private
-    def self.literalize(value)
-      connection.quote(value)
+    # @visibility private
+    def fetch_rows(sql)
+      fetch_each_row(sql).to_a
     end
 
-    def self.connection
-      ActiveRecord::Base.connection
+    # @visibility private
+    def fetch_each_row(sql, &block)
+      return to_enum(:fetch_each_row, sql) unless block
+
+      result = with_connection { |c| c.exec_query(sql) }
+      # AR populates `column_types` with the types of any columns that haven't
+      # already been type casted by pg decoders. If present, we need to
+      # deserialize them now.
+      if result.column_types.any?
+        result.each { |row| yield deserialize_types(row, result.column_types) }
+      else
+        result.each(&block)
+      end
     end
 
-    private_class_method :connection
+    # @visibility private
+    def run(sql)
+      with_connection { |c| c.execute(sql) }
+      nil
+    end
+
+    # @visibility private
+    def fetch_count(sql)
+      with_connection { |c| c.exec_update(sql) }
+    end
 
+    # @visibility private
+    def literalize(value)
+      with_connection { |c| c.quote(value) }
+    end
+
+    private
+
+    def with_connection(&block)
+      @base.connection_pool.with_connection(&block)
+    end
+
+    def deserialize_types(row, column_types)
+      column_types.each { |column, type| row[column] = type.deserialize(row[column]) }
+      row
+    end
   end
 end