simple-sql 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4aa26b5a85a0c280fbabaeb6496a48b4e4f614b2
-  data.tar.gz: b81cffbc2356054f595383a72b72b49580e2fef5
+  metadata.gz: 54dcb90e07a18f552fcaa0f48a29ca7e60dd3888
+  data.tar.gz: ea2093eb587de387ecff564f46f4c86857cd5e5c
 SHA512:
-  metadata.gz: fb5ed3c2ae8b584013c8bf3c6e5b658037f7a17b650058b2556029724f4ee01fcad775a46a7cdbc5296a1b6eca44caafafabce119466e2c71f4111e9e5fb00d6
-  data.tar.gz: 098003ee4e34f9b29003a96ba4d479af1054685320f12a9cb9c93eebd7668cdacdd903e2dc76c992e558b038386cc09c93715200d1bc7f85f3ff517c11e19dd3
+  metadata.gz: 35493961c28b9140d4a18508acc4d7bfe28c638fff760418173cfee3f583ba643d427ca4670eb5c4dd2d812ea7c63347b9d37bb4c82ed560d73f1651a9845199
+  data.tar.gz: 5978e812fec0928e0ff5dcf020409775c55406d20b635244a71a238a74fe094368bc02453106028d848594affbbcfde068982fb1b1a3b5db90c83e211cdc9d17

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.4.1)
+    simple-sql (0.4.2)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 

data/lib/simple/sql.rb

@@ -7,6 +7,7 @@ require_relative "sql/encoder.rb"
 require_relative "sql/config.rb"
 require_relative "sql/logging.rb"
 require_relative "sql/simple_transactions.rb"
+require_relative "sql/scope.rb"
 require_relative "sql/connection_adapter.rb"
 require_relative "sql/connection.rb"
 require_relative "sql/reflection.rb"

data/lib/simple/sql/connection_adapter.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Style/IfUnlessModifier
+# rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/MethodLength
 
 # This module implements an adapter between the Simple::SQL interface
@@ -6,9 +8,10 @@
 # This module can be mixed onto objects that implement a raw_connection
 # method, which must return a Pg::Connection.
 module Simple::SQL::ConnectionAdapter
-  Logging = Simple::SQL::Logging
-  Encoder = Simple::SQL::Encoder
-  Decoder = Simple::SQL::Decoder
+  Logging = ::Simple::SQL::Logging
+  Encoder = ::Simple::SQL::Encoder
+  Decoder = ::Simple::SQL::Decoder
+  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
@@ -35,7 +38,11 @@ module Simple::SQL::ConnectionAdapter
 
   def all(sql, *args, into: nil, &block)
     result = exec_logged(sql, *args)
-    enumerate(result, into: into, &block)
+    result = enumerate(result, into: into, &block)
+    if sql.is_a?(Scope) && sql.paginated?
+      add_page_info(sql, result)
+    end
+    result
   end
 
   # Runs a query and returns the first result row of a query.
@@ -53,7 +60,30 @@ module Simple::SQL::ConnectionAdapter
     end
   end
 
-  def exec_logged(sql, *args)
+  def add_page_info(scope, results)
+    raise ArgumentError, "expect Array but get a #{results.class.name}" unless results.is_a?(Array)
+    raise ArgumentError, "per must be > 0" unless scope.per > 0
+
+    # optimization: add empty case (page <= 1 && results.empty?)
+    if scope.page <= 1 && results.empty?
+      Scope::PageInfo.attach(results, total_count: 0, per: scope.per, page: scope.page)
+    else
+      sql = "SELECT COUNT(*) FROM (#{scope.to_sql(pagination: false)}) simple_sql_count"
+      total_count = ask(sql, *scope.args)
+      Scope::PageInfo.attach(results, total_count: total_count, per: scope.per, page: scope.page)
+    end
+  end
+
+  def exec_logged(sql_or_scope, *args)
+    if sql_or_scope.is_a?(Scope)
+      raise ArgumentError, "You cannot call .all with a scope and additional arguments" unless args.empty?
+
+      sql  = sql_or_scope.to_sql
+      args = sql_or_scope.args
+    else
+      sql = sql_or_scope
+    end
+
     Logging.yield_logged sql, *args do
       raw_connection.exec_params(sql, Encoder.encode_args(raw_connection, args))
     end

