simple-sql 0.5.4 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2b88507a234e3a0521bb5108ba36c638dc4efc84cf0d5983e7624a1486f0d78
-  data.tar.gz: e7c41f2e6fde85e100507e340c2e0c3891839f285a0ff6815ee21628c5ac0296
+  metadata.gz: ddf6a7cc39facc48d8f9ec3f14d94dc614261d23617f44ea2b604f06b94ae90b
+  data.tar.gz: f8eb847b80866ae0001c2517e11764a86f12bd6f4b0a3a33f489b37a78919484
 SHA512:
-  metadata.gz: 72eee863bf1e719e7ca2c969ba59af45ff916472a5840510a1bdbd175f181e5dd2d0eaa503df024a213c0efab5eb26f438ad6a0f312aac852f7e01ba39e7e177
-  data.tar.gz: 1bc3911e538addf0cf98312fe017e41ffe82098bd456009641a71ee5cfdc30cb8db0bbca3e8685ac29fbd1e4af511d974b7f6e96e9163b16a7ea2019cddeed56
+  metadata.gz: 4632a04f05ff2d698b3c925ef63a2267b6bd0d57145d94b94a2010d439193fb1e9ab8eeaa0dd55d1b2bc3b74a2398117fb2648058eda3470d96b27b9cf7ac203
+  data.tar.gz: 67262d0c42c46142d919455fecafc4f3a24a0a375008d1d6f318934ce876e7ecdedaf29c5c6c87757d06fcb0a0467bd2f93cc5cdc4882af4ed0955ece13fcb95

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/scope"
 require_relative "sql/connection_adapter"
 require_relative "sql/connection"
 
@@ -22,6 +21,7 @@ module Simple
     delegate [:reflection] => :default_connection
     delegate [:duplicate] => :default_connection
     delegate [:insert] => :default_connection
+    delegate [:scope] => :default_connection
 
     delegate [:logger, :logger=] => ::Simple::SQL::Logging
 

data/lib/simple/sql/connection.rb

@@ -4,6 +4,7 @@ end
 require_relative "connection/raw_connection"
 require_relative "connection/active_record_connection"
 
+require_relative "connection/scope"
 require_relative "connection/reflection"
 require_relative "connection/insert"
 require_relative "connection/duplicate"

data/lib/simple/sql/{scope.rb → connection/scope.rb}

@@ -6,29 +6,38 @@ require_relative "scope/pagination.rb"
 require_relative "scope/count.rb"
 require_relative "scope/count_by_groups.rb"
 
-# The Simple::SQL::Scope class helps building scopes; i.e. objects
-# that start as a quite basic SQL query, and allow one to add
-# sql_fragments as where conditions.
-class Simple::SQL::Scope
-  SELF = self
-
-  attr_reader :args
-  attr_reader :per, :page
-
+class Simple::SQL::Connection
   # Build a scope object
   #
   # This call supports a few variants:
   #
-  #     Simple::SQL::Scope.new("SELECT * FROM mytable")
-  #     Simple::SQL::Scope.new(table: "mytable", select: "*")
+  #     Simple::SQL.scope("SELECT * FROM mytable")
+  #     Simple::SQL.scope(table: "mytable", select: "*")
   #
   # The second option also allows one to pass in more options, like the following:
   #
-  #     Simple::SQL::Scope.new(table: "mytable", select: "*", where: { id: 1, foo: "bar" }, order_by: "id desc")
+  #     Simple::SQL.scope(table: "mytable", select: "*", where: { id: 1, foo: "bar" }, order_by: "id desc")
   #
-  def initialize(sql, args = [])
+  def scope(sql, args = [])
+    ::Simple::SQL::Connection::Scope.new sql, args, connection: self
+  end
+end
+
+# The Simple::SQL::Connection::Scope class helps building scopes; i.e. objects
+# that start as a quite basic SQL query, and allow one to add
+# sql_fragments as where conditions.
+class Simple::SQL::Connection::Scope
+  SELF = self
+
+  attr_reader :connection
+  attr_reader :args
+  attr_reader :per, :page
+
+  def initialize(sql, args = [], connection:) # :nodoc:
     expect! sql => [String, Hash]
 
+    @connection = connection
+
     @sql     = nil
     @args    = args
     @filters = []
@@ -62,7 +71,7 @@ class Simple::SQL::Scope
   end
 
   def duplicate
