simple-sql 0.4.5 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a83b1690cf4e3b75f7e974df31e7c8b29680e198
-  data.tar.gz: 333ca9858a0cc4eb06519d1eadee61fb875939f2
+  metadata.gz: a8c0b2ffb0ec662dd3a487855cac5b76d97a1970
+  data.tar.gz: 60a5c103b6d7970a4adca867a0f547923c5c03f9
 SHA512:
-  metadata.gz: ce35aefb5d57370cb6fd88b1c25a5a9ebe3d767ce8bbb2e1b4433726e6968511ffa5a82859ae2b012b2f189b12761c20a266d7a21556f89303ac6f67c3ed4332
-  data.tar.gz: 812bc3709085da01e1fcd91a10f6c5c864a34f5a5fddb3edea5885ba22fcd0d5b273a8d6d300482d0a03c41ed14120c7c710aaa9e4e33a6489774d44782c3847
+  metadata.gz: fd80d308c336f2c5ecca6d49ec3f5fff516adb3adb59048bccce9ac13c89996f21821be1795e6b925a7f58b1ec3198965ceeffa5f90bb4786193d415cc0efa18
+  data.tar.gz: 7930a7c788dca9588bc56ef8ba4a65bd5b42fb6aaef018bbcad6dd1ff1baacc2b1608b6526548a4553c654f265ca44a74481ace1c535be82d6f496347d68b588

data/Gemfile.lock

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

data/lib/simple/sql/scope.rb

@@ -1,10 +1,8 @@
-# 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
+
+require_relative "scope/filters.rb"
+require_relative "scope/order.rb"
+require_relative "scope/pagination.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
@@ -14,7 +12,6 @@ class Simple::SQL::Scope
 
   attr_reader :args
   attr_reader :per, :page
-  attr_reader :order_by_fragment
 
   # Build a scope object
   def initialize(sql)
@@ -38,106 +35,14 @@ class Simple::SQL::Scope
 
   public
 
-  # scope = Scope.new("SELECT * FROM tablename")
-  # scope = scope.where(id: 12)
-  # scope = scope.where("id > ?", 12)
-  #
-  # In the second form 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:
-  #
-  # scope = scope.where("foo | '?' = '^'", match, placeholder: '^')
-  #
-  def where(sql_fragment, arg = :__dummy__no__arg, placeholder: "?")
-    duplicate.send(:where!, sql_fragment, arg, placeholder: placeholder)
-  end
-
-  def where!(first_arg, arg = :__dummy__no__arg, placeholder: "?")
-    if arg != :__dummy__no__arg
-      where_sql_with_argument!(first_arg, arg, placeholder: placeholder)
-    elsif first_arg.is_a?(Hash)
-      where_hash!(first_arg)
-    else
-      where_sql!(first_arg)
-    end
-
-    self
-  end
-
-  def where_sql!(sql_fragment)
-    @filters << sql_fragment
-  end
-
-  def where_sql_with_argument!(sql_fragment, arg, placeholder:)
-    @args << arg
-    @filters << sql_fragment.gsub(placeholder, "$#{@args.length}")
-  end
-
-  def where_hash!(hsh)
-    hsh.each do |key, value|
-      raise ArgumentError, "condition key must be a Symbol or a String" unless key.is_a?(Symbol) || key.is_a?(String)
-
-      @args << value
-
-      case value
-      when Array
-        @filters << "#{key} = ANY($#{@args.length})"
-      else
-        @filters << "#{key} = $#{@args.length}"
-      end
-    end
-  end
-
-  # Set pagination
-  def paginate(per:, page:)
-    duplicate.send(:paginate!, per: per, page: page)
-  end
-
-  def paginate!(per:, page:)
-    @per = per
-    @page = page
-
-    self
-  end
-
-  # Adjust sort order
-  def order_by!(sql_fragment)
-    @order_by_fragment = sql_fragment
-    self
-  end
-
-  def order_by(sql_fragment)
-    duplicate.order_by!(sql_fragment)
-  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 order_by_fragment
-      sql += " ORDER BY #{order_by_fragment}"
-    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 = apply_filters(sql)
+    sql = apply_order(sql)
+    sql = apply_pagination(sql, pagination: pagination)
 
     sql
   end

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

