simple-sql 0.4.32 → 0.4.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98414c53004214c032d2432a3e17f19ea0c32fa81d1e8ab15cbfb843ec48ec6c
-  data.tar.gz: 0bc1b9bbbdba63fe6a91d750e23f47fd334779c5e6b501ef1f4d60e0131d5073
+  metadata.gz: e64bdc8330b5c64d7e7e17d44a008b0b54e60c9061f524bd1f66ededde5505a4
+  data.tar.gz: 0f07ebf046e8c136126bf5328d46de1dde14e4257389f490acdf4c1746f8cc0b
 SHA512:
-  metadata.gz: c248241ffaa25a7967b2e65f8f4292d0fc64428d24f3526b8dfa5515936b241f4fdc3e48861583697a9a259002590fdfd9eace692d364d8ec2ca1d5f2475f4fa
-  data.tar.gz: b0244677fe2fa04e995a3b7593e341b02018c9d9e197a6783f9c17332fda7821ed770f202ec854f7218ffd6439c6d3200ac0b2a101ed5f03699d3d0f3ee38597
+  metadata.gz: 95c29b91172bfe37d18607199b7ffd103b54b1cfbafe0ba8a5f4bbb3c70b21ec0357a49783dfeab3de9e04eea536a05513e59a5e68d307bcca186fe8671f5ce0
+  data.tar.gz: 9a673939c8ea707d61a8ef105e684996237198f771e8869bfa9b824e6be591e34ef461243f486af278387f7c25ff7ff74ab43c6bbcf69bba03b26d3b51ad12e1

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 $: << "lib"
 require "simple/sql"
-require "simple/store"
+#require "simple/store"
 
 SQL = Simple::SQL
 SQL.connect!

data/lib/simple/sql.rb

@@ -8,7 +8,6 @@ require_relative "sql/helpers"
 require_relative "sql/result"
 require_relative "sql/config"
 require_relative "sql/logging"
-require_relative "sql/simple_transactions"
 require_relative "sql/scope"
 require_relative "sql/connection_adapter"
 require_relative "sql/connection"
@@ -20,78 +19,47 @@ module Simple
   # The Simple::SQL module
   module SQL
     extend self
+
     extend Forwardable
-    delegate [:ask, :all, :each, :exec, :locked, :print] => :connection
-    delegate [:transaction, :wait_for_notify] => :connection
+    delegate [:ask, :all, :each, :exec, :locked, :print, :transaction, :wait_for_notify] => :default_connection
 
     delegate [:logger, :logger=] => ::Simple::SQL::Logging
 
-    private
-
-    def connection
-      connector.call
-    end
-
-    # The connector attribute returns a lambda, which, when called, returns a connection
-    # object.
-    #
-    # If this seems weird: this is for interacting with ActiveRecord. To be in sync how
-    # Rails handles ActiveRecord connections (it checks it out of a connection pool when
-    # needed for the first time in a request cycle, and checks it in afterwards) we need
-    # to make sure not to keep a reference to the actual connection object around. Instead
-    # we need to be able to call a function (in that case ActiveRecord::Base.connection).
-    #
-    # In non-Rails mode the connector really is a lambda which just returns an object.
+    # connects to the database specified via the url parameter. If called
+    # without argument it tries to determine a DATABASE_URL from either the
+    # environment setting (DATABASE_URL) or from a config/database.yml file,
+    # taking into account the RAILS_ENV and RACK_ENV settings.
     #
-    # In any case the connector is stored in a thread-safe fashion. This is not necessary
-    # in Rails mode (because AR::B.connection itself is thread-safe already), but in non-
-    # Rails-mode we make sure to manage one connection per thread.
-    def connector=(connector)
-      Thread.current[:"Simple::SQL.connector"] = connector
+    # Returns the connection object.
+    def connect(database_url = :auto)
+      Connection.create(database_url)
     end
 
-    def connector
-      Thread.current[:"Simple::SQL.connector"] ||= lambda { connect_to_active_record }
-    end
+    # -- default connection ---------------------------------------------------
 
-    def connect_to_active_record
-      return Connection.active_record_connection if defined?(ActiveRecord)
+    DEFAULT_CONNECTION_KEY = :"Simple::SQL.default_connection"
 
-      STDERR.puts <<~SQL
-        Simple::SQL works out of the box with ActiveRecord-based postgres connections, reusing the current connection.
-        To use without ActiveRecord you must connect to a database via Simple::SQL.connect!.
-      SQL
-
-      raise ArgumentError, "simple-sql: missing connection"
+    # returns the default connection.
+    def default_connection
+      Thread.current[DEFAULT_CONNECTION_KEY] ||= connect(:auto)
     end
 