-    dupe = SELF.new(@sql)
+    dupe = SELF.new(@sql, connection: @connection)
     dupe.instance_variable_set :@args, @args.dup
     dupe.instance_variable_set :@filters, @filters.dup
     dupe.instance_variable_set :@per, @per

data/lib/simple/sql/connection/scope/count.rb

@@ -0,0 +1,35 @@
+class Simple::SQL::Connection::Scope
+  EXACT_COUNT_THRESHOLD = 10_000
+
+  # Returns the exact count of matching records
+  def count
+    sql = order_by(nil).to_sql(pagination: false)
+
+    @connection.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
+  end
+
+  # Returns the fast count of matching records
+  #
+  # For counts larger than EXACT_COUNT_THRESHOLD this returns an estimate
+  def fast_count
+    estimate = estimated_count
+    return estimate if estimate > EXACT_COUNT_THRESHOLD
+
+    sql = order_by(nil).to_sql(pagination: false)
+    @connection.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
+  end
+
+  private
+
+  def estimated_count
+    sql = order_by(nil).to_sql(pagination: false)
+    lines = @connection.all("EXPLAIN #{sql}", *args)
+    lines.each do |line|
+      next unless line =~ /\brows=(\d+)/
+
+      return Integer($1)
+    end
+
+    -1
+  end
+end

data/lib/simple/sql/{scope → connection/scope}/count_by_groups.rb

@@ -1,7 +1,7 @@
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/MethodLength
 
-class Simple::SQL::Scope
+class Simple::SQL::Connection::Scope
   # Potentially fast implementation of returning all different values for a specific group.
   #
   # For example:
@@ -20,16 +20,16 @@ class Simple::SQL::Scope
   def enumerate_groups(sql_fragment)
     sql = order_by(nil).to_sql(pagination: false)
 
-    _, max_cost = ::Simple::SQL.costs "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
+    _, max_cost = @connection.costs "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
     raise "enumerate_groups: takes too much time. Make sure to create a suitable index" if max_cost > 10_000
 
     groups = []
     var_name = "$#{@args.count + 1}"
-    cur = ::Simple::SQL.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
+    cur = @connection.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq", *args
 
     while cur
       groups << cur
-      cur = ::Simple::SQL.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq"" WHERE #{sql_fragment} > #{var_name}", *args, cur
+      cur = @connection.ask "SELECT MIN(#{sql_fragment}) FROM (#{sql}) sq"" WHERE #{sql_fragment} > #{var_name}", *args, cur
     end
 
     groups
@@ -38,14 +38,14 @@ class Simple::SQL::Scope
   def count_by(sql_fragment)
     sql = order_by(nil).to_sql(pagination: false)
 
-    recs = ::Simple::SQL.all "SELECT #{sql_fragment} AS group, COUNT(*) AS count FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
+    recs = @connection.all "SELECT #{sql_fragment} AS group, COUNT(*) AS count FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
     Hash[recs]
   end
 
   def fast_count_by(sql_fragment)
     sql = order_by(nil).to_sql(pagination: false)
 
-    _, max_cost = ::Simple::SQL.costs "SELECT COUNT(*) FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
+    _, max_cost = @connection.costs "SELECT COUNT(*) FROM (#{sql}) sq GROUP BY #{sql_fragment}", *args
 
     return count_by(sql_fragment) if max_cost < 10_000
 
@@ -57,14 +57,14 @@ class Simple::SQL::Scope
     counts = {}
     sparse_groups = []
     enumerate_groups(sql_fragment).each do |group|
-      scope = ::Simple::SQL::Scope.new("SELECT * FROM (#{sql}) sq WHERE #{sql_fragment}=#{var_name}", *args, group)
+      scope = @connection.scope("SELECT * FROM (#{sql}) sq WHERE #{sql_fragment}=#{var_name}", *args, group)
       counts[group] = scope.send(:estimated_count)
       sparse_groups << group if estimated_count < EXACT_COUNT_THRESHOLD
     end
 
     # fetch exact counts in all sparse_groups
     unless sparse_groups.empty?