data/lib/simple/sql/scope.rb

@@ -0,0 +1,120 @@
+# rubocop:disable Style/Not
+# rubocop:disable Style/MultipleComparison
+# rubocop:disable Style/IfUnlessModifier
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/PerceivedComplexity
+
+# 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
+
+  # Build a scope object
+  def initialize(sql)
+    @sql = sql
+    @args = []
+    @filters = []
+  end
+
+  private
+
+  def duplicate
+    dupe = SELF.new(@sql)
+    dupe.instance_variable_set :@args, @args.dup
+    dupe.instance_variable_set :@filters, @filters.dup
+    dupe.instance_variable_set :@per, @per
+    dupe.instance_variable_set :@page, @page
+    dupe
+  end
+
+  public
+
+  # scope = Scope.new("SELECT * FROM tablename")
+  # scope = scope.where("id > ?", 12)
+  #
+  # The placeholder (usually a '?') is being replaced with the numbered
+  # argument (since postgres is using $1, $2, etc.) If your SQL fragment
+  # uses '?' as part of some fixed text you must use an alternative
+  # placeholder symbol.
+  #
+  # TODO: Add support for hash arguments, i.e.
+  # scope = scope.where(title: "foobar")
+  def where(sql_fragment, arg = :__dummy__no__arg, placeholder: "?")
+    duplicate.send(:where!, sql_fragment, arg, placeholder: placeholder)
+  end
+
+  private
+
+  def where!(sql_fragment, arg = :__dummy__no__arg, placeholder: "?")
+    if arg == :__dummy__no__arg
+      @filters << sql_fragment
+    else
+      @args << arg
+      @filters << sql_fragment.gsub(placeholder, "$#{@args.length}")
+    end
+
+    self
+  end
+
+  public
+
+  # Set pagination
+  def paginate(per:, page:)
+    duplicate.send(:paginate!, per: per, page: page)
+  end
+
+  private
+
+  def paginate!(per:, page:)
+    @per = per
+    @page = page
+
+    self
+  end
+
+  public
+
+  # Is this a paginated scope?
+  def paginated?
+    not @per.nil?
+  end
+
+  # generate a sql query
+  def to_sql(pagination: :auto)
+    raise ArgumentError unless pagination == :auto || pagination == false
+
+    sql = @sql
+    active_filters = @filters.compact
+    unless active_filters.empty?
+      sql += " WHERE (" + active_filters.join(") AND (") + ")"
+    end
+    if pagination == :auto && @per && @page
+      raise ArgumentError, "per must be > 0" unless @per > 0
+      raise ArgumentError, "page must be > 0" unless @page > 0
+
+      sql += "LIMIT #{@per} OFFSET #{(@page - 1) * @per}"
+    end
+
+    sql
+  end
+
+  # The Scope::PageInfo module can be mixed into other objects to
+  # hold total_count, total_pages, and current_page.
+  module PageInfo
+    attr_reader :total_count, :total_pages, :current_page
+
+    def self.attach(results, total_count:, per:, page:)
+      results.extend(self)
+      results.instance_variable_set :@total_count, total_count
+      results.instance_variable_set :@total_pages, (total_count + (per - 1)) / per
+      results.instance_variable_set :@current_page, page
+      results
+    end
+  end
+end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
   end
 end

data/spec/simple/sql_scope_spec.rb