-    public
-
-    # returns a configuration hash, either from the passed in database URL,
-    # from a DATABASE_URL environment value, or from the config/database.yml
-    # file.
-    def configuration(database_url = :auto)
-      database_url = Config.determine_url if database_url == :auto
-      Config.parse_url(database_url)
-    end
-
-    # connects to the database specified via the url parameter. If called
-    # without argument it tries to determine a DATABASE_URL from either the
-    # environment setting (DATABASE_URL) or from a config/database.yml file,
-    # taking into account the RAILS_ENV and RACK_ENV settings.
+    # connects to the database specified via the url parameter, and sets
+    # Simple::SQL's default connection.
+    #
+    # \see connect, default_connection
     def connect!(database_url = :auto)
-      database_url = Config.determine_url if database_url == :auto
-
-      connection = Connection.pg_connection(database_url)
-      self.connector = lambda { connection }
+      disconnect!
+      Thread.current[DEFAULT_CONNECTION_KEY] ||= connect(database_url)
     end
 
-    # disconnects the current connection.
+    # disconnects the current default connection.
     def disconnect!
-      return unless connector
+      connection = Thread.current[DEFAULT_CONNECTION_KEY]
+      return unless connection
 
       connection.disconnect!
-      self.connector = nil
+      Thread.current[DEFAULT_CONNECTION_KEY] = nil
     end
   end
 end

data/lib/simple/sql/config.rb

@@ -39,11 +39,11 @@ module Simple::SQL::Config
     username, password, host, port, database = abc.values_at "username", "password", "host", "port", "database"
 
     URI::Generic.build(
-      scheme: "postgres", 
-      userinfo: [ username, (":" if password), password ].join,
+      scheme: "postgres",
+      userinfo: [username, (":" if password), password].join,
       host: host || "localhost",
       port: port,
-      path: "/#{database}" 
+      path: "/#{database}"
     ).to_s
   end
 

data/lib/simple/sql/connection.rb

@@ -1,69 +1,31 @@
-require "pg"
-
-# private
-module Simple::SQL::Connection
-  Logging = ::Simple::SQL::Logging
-
-  def self.active_record_connection
-    ActiveRecordConnection
-  end
-
-  def self.pg_connection(database_url)
-    config = ::Simple::SQL::Config.parse_url(database_url)
-
-    Logging.info "Connecting to #{database_url}"
-
-    raw_connection = PG::Connection.new(config)
-    raw_connection.set_notice_processor { |message| Logging.info(message) }
-    PgConnection.new(raw_connection)
-  end
-
-  # A PgConnection object is built around a raw connection. It includes
-  # the ConnectionAdapter, which implements ask, all, + friends, and also
-  # includes a quiet simplistic Transaction implementation
-  class PgConnection
-    attr_reader :raw_connection
-
-    def initialize(raw_connection)
-      @raw_connection = raw_connection
-    end
-
-    def disconnect!
-      return unless @raw_connection
-
-      Logging.info "Disconnecting from database"
-      @raw_connection.close
-      @raw_connection = nil
+# A Connection object.
+#
+# A Connection object is built around a raw connection (as created from the pg
+# ruby gem).
+#
+#
+# It includes
+# the ConnectionAdapter, which implements ask, all, + friends, and also
+# includes a quiet simplistic Transaction implementation
+class Simple::SQL::Connection
+  def self.create(database_url = :auto)
+    case database_url
+    when :auto
+      if defined?(::ActiveRecord)
+        ActiveRecordConnection.new
+      else
+        RawConnection.new Simple::SQL::Config.determine_url
+      end
+    else
+      RawConnection.new database_url
     end
-
-    include ::Simple::SQL::ConnectionAdapter          # all, ask, first, etc.
-    include ::Simple::SQL::SimpleTransactions         # transactions
-
-    extend Forwardable
-    delegate [:wait_for_notify] => :raw_connection    # wait_for_notify
   end
 
-  module ActiveRecordConnection
-    extend self
-
-    extend ::Simple::SQL::ConnectionAdapter           # all, ask, first, etc.
-
-    extend Forwardable
-    delegate [:transaction] => :connection            # transactions
-    delegate [:wait_for_notify] => :raw_connection    # wait_for_notify
-
-    def raw_connection
-      ActiveRecord::Base.connection.raw_connection
-    end
+  include Simple::SQL::ConnectionAdapter
 
-    def disconnect!
-      # This doesn't really disconnect. We hope ActiveRecord puts the connection
-      # back into the connection pool instead.
-      @raw_connection = nil
-    end
-
-    def connection
-      ActiveRecord::Base.connection
-    end
-  end
+  extend Forwardable
+  delegate [:wait_for_notify] => :raw_connection
 end
+
+require_relative "connection/raw_connection"
+require_relative "connection/active_record_connection"

data/lib/simple/sql/connection/active_record_connection.rb