-      sparse_counts = ::Simple::SQL.all <<~SQL, *args, sparse_groups
+      sparse_counts = @connection.all <<~SQL, *args, sparse_groups
         SELECT #{sql_fragment} AS group, COUNT(*) AS count
         FROM (#{sql}) sq
         WHERE #{sql_fragment} = ANY(#{var_name})

data/lib/simple/sql/{scope → connection/scope}/filters.rb

@@ -1,6 +1,6 @@
 # rubocop:disable Style/GuardClause
 
-class Simple::SQL::Scope
+class Simple::SQL::Connection::Scope
   # scope = Scope.new("SELECT * FROM tablename")
   # scope = scope.where(id: 12)
   # scope = scope.where("id > ?", 12)

data/lib/simple/sql/{scope → connection/scope}/order.rb

@@ -1,4 +1,4 @@
-class Simple::SQL::Scope
+class Simple::SQL::Connection::Scope
   def order_by(sql_fragment)
     duplicate.send(:order_by!, sql_fragment)
   end

data/lib/simple/sql/{scope → connection/scope}/pagination.rb

@@ -1,6 +1,6 @@
 # rubocop:disable Style/Not
 
-class Simple::SQL::Scope
+class Simple::SQL::Connection::Scope
   # Set pagination
   def paginate(per:, page:)
     duplicate.send(:paginate!, per: per, page: page)

data/lib/simple/sql/connection_adapter.rb

@@ -6,7 +6,6 @@
 
 module Simple::SQL::ConnectionAdapter
   Logging = ::Simple::SQL::Logging
-  Scope   = ::Simple::SQL::Scope
 
   # execute one or more sql statements. This method does not allow to pass in
   # arguments - since the pg client does not support this - but it allows to
@@ -47,7 +46,7 @@ module Simple::SQL::ConnectionAdapter
     # [TODO] - resolve associations. Note that this is only possible if the type
     # is not an Array (i.e. into is nil)
 
-    if sql.is_a?(Scope) && sql.paginated?
+    if sql.is_a?(::Simple::SQL::Connection::Scope) && sql.paginated?
       record_set.send(:set_pagination_info, sql)
     end
 
@@ -120,8 +119,9 @@ module Simple::SQL::ConnectionAdapter
   Encoder = ::Simple::SQL::Helpers::Encoder
 
   def exec_logged(sql_or_scope, *args)
-    if sql_or_scope.is_a?(Scope)
+    if sql_or_scope.is_a?(::Simple::SQL::Connection::Scope)
       raise ArgumentError, "You cannot call .all with a scope and additional arguments" unless args.empty?
+      raise ArgumentError, "You cannot execute a scope on a different connection" unless self == sql_or_scope.connection
 
       sql  = sql_or_scope.to_sql
       args = sql_or_scope.args

data/lib/simple/sql/result/association_loader.rb

@@ -86,16 +86,16 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
   end
 
   # preloads a belongs_to association.
-  def preload_belongs_to(records, relation, as:)
+  def preload_belongs_to(connection, records, relation, as:)
     belonging_column = relation.belonging_column.to_sym
     having_column = relation.having_column.to_sym
 
     foreign_ids = H.pluck(records, belonging_column).uniq.compact
 
-    scope = SQL::Scope.new(table: relation.having_table)
+    scope = connection.scope(table: relation.having_table)
     scope = scope.where(having_column => foreign_ids)
 
-    recs = SQL.all(scope, into: Hash)
+    recs = connection.all(scope, into: Hash)
     recs_by_id = H.by_key(recs, having_column)
 
     records.each do |model|
@@ -104,7 +104,7 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
   end
 
   # preloads a has_one or has_many association.
-  def preload_has_one_or_many(records, relation, as:, order_by:, limit:)
+  def preload_has_one_or_many(connection, records, relation, as:, order_by:, limit:)
     # To really make sense limit must be implemented using window
     # functions, because one (or, at lieast, I) would expect this code
     #
@@ -121,7 +121,7 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
 
     host_ids  = H.pluck(records, having_column).uniq.compact
 
-    scope     = SQL::Scope.new(table: relation.belonging_table)
+    scope     = connection.scope(table: relation.belonging_table)
     scope     = scope.where(belonging_column => host_ids)
     scope     = scope.order_by(order_by) if order_by
 
@@ -165,9 +165,9 @@ module ::Simple::SQL::Result::AssociationLoader # :nodoc:
         raise ArgumentError, "#{association.inspect} is a singular association, w/o support for order_by: and limit:"
       end
 
-      preload_belongs_to records, relation, as: as
+      preload_belongs_to connection, records, relation, as: as
     else
-      preload_has_one_or_many records, relation, as: as, order_by: order_by, limit: limit
+      preload_has_one_or_many connection, records, relation, as: as, order_by: order_by, limit: limit
     end
   end
 end

data/lib/simple/sql/scope/count.rb

@@ -1,10 +1,11 @@
-class Simple::SQL::Scope
+class Simple::SQL::Connection::Scope
   EXACT_COUNT_THRESHOLD = 10_000
 
   # Returns the exact count of matching records
   def count
     sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
+
+    @connection.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
   end
 
   # Returns the fast count of matching records
@@ -15,14 +16,15 @@ class Simple::SQL::Scope
     return estimate if estimate > EXACT_COUNT_THRESHOLD
 
     sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
+    @connection.ask("SELECT COUNT(*) FROM (#{sql}) _total_count", *args)
   end
 
   private
 
   def estimated_count
     sql = order_by(nil).to_sql(pagination: false)
-    ::Simple::SQL.each("EXPLAIN #{sql}", *args) do |line|
+    lines = @connection.all("EXPLAIN #{sql}", *args)
+    lines.each do |line|
       next unless line =~ /\brows=(\d+)/
 
       return Integer($1)

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.5.4"
+    VERSION = "0.5.5"
   end
 end

data/spec/simple/sql/count_by_groups_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
 
-describe "Simple::SQL::Scope#count_by" do
+describe "Simple::SQL::Connection::Scope#count_by" do
   let!(:users)        { 1.upto(10).map { |i| create(:user, role_id: i) } }
   let(:all_role_ids)  { SQL.all("SELECT DISTINCT role_id FROM users") }
-  let(:scope)         { SQL::Scope.new("SELECT * FROM users") }
+  let(:scope)         { SQL.scope("SELECT * FROM users") }
 
   describe "enumerate_groups" do
     it "returns all groups" do

data/spec/simple/sql/count_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
 
-describe "Simple::SQL::Scope#count" do
+describe "Simple::SQL::Connection::Scope#count" do
   let!(:users)      { 1.upto(USER_COUNT).map { create(:user) } }
   let(:min_user_id) { SQL.ask "SELECT min(id) FROM users" }
-  let(:scope)       { SQL::Scope.new("SELECT * FROM users") }
+  let(:scope)       { SQL.scope("SELECT * FROM users") }
 
   describe "exact count" do
     it "counts" do

data/spec/simple/sql/result_count_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe "Simple::SQL::Result counts" do
   let!(:users)          { 1.upto(USER_COUNT).map { create(:user) } }
   let(:min_user_id)     { SQL.ask "SELECT min(id) FROM users" }
-  let(:scope)           { SQL::Scope.new("SELECT * FROM users") }
+  let(:scope)           { SQL.scope("SELECT * FROM users") }
   let(:paginated_scope) { scope.paginate(per: 1, page: 1) }
 
   describe "exact counting" do
@@ -39,7 +39,7 @@ describe "Simple::SQL::Result counts" do
 
 
   context 'when running with an empty, paginated paginated_scope' do
-    let(:scope)           { SQL::Scope.new("SELECT * FROM users WHERE FALSE") }
+    let(:scope)           { SQL.scope("SELECT * FROM users WHERE FALSE") }
     let(:paginated_scope) { scope.paginate(per: 1, page: 1) }
 
     it "returns correct results" do

data/spec/simple/sql/scope_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe "Simple::SQL::Scope" do
+describe "Simple::SQL::Connection::Scope" do
   def expects(expected_result, sql, *args)
     expect(SQL.ask(sql, *args)).to eq(expected_result)
   end
@@ -10,13 +10,13 @@ describe "Simple::SQL::Scope" do
   end
 
   it 'allows chaining of scopes' do
-    scope1 = SQL::Scope.new "SELECT 1, 2 FROM users"
+    scope1 = SQL.scope "SELECT 1, 2 FROM users"
     scope2 = scope1.where("FALSE")
     expect(scope1.to_sql).not_to eq(scope2.to_sql)
   end
 
   context "without conditions" do
-    let(:scope) { SQL::Scope.new "SELECT 1, 2 FROM users" }
+    let(:scope) { SQL.scope "SELECT 1, 2 FROM users" }
 
     it "runs with SQL.ask" do
       expect(SQL.ask(scope)).to eq([1, 2])
@@ -29,7 +29,7 @@ describe "Simple::SQL::Scope" do
 
   context "with hash conditions" do
     let(:user_id) { SQL.ask "SELECT id FROM users LIMIT 1" }
-    let(:scope)   { SQL::Scope.new "SELECT 1 FROM users" }
+    let(:scope)   { SQL.scope "SELECT 1 FROM users" }
 
     context "that do not match" do
       it "does not match with string keys" do
@@ -71,7 +71,7 @@ describe "Simple::SQL::Scope" do
   context "with non-argument conditions" do
     context "that do not match" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("id < 0")
         scope.where("TRUE")
       end
@@ -87,7 +87,7 @@ describe "Simple::SQL::Scope" do
 
     context "that do match" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("id >= 0")
         scope.where("TRUE")
       end
@@ -105,7 +105,7 @@ describe "Simple::SQL::Scope" do
   context "with argument conditions" do
     context "that do not match" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("first_name NOT LIKE ?", "First%")
         scope.where("id < ?", 0)
       end
@@ -121,7 +121,7 @@ describe "Simple::SQL::Scope" do
 
     context "where both match" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("first_name LIKE ?", "First%")
         scope.where("id >= ?", 0)
       end
@@ -137,7 +137,7 @@ describe "Simple::SQL::Scope" do
 
     context "where first condition matches" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("first_name LIKE ?", "First%")
         scope.where("id < ?", 0)
       end
@@ -149,7 +149,7 @@ describe "Simple::SQL::Scope" do
 
     context "where second condition matches" do
       let(:scope) do
-        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = SQL.scope "SELECT 1, 2 FROM users"
         scope = scope.where("first_name LIKE ?", "Boo%")
         scope.where("id >= ?", 0)
       end
@@ -160,7 +160,7 @@ describe "Simple::SQL::Scope" do
     end
 
     describe "hash matches" do
-      let(:scope) { SQL::Scope.new("SELECT id FROM users") }
+      let(:scope) { SQL.scope("SELECT id FROM users") }
 
       it 'validates hash keys' do
         expect {
@@ -178,7 +178,7 @@ describe "Simple::SQL::Scope" do
       end
 
       def ids_matching(condition)
-        scope = SQL::Scope.new("SELECT id FROM users")
+        scope = SQL.scope("SELECT id FROM users")
         scope = scope.where(condition)
         SQL.all(scope)
       end
@@ -205,22 +205,22 @@ describe "Simple::SQL::Scope" do
 
   context "Building with Hash" do
     it "runs with SQL.ask" do
-      scope = SQL::Scope.new table: "users", select: "1, 2", where: "id >= 0"
+      scope = SQL.scope table: "users", select: "1, 2", where: "id >= 0"
       expect(SQL.all(scope)).to eq([[1,2], [1,2]])
 
-      scope = SQL::Scope.new table: "users", select: [1,3,4], where: "id >= 0"
+      scope = SQL.scope table: "users", select: [1,3,4], where: "id >= 0"
       expect(SQL.all(scope)).to eq([[1,3,4], [1,3,4]])
     end
     
     it "raises an error with missing or invalid attributes" do
-      expect { SQL::Scope.new table: "users", limit: 1 }.to raise_error(ArgumentError)
-      expect { SQL::Scope.new select: "*" }.to raise_error(ArgumentError)
+      expect { SQL.scope table: "users", limit: 1 }.to raise_error(ArgumentError)
+      expect { SQL.scope select: "*" }.to raise_error(ArgumentError)
     end
   end
 
   context "describe pagination" do
     let(:scope) do
-      scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+      scope = SQL.scope "SELECT 1, 2 FROM users"
       scope = scope.where("first_name LIKE ?", "First%")
       scope.where("id > ?", 0)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors:
 - radiospiel
@@ -206,6 +206,12 @@ files:
 - lib/simple/sql/connection/insert.rb
 - lib/simple/sql/connection/raw_connection.rb
 - lib/simple/sql/connection/reflection.rb
+- lib/simple/sql/connection/scope.rb
+- lib/simple/sql/connection/scope/count.rb
+- lib/simple/sql/connection/scope/count_by_groups.rb
+- lib/simple/sql/connection/scope/filters.rb
+- lib/simple/sql/connection/scope/order.rb
+- lib/simple/sql/connection/scope/pagination.rb
 - lib/simple/sql/connection_adapter.rb
 - lib/simple/sql/formatting.rb
 - lib/simple/sql/fragment.rb
@@ -218,12 +224,7 @@ files:
 - lib/simple/sql/result.rb
 - lib/simple/sql/result/association_loader.rb
 - lib/simple/sql/result/records.rb
-- lib/simple/sql/scope.rb
 - lib/simple/sql/scope/count.rb
-- lib/simple/sql/scope/count_by_groups.rb
-- lib/simple/sql/scope/filters.rb
-- lib/simple/sql/scope/order.rb
-- lib/simple/sql/scope/pagination.rb
 - lib/simple/sql/version.rb
 - log/.gitkeep
 - scripts/stats