@@ -0,0 +1,163 @@
+require "spec_helper"
+
+describe "Simple::SQL::Scope" do
+  def expects(expected_result, sql, *args)
+    expect(SQL.ask(sql, *args)).to eq(expected_result)
+  end
+
+  let!(:users) { 1.upto(2).map { create(:user) } }
+
+  it 'allows chaining of scopes' do
+    scope1 = SQL::Scope.new "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" }
+
+    it "runs with SQL.ask" do
+      expect(SQL.ask(scope)).to eq([1, 2])
+    end
+
+    it "runs with SQL.all" do
+      expect(SQL.all(scope)).to eq([[1, 2], [1, 2]])
+    end
+  end
+
+  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 = scope.where("id < 0")
+        scope.where("TRUE")
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to be_nil
+      end
+
+      it "runs with SQL.all" do
+        expect(SQL.all(scope)).to eq([])
+      end
+    end
+
+    context "that do match" do
+      let(:scope) do
+        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = scope.where("id >= 0")
+        scope.where("TRUE")
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to eq([1, 2])
+      end
+
+      it "runs with SQL.all" do
+        expect(SQL.all(scope)).to eq([[1, 2], [1, 2]])
+      end
+    end
+  end
+
+  context "with argument conditions" do
+    context "that do not match" do
+      let(:scope) do
+        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = scope.where("first_name NOT LIKE ?", "First%")
+        scope.where("id < ?", 0)
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to be_nil
+      end
+
+      it "runs with SQL.all" do
+        expect(SQL.all(scope)).to eq([])
+      end
+    end
+
+    context "where both match" do
+      let(:scope) do
+        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = scope.where("first_name LIKE ?", "First%")
+        scope.where("id >= ?", 0)
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to eq([1,2])
+      end
+
+      it "runs with SQL.all" do
+        expect(SQL.all(scope)).to eq([[1,2], [1,2]])
+      end
+    end
+
+    context "where first condition matches" do
+      let(:scope) do
+        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = scope.where("first_name LIKE ?", "First%")
+        scope.where("id < ?", 0)
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to be_nil
+      end
+    end
+
+    context "where second condition matches" do
+      let(:scope) do
+        scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+        scope = scope.where("first_name LIKE ?", "Boo%")
+        scope.where("id >= ?", 0)
+      end
+
+      it "runs with SQL.ask" do
+        expect(SQL.ask(scope)).to be_nil
+      end
+    end
+  end
+
+  context "describe pagination" do
+    let(:scope) do
+      scope = SQL::Scope.new "SELECT 1, 2 FROM users"
+      scope = scope.where("first_name LIKE ?", "First%")
+      scope.where("id > ?", 0)
+    end
+
+    it "sets paginated?" do
+      s = scope.paginate(per: 1, page: 1)
+      expect(s.paginated?).to eq(true)
+    end
+
+    context "with per=1" do
+      it "adds pagination info to the .all return value" do
+        result = SQL.all(scope.paginate(per: 1, page: 1))
+
+        expect(result).to eq([[1, 2]])
+        expect(result.total_pages).to eq(2)
+        expect(result.current_page).to eq(1)
+        expect(result.total_count).to eq(2)
+      end
+    end
+
+    context "with per=2" do
+      it "returns an empty array after the last page" do
+        result = SQL.all(scope.paginate(per: 2, page: 2))
+
+        expect(result).to eq([])
+        expect(result.total_pages).to eq(1)
+        expect(result.current_page).to eq(2)
+        expect(result.total_count).to eq(2)
+      end
+
+      it "adds pagination info to the .all return value" do
+        result = SQL.all(scope.paginate(per: 2, page: 1))
+
+        expect(result).to eq([[1, 2], [1, 2]])
+        expect(result.total_pages).to eq(1)
+        expect(result.current_page).to eq(1)
+        expect(result.total_count).to eq(2)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-17 00:00:00.000000000 Z
+date: 2018-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -177,6 +177,7 @@ files:
 - lib/simple/sql/insert.rb
 - lib/simple/sql/logging.rb
 - lib/simple/sql/reflection.rb
+- lib/simple/sql/scope.rb
 - lib/simple/sql/simple_transactions.rb
 - lib/simple/sql/version.rb
 - log/.gitkeep
@@ -193,6 +194,7 @@ files:
 - spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_reflection_spec.rb
+- spec/simple/sql_scope_spec.rb
 - spec/spec_helper.rb
 - spec/support/001_database.rb
 - spec/support/002_database_cleaner.rb
@@ -235,6 +237,7 @@ test_files:
 - spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_reflection_spec.rb
+- spec/simple/sql_scope_spec.rb
 - spec/spec_helper.rb
 - spec/support/001_database.rb
 - spec/support/002_database_cleaner.rb