@@ -0,0 +1,111 @@
+# rubocop:disable Style/IfUnlessModifier
+# rubocop:disable Style/GuardClause
+
+class Simple::SQL::Scope
+  # scope = Scope.new("SELECT * FROM tablename")
+  # scope = scope.where(id: 12)
+  # scope = scope.where("id > ?", 12)
+  #
+  # In the second form 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:
+  #
+  # scope = scope.where("foo | '?' = '^'", match, placeholder: '^')
+  #
+  # If a hash is passed in as a search condition and the value to match is
+  # a hash, this is translated into a JSONB query, which matches each of
+  # the passed in keys against one of the passed in values.
+  #
+  # scope = scope.where(metadata: { uid: 1, type: ["foo", "bar", "baz"] })
+  #
+  # This feature can be disabled using the `jsonb: false` option.
+  #
+  # scope = scope.where(metadata: { uid: 1 }, jsonb: false)
+  #
+  def where(sql_fragment, arg = :__dummy__no__arg, placeholder: "?", jsonb: true)
+    duplicate.send(:where!, sql_fragment, arg, placeholder: placeholder, jsonb: jsonb)
+  end
+
+  private
+
+  def where!(first_arg, arg = :__dummy__no__arg, placeholder: "?", jsonb: true)
+    if arg != :__dummy__no__arg
+      where_sql_with_argument!(first_arg, arg, placeholder: placeholder)
+    elsif first_arg.is_a?(Hash)
+      where_hash!(first_arg, jsonb: jsonb)
+    else
+      where_sql!(first_arg)
+    end
+
+    self
+  end
+
+  def where_sql!(sql_fragment)
+    @filters << sql_fragment
+  end
+
+  def where_sql_with_argument!(sql_fragment, arg, placeholder:)
+    @args << arg
+    @filters << sql_fragment.gsub(placeholder, "$#{@args.length}")
+  end
+
+  def where_hash!(hsh, jsonb:)
+    hsh.each do |column, value|
+      validate_column! column
+      if value.is_a?(Hash) && jsonb
+        where_jsonb_condition!(column, value)
+      else
+        where_plain_condition!(column, value)
+      end
+    end
+  end
+
+  ID_REGEXP = /\A[A-Za-z0-9_\.]+\z/
+
+  def validate_column!(column)
+    unless column.is_a?(Symbol) || column.is_a?(String)
+      raise ArgumentError, "condition key #{column.inspect} must be a Symbol or a String"
+    end
+    unless column.to_sym =~ ID_REGEXP
+      raise ArgumentError, "condition key #{column.inspect} must match #{ID_REGEXP}"
+    end
+  end
+
+  def jsonb_condition(column, key, value)
+    if !value.is_a?(Array)
+      "#{column} @> '#{::JSON.generate(key => value)}'"
+    elsif value.empty?
+      "FALSE"
+    else
+      individual_conditions = value.map do |v|
+        jsonb_condition(column, key, v)
+      end
+      "(#{individual_conditions.join(' OR ')})"
+    end
+  end
+
+  def where_jsonb_condition!(column, hsh)
+    hsh.each do |key, value|
+      @filters << jsonb_condition(column, key, value)
+    end
+  end
+
+  def where_plain_condition!(key, value)
+    @args << value
+
+    case value
+    when Array
+      @filters << "#{key} = ANY($#{@args.length})"
+    else
+      @filters << "#{key} = $#{@args.length}"
+    end
+  end
+
+  def apply_filters(sql)
+    active_filters = @filters.compact
+    return sql if active_filters.empty?
+
+    "#{sql} WHERE (" + active_filters.join(") AND (") + ")"
+  end
+end

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

@@ -0,0 +1,21 @@
+
+
+class Simple::SQL::Scope
+  def order_by(sql_fragment)
+    duplicate.send(:order_by!, sql_fragment)
+  end
+
+  private
+
+  # Adjust sort order
+  def order_by!(sql_fragment)
+    @order_by_fragment = sql_fragment
+    self
+  end
+
+  # called from to_sql
+  def apply_order(sql)
+    return sql unless @order_by_fragment
+    "#{sql} ORDER BY #{@order_by_fragment}"
+  end
+end

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

@@ -0,0 +1,31 @@
+# rubocop:disable Style/Not
+
+class Simple::SQL::Scope
+  # Set pagination
+  def paginate(per:, page:)
+    duplicate.send(:paginate!, per: per, page: page)
+  end
+
+  # Is this a paginated scope?
+  def paginated?
+    not @per.nil?
+  end
+
+  private
+
+  def paginate!(per:, page:)
+    @per = per
+    @page = page
+
+    self
+  end
+
+  def apply_pagination(sql, pagination:)
+    return sql unless 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
+end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.4.5"
+    VERSION = "0.4.7"
   end
 end