@@ -0,0 +1,13 @@
+class Simple::SQL::Connection::ActiveRecordConnection < Simple::SQL::Connection
+  def initialize
+    ::ActiveRecord::Base.connection
+  end
+
+  def raw_connection
+    ::ActiveRecord::Base.connection.raw_connection
+  end
+
+  def transaction(&block)
+    ::ActiveRecord::Base.connection.transaction(&block)
+  end
+end

data/lib/simple/sql/{simple_transactions.rb → connection/raw_connection.rb}

@@ -1,14 +1,32 @@
-# private
-module Simple::SQL::SimpleTransactions
-  def tx_nesting_level
-    @tx_nesting_level ||= 0
+require "pg"
+
+class Simple::SQL::Connection::RawConnection < Simple::SQL::Connection
+  SELF = self
+
+  attr_reader :raw_connection
+
+  def initialize(database_url)
+    @database_url = database_url
+    @raw_connection = PG::Connection.new(@database_url)
+    ObjectSpace.define_finalizer(self, SELF.finalizer(@raw_connection))
+  end
+
+  def self.finalizer(raw_connection)
+    proc do
+      raw_connection.finish unless raw_connection.finished?
+    end
   end
 
-  def tx_nesting_level=(tx_nesting_level)
-    @tx_nesting_level = tx_nesting_level
+  def disconnect!
+    return unless @raw_connection
+
+    @raw_connection.finish unless @raw_connection.finished?
+    @raw_connection = nil
   end
 
   def transaction(&_block)
+    @tx_nesting_level ||= 0
+
     # Notes: by using "ensure" (as opposed to rescue) we are rolling back
     # both when an exception was raised and when a value was thrown. This
     # also means we have to track whether or not to rollback. i.e. do roll
@@ -18,12 +36,12 @@ module Simple::SQL::SimpleTransactions
     # Rolling back from inside a nested transaction would require SAVEPOINT
     # support; without the code is simpler at least :)
 
-    if tx_nesting_level == 0
+    if @tx_nesting_level == 0
       exec "BEGIN"
       tx_started = true
     end
 
-    self.tx_nesting_level += 1
+    @tx_nesting_level += 1
 
     return_value = yield
 
@@ -35,7 +53,7 @@ module Simple::SQL::SimpleTransactions
 
     return_value
   ensure
-    self.tx_nesting_level -= 1
+    @tx_nesting_level -= 1
     if tx_started && !tx_committed
       exec "ROLLBACK"
     end

data/lib/simple/sql/formatting.rb

@@ -16,47 +16,11 @@ module Simple
         sql
       end
 
-      def pretty_format(sql, *args)
-        sql = if use_pg_format?
-                pg_format_sql(sql)
-              else
-                format_sql(sql)
-              end
-
-        args = args.map(&:inspect).join(", ")
-        "#{sql} w/args: #{args}"
-      end
-
       private
 
       def format_sql(sql)
         sql.gsub(/\s*\n\s*/, " ").gsub(/(\A\s+)|(\s+\z)/, "")
       end
-
-      require "open3"
-
-      def use_pg_format?
-        return @use_pg_format unless @use_pg_format.nil?
-
-        `which pg_format`
-        if $?.exitstatus == 0
-          @use_pg_format = true
-        else
-          Simple::SQL.logger.warn "[sql] simple-sql can use pg_format for logging queries. Please see https://github.com/darold/pgFormatter"
-          @use_pg_format = false
-        end
-      end
-
-      PG_FORMAT_ARGS = "--function-case 2 --maxlength 15000 --nocomment --spaces 2 --keyword-case 2 --no-comma-end"
-
-      def pg_format_sql(sql)
-        stdin, stdout, _ = Open3.popen2("pg_format #{PG_FORMAT_ARGS} -")
-        stdin.print sql
-        stdin.close
-        formatted = stdout.read
-        stdout.close
-        formatted
-      end
     end
   end
 end

data/lib/simple/sql/logging.rb

@@ -87,8 +87,8 @@ module Simple
         return if sql =~ /^EXPLAIN /
 
         log_multiple_lines ::Logger::WARN, prefix: "[sql-slow]" do
