simple-sql 0.5.18 → 0.5.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 539c668c59391992ee22ef86ddc7c6d9a20030cbbcf473ddba4d4c8eccdf2a4f
-  data.tar.gz: 28ab53f413beff60ad5bf3ab55769c5fb526ace82419e2bd695bc4cbd81bba82
+  metadata.gz: 8f07bda4a766c4847fdb1b6ff5b2ffbb46aadf64e57ae72ae0e033027aba2d13
+  data.tar.gz: 8637da9a4e8de6f7a57c8003db0fb27e0d479005730e88e14476f3c5e7edc6ca
 SHA512:
-  metadata.gz: d518fb85eeb923e61f75d4d51a52330e2a22cbf730a51238d0f7df389903cea13aad48a1c49b52fb54d2b083b300637aea282a3ca77f902d28845a0e1d3d28cd
-  data.tar.gz: 4e18e1e40a62e1b2b4231ddb342a978b7d04df7deddfa9f410d81ab14d0c30a548b3976b8b1e25f04b984f8e0123c33eec9fc9ccedab512c76db4934b5af86fd
+  metadata.gz: 35b8dec9461128d4c1250c6ab3451431aa6defc442afb03cbbeb2fdb5247b9b4258aebcfb86014cf4d6bcad8313320ae028d6d65519a66cddd3dbb35524feb9c
+  data.tar.gz: b087a97ff95ec6f848bde598625ceaf4fd3864cfb3e37a17d7001edab4eabaffcaf5b124e7b401108fbd5622f25bc02eb019bb428d071f7d4bcbb37345cc1cb4

data/lib/simple/sql.rb

@@ -59,11 +59,9 @@ module Simple
 
     # -- default connection ---------------------------------------------------
 
-    DEFAULT_CONNECTION_KEY = :"Simple::SQL.default_connection"
-
     # returns the default connection.
     def default_connection
-      Thread.current[DEFAULT_CONNECTION_KEY] ||= connect(:auto)
+      @default_connection ||= connect(:auto)
     end
 
     # connects to the database specified via the url parameter, and sets
@@ -72,16 +70,13 @@ module Simple
     # \see connect, default_connection
     def connect!(database_url = :auto)
       disconnect!
-      Thread.current[DEFAULT_CONNECTION_KEY] ||= connect(database_url)
+      @default_connection = connect(database_url)
     end
 
     # disconnects the current default connection.
     def disconnect!
-      connection = Thread.current[DEFAULT_CONNECTION_KEY]
-      return unless connection
-
-      connection.disconnect!
-      Thread.current[DEFAULT_CONNECTION_KEY] = nil
+      ::Simple::SQL::ConnectionManager.disconnect_all!
+      @default_connection = nil
     end
   end
 end

data/lib/simple/sql/connection.rb

@@ -4,6 +4,8 @@ end
 require "pg"
 require "active_record"
 
+require_relative "connection_manager"
+
 require_relative "connection/base"
 require_relative "connection/lock"
 require_relative "connection/scope"
@@ -17,80 +19,49 @@ require_relative "connection/type_info"
 # It Method.includes the ConnectionAdapter, which implements ask, all, + friends
 #
 class Simple::SQL::Connection
+  ConnectionManager = ::Simple::SQL::ConnectionManager
+
   def self.create(database_url = :auto)
-    case database_url
-    when nil    then DefaultConnection.new
-    when String then ExplicitConnection.new(database_url)
-    when :auto
-      if ::ActiveRecord::Base.connected?
-        DefaultConnection.new
-      else
-        ExplicitConnection.new(::Simple::SQL::Config.determine_url)
-      end
+    expect! database_url => [nil, :auto, String]
+    new connection_class(database_url)
+  end
+
+  def self.connection_class(database_url)
+    if database_url.nil?
+      ::ActiveRecord::Base
+    elsif database_url.is_a?(String)
+      ConnectionManager.connection_class(database_url)
+    elsif ::ActiveRecord::Base.connected?
+      # database_url is :auto, and we are connected. This happens, for example,
+      # within a rails controller. IT IS IMPORTANT NOT TO CONNECT AGAINST THE
+      # ::Simple::SQL::Config.determine_url! Only so we can make sure that
+      # simple-sql and ActiveRecord can be mixed freely together, i.e. they are
+      # sharing the same connection.
+      ::ActiveRecord::Base
     else
-      expect! database_url => [nil, :auto, String]
+      ConnectionManager.connection_class(::Simple::SQL::Config.determine_url)
     end
   end
 
-  def initialize(active_record_class)
-    @active_record_class = active_record_class
+  def initialize(connection_class)
+    @connection_class = connection_class
   end
 
   def raw_connection