data/spec/simple/sql_scope_spec.rb

@@ -5,7 +5,9 @@ describe "Simple::SQL::Scope" do
     expect(SQL.ask(sql, *args)).to eq(expected_result)
   end
 
-  let!(:users) { 1.upto(2).map { create(:user) } }
+  let!(:users) do
+    1.upto(2).map { |id| create(:user, id: id) }
+  end
 
   it 'allows chaining of scopes' do
     scope1 = SQL::Scope.new "SELECT 1, 2 FROM users"
@@ -156,6 +158,49 @@ describe "Simple::SQL::Scope" do
         expect(SQL.ask(scope)).to be_nil
       end
     end
+
+    describe "hash matches" do
+      let(:scope) { SQL::Scope.new("SELECT id FROM users") }
+
+      it 'validates hash keys' do
+        expect {
+          scope.where("foo bar" => "baz")
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "JSONB matches" do
+      before do
+        SQL.exec <<~SQL
+          UPDATE users SET metadata = '{"type": "user"}';
+          UPDATE users SET metadata = jsonb_set(metadata, '{uid}', to_json(id)::jsonb);
+        SQL
+      end
+
+      def ids_matching(condition)
+        scope = SQL::Scope.new("SELECT id FROM users")
+        scope = scope.where(condition)
+        SQL.all(scope)
+      end
+
+      it "runs with SQL.ask" do
+        # exact match
+        expect(ids_matching(metadata: { "uid" => 1 })).to contain_exactly(1)
+
+        # match against array
+        expect(ids_matching(metadata: { "uid" => [] })).to contain_exactly()
+        expect(ids_matching(metadata: { "uid" => [1, -1] })).to contain_exactly(1)
+        expect(ids_matching(metadata: { "uid" => [1, 2] })).to contain_exactly(1, 2)
+
+        # match against array of mixed types
+        expect(ids_matching(metadata: { "uid" => [1, "-1"] })).to contain_exactly(1)
+
+        # match against multiple conditions
+        expect(ids_matching(metadata: { "uid" => [1, "-1"], "type" => "foo" })).to contain_exactly()
+        expect(ids_matching(metadata: { "uid" => [1, "-1"], "type" => ["foo", "user"] })).to contain_exactly(1)
+        expect(ids_matching(metadata: { "uid" => [1, "-1"], "type" => [] })).to contain_exactly()
+      end
+    end
   end
 
   context "describe pagination" do

data/spec/support/001_database.rb

@@ -30,7 +30,7 @@ ActiveRecord::Schema.define do
     t.integer   :role_id
     t.string    :first_name
     t.string    :last_name
-    t.hstore    :meta_data
+    t.jsonb     :metadata
     t.column    :access_level, :access_level
 
     t.timestamps null: true

data/spec/support/003_factories.rb

@@ -7,7 +7,7 @@ def sequence(pattern)
   end
 end
 
-def attrs(table)
+def table_attrs(table)
   case table
   when :user
     {
@@ -15,19 +15,20 @@ def attrs(table)
       first_name: sequence("First {{sequence}}"),
       last_name: sequence("Last {{sequence}}"),
       access_level: "viewable"
-    }
+    }.freeze
   when :unique_user
     {
       first_name: sequence("First {{sequence}}"),
       last_name: sequence("Last {{sequence}}")
-    }
+    }.freeze
   else
     raise ArgumentError, "Invalid table for factory: #{table.inspect}"
   end
 end
 
-def create(table)
+def create(table, attrs = {})
   table_name = table.to_s.pluralize
-  id = Simple::SQL.insert(table_name, attrs(table))
+  attrs = table_attrs(table).merge(attrs)
+  id = Simple::SQL.insert(table_name, attrs)
   Simple::SQL.ask("SELECT * FROM #{table_name} WHERE id=$1", id, into: OpenStruct)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.7
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-30 00:00:00.000000000 Z
+date: 2018-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -178,6 +178,9 @@ files:
 - lib/simple/sql/logging.rb
 - lib/simple/sql/reflection.rb
 - lib/simple/sql/scope.rb
+- 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