-          formatted_query = Formatting.pretty_format(sql, *args)
-          query_plan = ::Simple::SQL.all "EXPLAIN ANALYZE #{sql}", *args
+          formatted_query = Formatting.format(sql, *args)
+          query_plan = ::Simple::SQL.all "EXPLAIN #{sql}", *args
 
           <<~MSG
             === slow query detected: (#{'%.3f secs' % runtime}) ===================================================================================

data/lib/simple/sql/result.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Metrics/AbcSize
 # rubocop:disable Naming/AccessorMethodName
 
 require_relative "helpers"
@@ -31,21 +30,54 @@ class ::Simple::SQL::Result < Array
     replace(records)
   end
 
+  # returns a fast estimate for the total_count of search hits
+  #
+  # This is filled in when resolving a paginated scope.
+  def total_count_estimate
+    @total_count_estimate ||= catch(:total_count_estimate) do
+      scope = @pagination_scope
+      scope_sql = scope.order_by(nil).to_sql(pagination: false)
+      ::Simple::SQL.each("EXPLAIN #{scope_sql}", *scope.args) do |line|
+        next unless line =~ /\brows=(\d+)/
+
+        throw :total_count_estimate, Integer($1)
+      end
+      -1
+    end
+  end
+
+  # returns the estimated total number of pages of search hits
+  #
+  # This is filled in when resolving a paginated scope.
+  def total_pages_estimate
+    @total_pages_estimate ||= (total_count_estimate * 1.0 / @pagination_scope.per).ceil
+  end
+
   # returns the total_count of search hits
   #
   # This is filled in when resolving a paginated scope.
-  attr_reader :total_count
+  def total_count
+    @total_count ||= begin
+      scope = @pagination_scope
+      scope_sql = scope.order_by(nil).to_sql(pagination: false)
+      ::Simple::SQL.ask("SELECT COUNT(*) FROM (#{scope_sql}) simple_sql_count", *scope.args)
+    end
+  end
 
   # returns the total number of pages of search hits
   #
   # This is filled in when resolving a paginated scope. It takes
   # into account the scope's "per" option.
-  attr_reader :total_pages
+  def total_pages
+    @total_pages ||= (total_count * 1.0 / @pagination_scope.per).ceil
+  end
 
   # returns the current page number in a paginated search
   #
   # This is filled in when resolving a paginated scope.
-  attr_reader :current_page
+  def current_page
+    @current_page ||= @pagination_scope.page
+  end
 
   private
 
@@ -56,14 +88,13 @@ class ::Simple::SQL::Result < Array
       # This branch is an optimization: the call to the database to count is
       # not necessary if we know that there are not even any results on the
       # first page.
-      @total_count  = 0
       @current_page = 1
+      @total_count  = 0
+      @total_pages  = 1
+      @total_count_estimate  = 0
+      @total_pages_estimate  = 1
     else
-      sql = "SELECT COUNT(*) FROM (#{scope.order_by(nil).to_sql(pagination: false)}) simple_sql_count"
-      @total_count = ::Simple::SQL.ask(sql, *scope.args)
-      @current_page = scope.page
+      @pagination_scope = scope
     end
-
-    @total_pages = (@total_count * 1.0 / scope.per).ceil
   end
 end

data/lib/simple/sql/scope.rb

@@ -24,11 +24,11 @@ class Simple::SQL::Scope
   #
   #     Simple::SQL::Scope.new(table: "mytable", select: "*", where: { id: 1, foo: "bar" }, order_by: "id desc")
   #
-  def initialize(sql)
+  def initialize(sql, args = [])
     expect! sql => [String, Hash]
 
     @sql     = nil
-    @args    = []
+    @args    = args
     @filters = []
 
     case sql

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.32"
+    VERSION = "0.4.35"
   end
 end

data/spec/support/004_simplecov.rb

@@ -4,10 +4,18 @@ require "simplecov"
 # care of merging these results automatically.
 SimpleCov.command_name "test:#{ENV['USE_ACTIVE_RECORD']}"
 
+USE_ACTIVE_RECORD = ENV["USE_ACTIVE_RECORD"] == "1"
+
 SimpleCov.start do
   # return true to remove src from coverage 
   add_filter do |src|
-    src.filename =~ /\/spec\//
+    next true if src.filename =~ /\/spec\//
+    next true if src.filename =~ /\/immutable\.rb/
+
+    next true if USE_ACTIVE_RECORD  && src.filename =~ /\/sql\/connection\/raw_connection\.rb/
+    next true if !USE_ACTIVE_RECORD && src.filename =~ /\/sql\/connection\/active_record_connection\.rb/
+
+    false
   end
 
   minimum_coverage 90

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.32
+  version: 0.4.35
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-22 00:00:00.000000000 Z
+date: 2019-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -201,6 +201,8 @@ files:
 - lib/simple/sql.rb
 - lib/simple/sql/config.rb
 - lib/simple/sql/connection.rb
+- lib/simple/sql/connection/active_record_connection.rb
+- lib/simple/sql/connection/raw_connection.rb
 - lib/simple/sql/connection_adapter.rb
 - lib/simple/sql/duplicate.rb
 - lib/simple/sql/formatting.rb
@@ -219,7 +221,6 @@ files:
 - lib/simple/sql/scope/filters.rb
 - lib/simple/sql/scope/order.rb
 - lib/simple/sql/scope/pagination.rb
-- lib/simple/sql/simple_transactions.rb
 - lib/simple/sql/version.rb
 - log/.gitkeep
 - scripts/stats
@@ -266,7 +267,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: SQL with a simple interface