-    @active_record_class.connection.raw_connection
+    @connection_class.connection.raw_connection
   end
 
   def transaction(&block)
-    @active_record_class.connection.transaction(&block)
+    @connection_class.connection.transaction(&block)
   end
 
-  extend Forwardable
-  delegate [:wait_for_notify] => :raw_connection
-
-  # -- specific connection classes --------------------------------------------
-
-  class DefaultConnection < self
-    def initialize
-      @active_record_class = ::ActiveRecord::Base
-    end
-
-    def disconnect!; end
+  def disconnect!
+    return unless @connection_class && @connection_class != ::ActiveRecord::Base
+    @connection_class.remove_connection
   end
 
-  class ExplicitConnection < self
-    def initialize(url)
-      super create_active_record_class(url)
-    end
-
-    def disconnect!
-      return unless @active_record_class
-
-      @active_record_class.remove_connection
-    end
-
-    private
-
-    # ActiveRecord needs a class name in order to connect.
-    module WritableClassName
-      attr_accessor :name
-    end
-
-    # create_active_record_class builds a ActiveRecord::Base class, whose
-    # ConnectionPool we are going to use for this connection.
-    def create_active_record_class(url)
-      Class.new(ActiveRecord::Base).tap do |klass|
-        klass.extend WritableClassName
-        klass.name = "Simple::SQL::Connection::ExplicitConnection::Adapter"
-        klass.establish_connection url
-
-        connection_pool = klass.connection_pool
-        connection_pool_stats = {
-          size: connection_pool.size,
-          automatic_reconnect: connection_pool.automatic_reconnect,
-          checkout_timeout: connection_pool.checkout_timeout
-        }
-        ::Simple::SQL.logger.info "#{url}: connected to connection pool w/#{connection_pool_stats.inspect}"
-      end
-    end
-  end
+  extend Forwardable
+  delegate [:wait_for_notify] => :raw_connection
 end
+
+# TODO disconnect! reconnect!

data/lib/simple/sql/connection_manager.rb

@@ -0,0 +1,50 @@
+# The ConnectionManager manages a pool of ActiveRecord::Base classes.
+#
+# ActiveRecord assigns a connection_pool to a class. If you want to connect to
+# multiple detabases you must inherit from ActiveRecord::Base. This is what
+# we do dynamically in this ConnectionManager.
+#
+# Note that connections to the same database are always shared within a single
+# ConnectionPool.
+module Simple::SQL
+  module ConnectionManager
+    extend self
+
+    def disconnect_all!
+      ActiveRecord::Base.connection_pool.disconnect!
+      connection_classes.values.map(&:connection_pool).each(&:disconnect!)
+      connection_classes.clear
+    end
+
+    def connection_class(url)
+      connection_classes[url] ||= create_connection_class(url)
+    end
+
+    private
+
+    def connection_classes
+      @connection_classes ||= {}
+    end
+
+    # ActiveRecord needs a class name in order to connect.
+    module WritableClassName
+      attr_accessor :name
+    end
+
+    def create_connection_class(url)
+      Class.new(ActiveRecord::Base).tap do |klass|
+        klass.extend WritableClassName
+        klass.name = "Simple::SQL::Connection::ExplicitConnection::Adapter/#{url}"
+
+        klass.establish_connection url
+        connection_pool = klass.connection_pool
+        connection_pool_stats = {
+          size: connection_pool.size,
+          automatic_reconnect: connection_pool.automatic_reconnect,
+          checkout_timeout: connection_pool.checkout_timeout
+        }
+        ::Simple::SQL.logger.info "#{url}: connected to connection pool w/#{connection_pool_stats.inspect}"
+      end
+    end
+  end
+end

data/lib/simple/sql/logging.rb

@@ -24,12 +24,7 @@ module Simple
 
       def default_logger
         # return the ActiveRecord logger, if it exists.
-        if defined?(ActiveRecord)
-          logger = ActiveRecord::Base.logger
-          return logger if logger
-        end
-
-        stderr_logger
+        ::ActiveRecord::Base.logger || stderr_logger
       end
 
       def stderr_logger

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.5.18"
+    VERSION = "0.5.19"
   end
 end

data/spec/simple/sql/connect_spec.rb

@@ -1,78 +1,66 @@
 require "spec_helper"
 
