ensql 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bc1fdbc384c83a4d0a8ab1544f095320d63d66bc814cc30877f63bdc766be40
-  data.tar.gz: 7af7a154c0b4480278377f3dae635daf890ed69fd259f6bcffa3a14c3b4a8269
+  metadata.gz: 926a86bf4e2b069dfee856bc77567048cca9f5e621d48e255fe3d5f1c041a42d
+  data.tar.gz: 294b707b6a8d8394ba12eafe20298bb800ab86584f354bacfe8cbdef66581531
 SHA512:
-  metadata.gz: 1d085a19d85b24a3a4d038e137b54b439fafe8b30ec5f5b2e384792af87c00e3daf462ed08a8d16c252568d1f1d6bb1bf390e23c23423a8f48de4085f0f6e487
-  data.tar.gz: 7ee53cbd22ce7c5c059659b50fccd6a3e0f3b0836f0114d916d1faab3c6cdb7a598a5588102631cab3de6b2c435236939e0b43cdb550c7f068fb76c4eea579ed
+  metadata.gz: fd0ed7157a3c0dd791a3635af47e7fb58ec54ab770e38eb1765e224e4674c4065278af952d74f142db42242b4ab7bb2cfb23f89eefbdb39ec3a5af44a3d7867a
+  data.tar.gz: 34a692c5053ab53c916faf15522d218365e926fd56aa4bf814eac547110b554b996c5ef6bfed09b76136b43705b00e438ad67508e30814b9734bd6bb6b53d07f

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## [0.6.2] - 2021-03-09
+
+- Adds a specialised adapter for PostgreSQL.
+- Uses instances instead of modules for SequelAdapter and ActiveRecordAdapter. The use of the (now) classes as adapters is deprecated.
+- Adds connection pool wrappers for ActiveRecord and Sequel.
+- Ensures SQL#each_row returns nil.
+- Makes adapter attribute thread-safe.
+
 ## [0.6.1] - 2021-02-25
 
 - Enables the use of streaming with the SequelAdapter

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    ensql (0.6.1)
+    ensql (0.6.2)
+      connection_pool (>= 0.9.3, < 3)
 
 GEM
   remote: https://rubygems.org/
@@ -18,6 +19,7 @@ GEM
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     concurrent-ruby (1.1.8)
+    connection_pool (2.2.3)
     diff-lcs (1.4.4)
     docile (1.3.5)
     i18n (1.8.9)

data/README.md

@@ -68,19 +68,33 @@ Or install it manually with:
 
 Ensql requires:
 
-* Ruby >= 2.4.0
-* Sequel >= 5.9 if using Sequel
-* ActiveRecord >= 5.0 if using ActiveRecord
+* ruby >= 2.4.0
+* sequel >= 5.9 if using SequelAdapter
+* activerecord >= 5.0 if using ActiveRecordAdapter
+* pg >= 0.19 if using PostgresAdapter
 
 ## Usage
 
 Typically, you don't need to configure anything. Ensql will look for Sequel or ActiveRecord (in that order) and load the
-appropriate adapter. You can override this if you need to, or configure your own adapter. See [the API docs](https://rubydoc.info/gems/ensql/Ensql/Adapter) for
-details of the interface.
+appropriate adapter. You can override this if the wrong adapter is autoconfigured, or if you're using PostgreSQL and
+want to use the much faster and more convenient PostgresAdapter.
 
 ```ruby
-Ensql.adapter = Ensql::ActiveRecordAdapter # Will use ActiveRecord instead
+# Use ActiveRecord instead of Sequel if both are available
+Ensql.adapter = Ensql::ActiveRecordAdapter.new
+
+# Use the PostgreSQL specific adapter, with ActiveRecord's connection pool
+Ensql.adapter = Ensql::PostgresAdapter.new Ensql::ActiveRecordAdapter.pool
+
+# Use the PostgreSQL specific adapter, with Sequel's connection pool
+DB = Sequel.connect(ENV['DATABASE_URL'])
+Ensql.adapter = Ensql::PostgresAdapter.new Ensql::SequelAdapter.pool(DB)
+
+# Use the PostgreSQL specific adapter, with our own thread-safe connection pool
+Ensql.adapter = Ensql::PostgresAdapter.pool { PG.connect ENV['DATABASE_URL'] }
 ```
+You can also supply your own adapter (see [the API docs](https://rubydoc.info/gems/ensql/Ensql/Adapter) for details of the interface).
+
 
 SQL can be supplied directly or read from a file. You're encouraged to organise all but the most trivial statements in
 their own *.sql files, for the reasons outlined above. You can organise them in whatever way makes most sense for your
@@ -178,21 +192,26 @@ Ensql.run('TRUNCATE logs') # same thing
 - Maybe we could use type hinting like `%{param:pgarray}` to indicated how to serialise the object as a literal.
 
 - Detecting the database and switching to a db specific adapters. This allows us to be more efficient and optimise some
-  literals in a database specific format, e.g. postgres array literals.
+  literals in a database specific format, e.g. PostgreSQL array literals.
 
-- Handling specific connections rather than just grabbing the default.
-
-- Establishing connections directly.
+- Proper single-row mode support for the pg adapter
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You'll
-need a running postgres database. You can also run `bin/console` for an interactive prompt that will allow you to
+need a running PostgreSQL database. 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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Release Checklist
+
+- [ ] Review changes in master since last release, especially the public API.
+- [ ] Ensure documentation is up to date.
+- [ ] Bump appropriate part of version in `version.rb`.
+- [ ] Update the spec version in each `.lock`.
+- [ ] Update `Changelog.md` with summary of new version.
+- [ ] Run `rake release` to create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/ensql.gemspec

@@ -29,6 +29,8 @@ Gem::Specification.new do |spec|
   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"

data/gemfiles/maintained.gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: ..
   specs:
-    ensql (0.6.0)
+    ensql (0.6.2)
+      connection_pool (>= 0.9.3, < 3)
 
 GEM
   remote: https://rubygems.org/
@@ -19,6 +20,7 @@ GEM
       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)
@@ -39,7 +41,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    sequel (5.41.0)
+    sequel (5.42.0)
     sequel_pg (1.14.0)
       pg (>= 0.18.0, != 1.2.0)
       sequel (>= 4.38.0)

data/gemfiles/minimum.gemfile

@@ -13,6 +13,7 @@ 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
@@ -20,6 +21,6 @@ group :adapters do
   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",           "~> 0.18" # AR version constraint
+  gem "pg",           Ensql::SUPPORTED_PG_VERSIONS.to_s.scan(/\d+.\d+/).first
   gem "sequel_pg"
 end

data/gemfiles/minimum.gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: ..
   specs:
-    ensql (0.6.0)
+    ensql (0.6.2)
+      connection_pool (>= 0.9.3, < 3)
 
 GEM
   remote: https://rubygems.org/
@@ -19,12 +20,13 @@ GEM
       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.21.0)
+    pg (0.19.0)
     rake (13.0.3)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -59,8 +61,9 @@ PLATFORMS
 
 DEPENDENCIES
   activerecord (= 5.0)
+  connection_pool (= 0.9.3)
   ensql!
-  pg (~> 0.18)
+  pg (= 0.19)
   rake (~> 13.0)
   rspec (~> 3.0)
   sequel (= 5.9)

data/lib/ensql.rb

@@ -76,30 +76,40 @@ module Ensql
       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.
+    # Get the current connection 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
+    #     Ensql.adapter # => Ensql::SequelAdapter.new
+    #     Ensql.adapter = Ensql::ActiveRecordAdapter.new # override adapter
+    #     Ensql.adapter = my_tsql_adapter # supply your own adapter
     #
     def adapter
-      @adapter ||= autoload_adapter
+      Thread.current[:ensql_adapter] || Thread.main[:ensql_adapter] ||= autoload_adapter
+    end
+
+    # Set the connection adapter to use. Must implement the interface defined in
+    # {Ensql::Adapter}. This uses a thread-local variable so adapters can be
+    # switched safely in a multi-threaded web server.
+    def adapter=(adapter)
+      if adapter.is_a?(Module) && (adapter.name == 'Ensql::SequelAdapter' || adapter.name == 'Ensql::ActiveRecordAdapter')
+        warn "Using `#{adapter}` as an adapter is deprecated, use `#{adapter}.new`.", uplevel: 1
+      end
+
+      Thread.current[:ensql_adapter] = adapter
     end
-    attr_writer :adapter
 
   private
 
     def autoload_adapter
       if defined? Sequel
         require_relative 'ensql/sequel_adapter'
-        SequelAdapter
+        SequelAdapter.new
       elsif defined? ActiveRecord
         require_relative 'ensql/active_record_adapter'
-        ActiveRecordAdapter
+        ActiveRecordAdapter.new
       else
         raise Error, "Couldn't autodetect an adapter, please specify manually."
       end

data/lib/ensql/active_record_adapter.rb

@@ -2,6 +2,7 @@
 
 require_relative 'version'
 require_relative 'adapter'
+require_relative 'pool_wrapper'
 
 # Ensure our optional dependency has a compatible version
 gem 'activerecord', Ensql::SUPPORTED_ACTIVERECORD_VERSIONS
@@ -9,30 +10,60 @@ 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 SUPPORTED_ACTIVERECORD_VERSIONS
   #
-  module ActiveRecordAdapter
-    extend Adapter
+  class ActiveRecordAdapter
+    include Adapter
 
-    # @!visibility private
-    def self.fetch_rows(sql)
+    # 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
+
+    # 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
+
+    # @param base [Class] an ActiveRecord class to source connections from
+    def initialize(base = ActiveRecord::Base)
+      @base = base
+    end
+
+    # @visibility private
+    def fetch_rows(sql)
       fetch_each_row(sql).to_a
     end
 
-    # @!visibility private
-    def self.fetch_each_row(sql, &block)
+    # @visibility private
+    def fetch_each_row(sql, &block)
       return to_enum(:fetch_each_row, sql) unless block_given?
 
-      result = connection.exec_query(sql)
+      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.
@@ -43,32 +74,31 @@ module Ensql
       end
     end
 
-    # @!visibility private
-    def self.run(sql)
-      connection.execute(sql)
+    # @visibility private
+    def run(sql)
+      with_connection { |c| c.execute(sql) }
+      nil
     end
 
-    # @!visibility private
-    def self.fetch_count(sql)
-      connection.exec_update(sql)
+    # @visibility private
+    def fetch_count(sql)
+      with_connection { |c| c.exec_update(sql) }
     end
 
-    # @!visibility private
-    def self.literalize(value)
-      connection.quote(value)
+    # @visibility private
+    def literalize(value)
+      with_connection { |c| c.quote(value) }
     end
 
-    def self.connection
-      ActiveRecord::Base.connection
-    end
+  private
 
-    def self.deserialize_types(row, column_types)
-      row.each_with_object({}) { |(column, value), hash|
-        hash[column] = column_types[column]&.deserialize(value) || value
-      }
+    def with_connection(&block)
+      @base.connection_pool.with_connection(&block)
     end
 
-    private_class_method :connection, :deserialize_types
-
+    def deserialize_types(row, column_types)
+      column_types.each { |column, type| row[column] = type.deserialize(row[column]) }
+      row
+    end
   end
 end

data/lib/ensql/pool_wrapper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ensql
+  # Wrap a 3rd-party connection pool with a standard interface. Connections can be checked out by {with}
+  class PoolWrapper
+
+    # Wraps a block for accessing a connection from a pool.
+    #
+    #     PoolWrapper.new do |client_block|
+    #       my_connection_pool.with_connection(&client_block)
+    #     end
+    def initialize(&connection_block)
+      @connection_block = connection_block
+    end
+
+    # Get a connection from our source pool
+    # @yield [connection] the database-specific connection
+    def with(&client_block)
+      @connection_block.call(client_block)
+    end
+  end
+end

data/lib/ensql/postgres_adapter.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'adapter'
+
+gem 'pg', Ensql::SUPPORTED_PG_VERSIONS
+require 'pg'
+require 'connection_pool'
+
+module Ensql
+  # Wraps a pool of PG connections to implement the {Adapter} interface. The
+  # adapter can use a 3rd-party pool (e.g. from ActiveRecord of Sequel) or
+  # manage its own using the simple
+  # [connection_pool gem](https://github.com/mperham/connection_pool).
+  #
+  # This adapter is much faster and offers much better PostgreSQL specific
+  # parameter interpolation than the framework adapters.
+  #
+  # @example
+  #     # Use with ActiveRecord's connection pool
+  #     Ensql.adapter = Ensql::PostgresAdapter.new(Ensql::ActiveRecordAdapter.pool)
+  #
+  #     # Use with Sequel's connection pool
+  #     DB = Sequel.connect(ENV['DATABASE_URL'])
+  #     Ensql.adapter = Ensql::PostgresAdapter.new(Ensql::SequelAdapter.pool(DB))
+  #
+  #     # Use with our own thread-safe connection pool
+  #     Ensql.adapter = Ensql::PostgresAdapter.pool { PG.connect ENV['DATABASE_URL'] }
+  #     Ensql.adapter = Ensql::PostgresAdapter.pool(size: 5) { PG.connect ENV['DATABASE_URL'] }
+  #
+  # @see SUPPORTED_PG_VERSIONS
+  #
+  class PostgresAdapter
+    include Adapter
+
+    # Set up a connection pool using the supplied block to initialise connections.
+    #
+    #     PostgresAdapter.pool(size: 20) { PG.connect ENV['DATABASE_URL'] }
+    #
+    # @param pool_opts are sent straight to the ConnectionPool initializer.
+    # @option pool_opts [Integer] timeout (5) number of seconds to wait for a connection if none currently available.
+    # @option pool_opts [Integer] size (5) number of connections to pool.
+    # @yieldreturn [PG::Connection] a new connection.
+    def self.pool(**pool_opts, &connection_block)
+      new ConnectionPool.new(**pool_opts, &connection_block)
+    end
+
+    # @param pool [PoolWrapper, ConnectionPool, #with] a object that yields a PG::Connection using `#with`
+    def initialize(pool)
+      @pool = pool
+      @quoter = PG::TextEncoder::QuotedLiteral.new
+      @result_type_map = @pool.with { |c| PG::BasicTypeMapForResults.new(c) }
+      @query_type_map = @pool.with { |c| build_query_type_map(c) }
+    end
+
+    # @visibility private
+    def run(sql)
+      execute(sql) { nil }
+    end
+
+    # @visibility private
+    def literalize(value)
+      case value
+      when NilClass then 'NULL'
+      when Numeric, TrueClass, FalseClass then value.to_s
+      when String then @quoter.encode(value)
+      else
+        @quoter.encode(serialize(value))
+      end
+    end
+
+    # @visibility private
+    def fetch_count(sql)
+      execute(sql, &:cmd_tuples)
+    end
+
+    # @visibility private
+    def fetch_first_field(sql)
+      fetch_result(sql) { |res| res.getvalue(0, 0) if res.ntuples > 0 && res.nfields > 0 }
+    end
+
+    # @visibility private
+    def fetch_first_row(sql)
+      fetch_result(sql) { |res| res[0] if res.ntuples > 0 }
+    end
+
+    # @visibility private
+    def fetch_first_column(sql)
+      # Return an array of nils if we don't have a column
+      fetch_result(sql) { |res| res.nfields > 0 ? res.column_values(0) : Array.new(res.ntuples) }
+    end
+
+    # @visibility private
+    def fetch_each_row(sql, &block)
+      return to_enum(:fetch_each_row, sql) unless block_given?
+
+      fetch_result(sql) { |res| res.each(&block) }
+    end
+
+    # @visibility private
+    def fetch_rows(sql)
+      fetch_result(sql, &:to_a)
+    end
+
+  private
+
+    def fetch_result(sql)
+      execute(sql) do |res|
+        res.type_map = @result_type_map
+        yield res
+      end
+    end
+
+    def execute(sql, &block)
+      @pool.with { |c| c.async_exec(sql, &block) }
+    end
+
+    # Use PG's built-in type mapping to serialize objects into SQL strings.
+    def serialize(value)
+      coder = encoder_for(value) or raise TypeError, "No SQL serializer for #{value.class}"
+      coder.encode(value)
+    end
+
+    def encoder_for(value)
+      coder = @query_type_map[value.class]
+      # Handle the weird case where coder can be a method name
+      coder.is_a?(Symbol) ? @query_type_map.send(coder, value) : coder
+    end
+
+    # Ensure encoders are set up for old versions of the pg gem
+    def build_query_type_map(connection)
+      map = PG::BasicTypeMapForQueries.new(connection)
+      map[Date] ||= PG::TextEncoder::Date.new
+      map[Time] ||= PG::TextEncoder::TimestampWithoutTimeZone.new
+      map[Hash] ||= PG::TextEncoder::JSON.new
+      map[BigDecimal] ||= NumericEncoder.new
+      map
+    end
+  end
+
+  # PG < 1.1.0 doesn't have a numeric decoder
+  # This is copied from https://github.com/ged/ruby-pg/commit/d4ae41bb8fd447c92ef9c8810ec932acd03e0293
+  # :nocov:
+  unless defined? PG::TextEncoder::Numeric
+    class NumericDecoder < PG::SimpleDecoder
+      def decode(string, tuple=nil, field=nil)
+        BigDecimal(string)
+      end
+    end
+    class NumericEncoder < PG::SimpleEncoder
+      def encode(decimal)
+        decimal.to_s('F')
+      end
+    end
+    private_constant :NumericDecoder, :NumericEncoder
+    PG::BasicTypeRegistry.register_type(0, 'numeric', NumericEncoder, NumericDecoder)
+  end
+  # :nocov:
+end

data/lib/ensql/sequel_adapter.rb

@@ -2,6 +2,7 @@
 
 require_relative 'version'
 require_relative 'adapter'
+require_relative 'pool_wrapper'
 
 # Ensure our optional dependency has a compatible version
 gem 'sequel', Ensql::SUPPORTED_SEQUEL_VERSIONS
@@ -9,15 +10,16 @@ require 'sequel'
 
 module Ensql
   #
-  # Implements the {Adapter} interface for Sequel. Requires a Sequel connection
-  # to be established. Uses the first connection found in Sequel::DATABASES. You
-  # may want to utilize the relevant extensions to make the most of
-  # deserialization and other database features.
+  # Wraps a Sequel::Database to implement the {Adapter} interface for Sequel.
+  # You may want to utilize the relevant Sequel extensions to make the most of
+  # database-specific deserialization and other features.  By default, uses the
+  # first database in Sequel::Databases. Other databases can be passed to the
+  # constructor.
   #
   #     require 'sequel'
   #     DB = Sequel.connect('postgres://localhost/mydb')
   #     DB.extend(:pg_json)
-  #     Ensql.adapter = Ensql::SequelAdapter
+  #     Ensql.adapter = Ensql::SequelAdapter.new(DB)
   #
   # To stream rows, configure streaming on the connection and use
   # {SQL.each_row}
@@ -25,6 +27,7 @@ module Ensql
   #      DB = Sequel.connect('postgresql:/')
   #      DB.extension(:pg_streaming)
   #      DB.stream_all_queries = true
+  #      Ensql.adapter = Ensql::SequelAdapter.new(DB)
   #      Ensql.sql("select * from large_table").each_row do  |row|
   #        # This now yields each row in single-row mode.
   #        # The connection cannot be used for other queries while this is streaming.
@@ -32,41 +35,71 @@ module Ensql
   #
   # @see SUPPORTED_SEQUEL_VERSIONS
   #
-  module SequelAdapter
-    extend Adapter
+  class SequelAdapter
+    include Adapter
 
-    # @!visibility private
-    def self.fetch_rows(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
+
+    # Wrap the raw connections from a Sequel::Database connection pool. This
+    # allows us to safely checkout the underlying database connection for use in
+    # a database specific adapter.
+    #
+    #     Ensql.adapter = MySqliteAdapter.new(SequelAdapter.pool)
+    #
+    # @param db [Sequel::Database]
+    # @return [PoolWrapper] a pool adapter for raw connections
+    def self.pool(db)
+      PoolWrapper.new do |client_block|
+        db.pool.hold(&client_block)
+      end
+    end
+
+    # @param db [Sequel::Database]
+    def initialize(db = first_configured_database)
+      @db = db
+    end
+
+    # @visibility private
+    def fetch_rows(sql)
       fetch_each_row(sql).to_a
     end
 
-    # @!visibility private
-    def self.fetch_each_row(sql)
+    # @visibility private
+    def fetch_each_row(sql)
       return to_enum(:fetch_each_row, sql) unless block_given?
 
       db.fetch(sql) { |r| yield r.transform_keys(&:to_s) }
     end
 
-    # @!visibility private
-    def self.fetch_count(sql)
+    # @visibility private
+    def fetch_count(sql)
       db.execute_dui(sql)
     end
 
-    # @!visibility private
-    def self.run(sql)
+    # @visibility private
+    def run(sql)
       db << sql
+      nil
     end
 
-    # @!visibility private
-    def self.literalize(value)
+    # @visibility private
+    def literalize(value)
       db.literal(value)
     end
 
-    def self.db
-      Sequel::DATABASES.first or raise Error, "no connection found in Sequel::DATABASES"
-    end
+  private
 
-    private_class_method :db
+    attr_reader :db
+
+    def first_configured_database
+      Sequel::DATABASES.first or raise Error, "no database found in Sequel::DATABASES"
+    end
 
   end
 end

data/lib/ensql/sql.rb

@@ -95,6 +95,7 @@ module Ensql
     # (see Adapter.fetch_each_row)
     def each_row(&block)
       adapter.fetch_each_row(to_sql, &block)
+      nil
     end
 
     # Interpolate the params into the SQL statement.

data/lib/ensql/version.rb

@@ -2,9 +2,11 @@
 
 module Ensql
   # Gem version
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
   # Versions of activerecord compatible with the {ActiveRecordAdapter}
   SUPPORTED_ACTIVERECORD_VERSIONS = ['>= 5.0', '< 6.2'].freeze
   # Versions of sequel compatible with the {SequelAdapter}
   SUPPORTED_SEQUEL_VERSIONS = '~> 5.9'
+  # Versions of pg compatibile with the {PostgresAdapter}
+  SUPPORTED_PG_VERSIONS = ['>= 0.19', '< 2'].freeze
 end

data/perf/adapter_benchmark.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+#
+# Compare operations performed using each adapter
+#
+
+ENV['TZ'] = 'UTC'
+
+require 'benchmark/ips'
+
+require_relative 'lib/ensql/active_record_adapter'
+require_relative 'lib/ensql/sequel_adapter'
+require_relative 'lib/ensql/postgres_adapter'
+
+ActiveRecord::Base.establish_connection(adapter: "postgresql")
+DB = Sequel.connect("postgresql:/")
+DB.extension(:pg_json)
+
+adapters = {
+  'pg     ': Ensql::PostgresAdapter.new { PG::Connection.open },
+  'ar     ': Ensql::ActiveRecordAdapter.new(ActiveRecord::Base.connection_pool),
+  'seq    ': Ensql::SequelAdapter.new(DB),
+  'pg-ar  ': Ensql::PostgresAdapter.new(Ensql::ActiveRecordAdapter.pool),
+  'pg-seq ': Ensql::PostgresAdapter.new(Ensql::SequelAdapter.pool(DB)),
+}
+
+ADAPTER = adapters.values.first
+
+ADAPTER.run('drop table if exists number_benchmark')
+ADAPTER.run('create table number_benchmark as select generate_series(1,100) as number')
+
+adapter_tests = {
+  'literalize (String)': [:literalize, "It's quoted"],
+  'literalize (Long String)': [:literalize, "It's quoted" * 1000],
+  'literalize (Time)': [:literalize, Time.now],
+  'literalize (Int)': [:literalize, 1234],
+  'literalize (bool)': [:literalize, true],
+  'run INSERT': [:run, 'insert into number_benchmark values (999)'],
+  'run SET': [:run, "set time zone UTC"],
+  'run SELECT': [:run, 'select generate_series(1,100)'],
+  'count UPDATE': [:fetch_count, 'update number_benchmark set number = number + 1'],
+  'count SELECT': [:fetch_count, 'select generate_series(1,100)'],
+  'first column': [:fetch_first_column, 'select generate_series(1,100)'],
+  'first column (of many)': [:fetch_first_column, 'select *, now() from generate_series(1,100) as number'],
+  'first field': [:fetch_first_field, 'select 1'],
+  'first field with cast': [:fetch_first_field, "select cast('2021-01-01' as timestamp)"],
+  'first field (of many)': [:fetch_first_field, 'select generate_series(1,100)'],
+  'first row': [:fetch_first_row, "select 1, 2, 3"],
+  'first row (cast)': [:fetch_first_row, "select cast('2021-01-01' as timestamp), cast('[1,2,3]' as json)"],
+  'first row (of many)': [:fetch_first_row, "select generate_series(1, 100)"],
+  'rows (1)': [:fetch_rows, "select 1, 1"],
+  'rows (100)': [:fetch_rows, "select 1, 1, generate_series(1, 100)"],
+  'rows (100,cast)': [:fetch_rows, "select cast('2021-01-01' as timestamp), cast('[1,2,3]' as json), generate_series(1, 100)"],
+  'rows (100000)': [:fetch_rows, "select 1, 1, generate_series(1, 100000)"],
+}
+
+fetch_each_row_tests = {
+  'each_row (1)': [:fetch_each_row, "select 1, 1" ],
+  'each_row (100)': [:fetch_each_row, "select 1, 1, generate_series(1, 100)"],
+  'each_row (100,cast)': [:fetch_each_row, "select cast('2021-01-01' as timestamp), cast('[1,2,3]' as json), generate_series(1, 100)"],
+  'each_row (100000)': [:fetch_each_row, "select 1, 1, generate_series(1, 100000)"],
+}
+
+# Verify results are the same
+adapter_tests.each do |name, args|
+  results = adapters.map { |n, a| [n, a.send(*args)] }.uniq { |n, result| result }
+  next if results.count == 1
+
+  warn "Differing results for #{name}: #{args}"
+  results.each { |n, result| warn "  #{n} =>  #{result.inspect[0..500]}" }
+end
+
+# Compare times
+adapter_tests.each do |test_name, args|
+  puts args.map { |a| a.inspect[0..100] }.join(' ')
+
+  Benchmark.ips(quiet: true) do |x|
+    x.config(stats: :bootstrap, confidence: 95, warmup: 0.2, time: 0.5)
+
+    adapters.each do |name, adapter|
+      x.report("#{test_name} - #{name}") { adapter.send(*args) }
+    end
+
+    x.compare!
+  end
+end
+
+fetch_each_row_tests.each do |test_name, args|
+  Benchmark.ips(quiet: true) do |x|
+    x.config(stats: :bootstrap, confidence: 95, warmup: 0.2, time: 0.5)
+
+    adapters.each do |name, adapter|
+      x.report("#{test_name} - #{name}") { adapter.send(*args) { |r| r } }
+    end
+
+    x.compare!
+  end
+end
+
+ADAPTER.run('drop table number_benchmark')

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: ensql
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Daniel Fone
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-25 00:00:00.000000000 Z
+date: 2021-03-09 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.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,9 +116,12 @@ files:
 - lib/ensql.rb
 - lib/ensql/active_record_adapter.rb
 - lib/ensql/adapter.rb
+- lib/ensql/pool_wrapper.rb
+- lib/ensql/postgres_adapter.rb
 - lib/ensql/sequel_adapter.rb
 - lib/ensql/sql.rb
 - lib/ensql/version.rb
+- perf/adapter_benchmark.rb
 homepage: https://github.com/danielfone/ensql
 licenses:
 - MIT