-describe "Simple::SQL.connect" do
-  let!(:default_pg_backend_pid) { Simple::SQL.ask "SELECT pg_backend_pid()" }
-
-  def connection_count(db: nil)
-    db ||= ::Simple::SQL
-    db.ask("SELECT sum(numbackends) FROM pg_stat_database")
-  end
-  
-  context 'without an argument' do
-    let(:params) { [] }
-
-    it 'is reusing the existing ActiveRecord connection' do
-      Simple::SQL.with_connection(*params) do |db|
-        expect(default_pg_backend_pid).to eq(db.ask("SELECT pg_backend_pid()"))
-        expect(db).not_to be_a(Simple::SQL::Connection::ExplicitConnection)
-      end
+describe "Connections" do
+  describe "Simple::SQL.connect" do
+    before do
+      org = create(:organization)
+      2.times { create(:user, organization_id: org.id) }
+    end
 
-      expect(::Simple::SQL.ask("SELECT sum(numbackends) FROM pg_stat_database")).to eq(1)
+    after do
+      expect(User.count).to eq(2)
     end
 
-    it 'is not estabishing a new connection' do
-      initial_connection_count = connection_count
+    describe 'automatic connections' do
+      let(:db) { Simple::SQL.connect }
 
-      Simple::SQL.with_connection(*params) do |db|
-        db.ask("SELECT 1")
-        expect(connection_count).to eq(initial_connection_count)
-      end
+      it 'can mix Simple::SQL inside ActiveRecord' do
+        User.transaction do
+          User.delete_all
+          expect(db.ask("SELECT count(*) FROM users")).to eq(0)
 
-      expect(connection_count).to eq(initial_connection_count)
-    end
-  end
+          raise ActiveRecord::Rollback
+        end
+
+        db.transaction do
+          db.ask("DELETE FROM users")
 
-  context 'with an :auto argument' do
-    let(:params) { [:auto] }
+          expect(User.count).to eq(0)
 
-    it 'is reusing the existing ActiveRecord connection' do
-      Simple::SQL.with_connection(*params) do |db|
-        expect(default_pg_backend_pid).to eq(db.ask("SELECT pg_backend_pid()"))
-        expect(db).not_to be_a(Simple::SQL::Connection::ExplicitConnection)
+          raise ActiveRecord::Rollback
+        end
       end
     end
 
-    it 'is not estabishing a new connection' do
-      initial_connection_count = connection_count
+    describe 'explizit connections' do
+      let(:db) { Simple::SQL.connect(::Simple::SQL::Config.determine_url) }
 
-      Simple::SQL.with_connection(*params) do |db|
-        db.ask("SELECT 1")
-        expect(connection_count).to eq(initial_connection_count)
-      end
+      it 'runs in separate transactions' do
+        User.transaction do
+          User.delete_all
+          expect(db.ask("SELECT count(*) FROM users")).to eq(2)
 
-      expect(connection_count).to eq(initial_connection_count)
-    end
-  end
+          raise ActiveRecord::Rollback
+        end
+
+        db.transaction do
+          db.ask("DELETE FROM users")
 
-  context 'with an explicit URL' do
-    let(:params) { [Simple::SQL::Config.determine_url] }
+          expect(User.count).to eq(2)
 
-    it 'is reconnecting using the passed in URL' do
-      Simple::SQL.with_connection(*params) do |db|
-        expect(default_pg_backend_pid).not_to eq(db.ask("SELECT pg_backend_pid()"))
-        expect(db).to be_a(Simple::SQL::Connection::ExplicitConnection)
+          raise ActiveRecord::Rollback
+        end
       end
     end
+  end
 
-    it 'is estabishing a new connection' do
-      initial_connection_count = connection_count
-
-      Simple::SQL.with_connection(*params) do |db|
-        db.ask("SELECT 1")
-        expect(connection_count).to be > initial_connection_count
-      end
+  describe "Simple::SQL.disconnect!" do
+    let(:default_db) { Simple::SQL.connect }
+    let(:db) { Simple::SQL.connect(::Simple::SQL::Config.determine_url) }
 
-      expect(connection_count).to eq(initial_connection_count)
+    it 'disconnects everything' do
+      Simple::SQL.disconnect!
+      expect(ActiveRecord::Base.connection_pool.connections.length).to eq(0)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.5.18
+  version: 0.5.19
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-06 00:00:00.000000000 Z
+date: 2019-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -203,6 +203,7 @@ files:
 - lib/simple/sql/connection/scope/pagination.rb
 - lib/simple/sql/connection/scope/shorthand.rb
 - lib/simple/sql/connection/type_info.rb
+- lib/simple/sql/connection_manager.rb
 - lib/simple/sql/formatting.rb
 - lib/simple/sql/fragment.rb
 - lib/simple/sql/helpers.rb
@@ -268,7 +269,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: SQL with a simple interface