simple-sql 0.5.25 → 0.5.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 808175e637d54e64be95571d633d728ee6c8710e214dc379f9104b7624cd21e3
-  data.tar.gz: 108b164f85d746a20aa630175b63500149146a69fc88a43ef628bddd7d0e6584
+  metadata.gz: fab09e2181d6826802076b03cf71b0c742862ab1bf58e730403eee0eed1bb1c6
+  data.tar.gz: 4f64d6025f76fec82d72f83cc936072cb092fa51f5fa0ad4ea37da1e70b045a3
 SHA512:
-  metadata.gz: ff51e82f0ec865164d8ca570ee693902ea036aa5fca789ba51830f57146c4dadc8fe3d4c65f8c9ca6cfc578629c8b1e39932877b7470f06b196e31c4a935e259
-  data.tar.gz: da0146769d4360bcbe10b2ca6019918839d4d532d4cfe74f944e4b8a5367bcc007d222d90eaaec4e897d4cce3e0b8c846f143bf9ee0817306279550d029eac00
+  metadata.gz: e8d383d973a2564e5e841e3820c24dc8aa9438c1ce3629f9508538e53c9775ef9ec16e8b7979933d1fed09bdc9389c71b2ce31122347f096f0e604bba2b20184
+  data.tar.gz: 8a8caf53d1e973c8d762e725e7a7f91ea2fc5295d092c024db4227bda1c92976b0600f1f62d80d1d98794b5f35dc0eea3639ef887dbb2506b1cfdf20b8d7a055

data/.rubocop.yml

@@ -4,6 +4,7 @@ AllCops:
     - 'spec/**/*'
     - 'test/**/*'
     - 'bin/**/*'
+    - 'scripts/*'
     - 'tasks/release.rake'
     - '*.gemspec'
     - 'Gemfile'

data/VERSION

@@ -1 +1 @@
-0.5.25
+0.5.26

data/lib/simple/sql/config.rb

@@ -56,7 +56,7 @@ module Simple::SQL::Config
   def load_activerecord_base_configuration(path:, env:)
     require "yaml"
     database_config = YAML.load_file(path)
-    env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    env ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
 
     database_config[env] ||
       database_config["defaults"] ||

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

@@ -42,6 +42,7 @@ class Simple::SQL::Connection
       raise ArgumentError, "Cannot insert a record without attributes" if columns.empty?
 
       @connection = connection
+      @table_name = table_name
       @columns = columns
       @into = into
 
@@ -64,9 +65,31 @@ class Simple::SQL::Connection
     def insert(records:)
       @connection.transaction do
         records.map do |record|
-          @connection.ask @sql, *record.values_at(*@columns), into: @into
+          values = record.values_at(*@columns)
+          encode_json_values!(values)
+
+          @connection.ask @sql, *values, into: @into
         end
       end
     end
+
+    def encode_json_values!(values)
+      indices_of_json_columns.each { |idx| values[idx] = json_encode(values[idx]) }
+    end
+
+    # determine indices of columns that are JSON(B).
+    def indices_of_json_columns
+      return @indices_of_json_columns if @indices_of_json_columns
+
+      column_types = @connection.reflection.column_types(@table_name)
+      @indices_of_json_columns = @columns.each_with_index
+                                         .select { |column_name, _idx| %w(json jsonb).include?(column_types[column_name]) }
+                                         .map { |_column_name, idx| idx }
+    end
+
+    def json_encode(value)
+      return value unless value.is_a?(Hash) || value.is_a?(Array)
+      JSON.generate(value)
+    end
   end
 end

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

@@ -1,7 +1,8 @@
 # rubocop:disable Style/MultipleComparison
 
 require_relative "scope/shorthand"
-require_relative "scope/filters"
+require_relative "scope/where"
+require_relative "scope/search"
 require_relative "scope/order"
 require_relative "scope/pagination"
 require_relative "scope/count"
@@ -34,14 +35,17 @@ class Simple::SQL::Connection::Scope
   attr_reader :args
   attr_reader :per, :page
 
+  # when initialized with a Hash: contains table name
+  attr_accessor :table_name
+
   def initialize(sql, args = [], connection:) # :nodoc:
     expect! sql => [String, Hash]
 
     @connection = connection
 
-    @sql     = nil
-    @args    = args
-    @filters = []
+    @sql   = nil
+    @args  = args
+    @where = []
 
     case sql
     when String then @sql = sql
@@ -60,10 +64,10 @@ class Simple::SQL::Connection::Scope
 
     # -- set table and select -------------------------------------------------
 
-    table = hsh[:table] || raise(ArgumentError, "Missing :table option")
+    @table_name = hsh[:table] || raise(ArgumentError, "Missing :table option")
     select = hsh[:select] || "*"
 
-    @sql = "SELECT #{Array(select).join(', ')} FROM #{table}"
+    @sql = "SELECT #{Array(select).join(', ')} FROM #{table_name}"
 
     # -- apply conditions, if any ---------------------------------------------
 
@@ -73,8 +77,9 @@ class Simple::SQL::Connection::Scope
 
   def duplicate
     dupe = SELF.new(@sql, connection: @connection)
+    dupe.instance_variable_set :@table_name, @table_name.dup
     dupe.instance_variable_set :@args, @args.dup
-    dupe.instance_variable_set :@filters, @filters.dup
+    dupe.instance_variable_set :@where, @where.dup
     dupe.instance_variable_set :@per, @per
     dupe.instance_variable_set :@page, @page
     dupe.instance_variable_set :@order_by_fragment, @order_by_fragment
@@ -89,7 +94,7 @@ class Simple::SQL::Connection::Scope
     raise ArgumentError unless pagination == :auto || pagination == false
 
     sql = @sql
-    sql = apply_filters(sql)
+    sql = apply_where(sql)
     sql = apply_order_and_limit(sql)
     sql = apply_pagination(sql, pagination: pagination)
 

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

@@ -0,0 +1,149 @@
+# rubocop:disable Metrics/AbcSize
+class Simple::SQL::Connection::Scope
+  def search(filters, dynamic_column: nil, table_name: nil)
+    table_name ||= self.table_name
+    raise "Cannot run search without a table_name setting. Please set table_name on this scope." unless table_name
+
+    column_types = connection.reflection.column_types(table_name)
+    dynamic_column ||= column_types.detect { |_column_name, column_type| column_type == "jsonb" }.first
+
+    Search.search(self, filters, dynamic_column: dynamic_column, column_types: column_types)
+  end
+end
+
+module Simple::SQL::Connection::Scope::Search
+  extend self
+
+  ID_REGEXP = /\A[_a-zA-Z][_a-zA-Z0-9]*\z/
+
+  # apply the filter hash onto the passed in scope. This matches all filters
+  # with a name which is matching a column name against the column values.
+  # It matches every other filter value against an entry in the
+  # dynamic_filter column.
+  def search(scope, filters, dynamic_column:, column_types:)
+    expect! filters => [nil, Hash]
+    expect! dynamic_column => ID_REGEXP
+
+    filters.each_key do |key|
+      expect! key => [Symbol, String]
+      expect! key.to_s => ID_REGEXP
+    end
+
+    return scope if filters.nil? || filters.empty?
+
+    # some filters try to match against existing columns, some try to match
+    # against the "tags" JSONB column - and they result in different where
+    # clauses in the Simple::SQL scope ("value = <match>" or "tags->>value = <match>").
+    static_filters, dynamic_filters = filters.partition { |key, _| static_filter?(column_types, key) }
+
+    scope = apply_static_filters(scope, static_filters, column_types: column_types)
+    scope = apply_dynamic_filters(scope, dynamic_filters, dynamic_column: dynamic_column)
+    scope
+  end
+
+  private
+
+  def static_filter?(column_types, key)
+    column_types.key?(key)
+  end
+
+  def array_product(ary, *other_arys)
+    ary.product(*other_arys)
+  end
+
+  # -- apply static filters ---------------------------------------------------
+
+  def apply_static_filters(scope, filters, column_types:)
+    return scope if filters.empty?
+
+    filters.inject(scope) do |scp, (k, v)|
+      scp.where k => resolve_static_matches(v, column_type: column_types.fetch(k))
+    end
+  end
+
+  def resolve_static_matches(value, column_type:)
+    if value.is_a?(Array)
+      return value.map { |v| resolve_static_matches(v, column_type: column_type) }
+    end
+
+    case column_type
+    when "bigint"   then Integer(value)
+    when "integer"  then Integer(value)
+    else                 value.to_s
+    end
+  end
+
+  # -- apply dynamic filters --------------------------------------------------
+
+  def apply_dynamic_filters(scope, filters, dynamic_column:)
+    # we translate a condition of "foo => []" into a SQL fragment like this:
+    #
+    #  NOT (column ? 'foo') OR column @> '{ "foo" : null }'::jsonb)"
+    #
+    # i.e. we check for non-existing columns and columns that exist but have a
+    # value of null (i.e. column->'key' IS NULL).
+    empty_filters, filters = filters.partition { |_key, value| value.nil? || value.empty? }
+    empty_filters.each do |key, _|
+      scope = scope.where("(NOT #{dynamic_column} ? '#{key}' OR #{dynamic_column} @> '#{::JSON.generate(key => nil)}'::jsonb)")
+    end
+
+    return scope if filters.empty?
+
+    keys = []
+    value_arrays = []
+
+    # collect keys and value_arrays for each filter
+    filters.each do |key, value|
+      keys << key
+      # note that resolve_dynamic_matches always returns an array.
+      value_arrays << resolve_dynamic_matches(value, key: key)
+    end
+
+    # We create a product of all potential value combinations. This is to support
+    # search combinations combining multiple values in multiple attributes; like
+    # this:
+    #
+    #     search(foo: %w(bar baz), ids: [1, 2, 3])
+    #
+    # which is implemented as "(foo='bar' AND ids=1) OR (foo='bar' AND ids=2) ..."
+    #
+    # I hope we figure out a smart way to use Postgres' JSONB index support to
+    # not have to do that.
+    #
+    # Note: a shorter way to do this would be
+    #
+    #   "(foo='bar' OR foo='baz') AND (ids=1 OR ids=2 .. )"
+    #
+    # However, in that case EXPLAIN suggests a more complicated query plan, which
+    # suggests that a query might execute faster if there is only a single condition
+    # using the JSONB index on each JSONB column.
+    product = array_product(*value_arrays)
+
+    # convert each individual combination in the product into a JSONB search
+    # condition.
+    sql_fragment_parts = product.map do |values|
+      match = Hash[keys.zip(values)]
+      "#{dynamic_column} @> '#{::JSON.generate(match)}'::jsonb"
+    end
+
+    # combine all search conditions with a SQL OR.
+    return scope if sql_fragment_parts.empty?
+
+    sql_fragment = "\n\t" + sql_fragment_parts.join(" OR\n\t") + "\n"
+    scope.where(sql_fragment)
+  end
+
+  # convert value into an array of matches for dynamic attributes. This array
+  # might contain integers and strings: We treat each number as a string, and
+  # each string which looks like an integer as a number. Consequently searching
+  # for "123" in a dynamic attribute would match on 123 *and* on "123".
+  def resolve_dynamic_matches(value, key:)
+    _ = key
+
+    Array(value).each_with_object([]) do |v, ary|
+      ary << v
+      ary << Integer(v) if v.is_a?(String) && v =~ /\A-?\d+\z/
+      ary << v.to_s unless v.is_a?(String)
+    end.uniq
+  end
+end

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

@@ -6,4 +6,8 @@ class Simple::SQL::Connection::Scope
   def first(into: :struct)
     connection.ask(self, into: into)
   end
+
+  def print(*args, io: STDOUT, width: :auto)
+    connection.print(self, *args, io: io, width: width)
+  end
 end

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

@@ -41,12 +41,12 @@ class Simple::SQL::Connection::Scope
   end
 
   def where_sql!(sql_fragment)
-    @filters << sql_fragment
+    @where << sql_fragment
   end
 
   def where_sql_with_argument!(sql_fragment, arg, placeholder:)
     @args << arg
-    @filters << sql_fragment.gsub(placeholder, "$#{@args.length}")
+    @where << sql_fragment.gsub(placeholder, "$#{@args.length}")
   end
 
   def where_hash!(hsh, jsonb:)
@@ -86,7 +86,7 @@ class Simple::SQL::Connection::Scope
 
   def where_jsonb_condition!(column, hsh)
     hsh.each do |key, value|
-      @filters << jsonb_condition(column, key, value)
+      @where << jsonb_condition(column, key, value)
     end
   end
 
@@ -95,16 +95,16 @@ class Simple::SQL::Connection::Scope
 
     case value
     when Array
-      @filters << "#{key} = ANY($#{@args.length})"
+      @where << "#{key} = ANY($#{@args.length})"
     else
-      @filters << "#{key} = $#{@args.length}"
+      @where << "#{key} = $#{@args.length}"
     end
   end
 
-  def apply_filters(sql)
-    active_filters = @filters.compact
-    return sql if active_filters.empty?
+  def apply_where(sql)
+    where = @where.compact
+    return sql if where.empty?
 
-    "#{sql} WHERE (" + active_filters.join(") AND (") + ")"
+    "#{sql} WHERE (" + where.join(") AND (") + ")"
   end
 end

data/spec/simple/sql/search_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe "Simple::SQL.search" do
+  let!(:users) do
+    1.upto(10).map { |i| 
+      metadata = { user_id_squared: i * i, id_string: "user-#{i}", even_str: i.even? ? "yes" : "no" }
+      metadata[:odd] = true if i.odd?
+      metadata[:always_odd] = i.odd? ? true : nil      # always_even is always set, in contrast to odd
+      create(:user, role_id: i, metadata: metadata)
+    } 
+  end
+
+  let(:scope) do
+    scope = SQL.scope("SELECT * FROM users") 
+    scope.table_name = "users"
+    scope
+  end
+
+  def search(*args)
+    scope.search(*args).all
+  end
+
+  it "filters by one dynamic attribute and one match" do
+    expect(search(even_str: "yes").map(&:id)).to contain_exactly(2,4,6,8,10)
+  end
+
+  it "filters by one dynamic attribute and multiple matches" do
+    expect(search(user_id_squared: [1, 3, 9]).map(&:id)).to contain_exactly(1,3)
+  end
+
+  it "filters by unknown dynamic attribute" do
+    expect(search(no_such_str: "yes").map(&:id)).to contain_exactly()
+  end
+
+  it "converts strings to integers" do
+    expect(search(user_id_squared: [1, "4", "9"]).map(&:id)).to contain_exactly(1,2,3)
+  end
+
+  it "filters by multiple dynamic attributes" do
+    expect(search(user_id_squared: [1, "4", "9"], even_str: "yes").map(&:id)).to contain_exactly(2)
+  end
+
+  it "filters by multiple mixed attributes" do
+    expect(search(id: [1, "2", "3", 4], even_str: "yes").map(&:id)).to contain_exactly(2, 4)
+  end
+
+  it "filters for non-existing dynamic attributes" do
+    expect(search(odd: []).map(&:id)).to contain_exactly(2, 4, 6, 8, 10)
+    expect(search(odd: nil).map(&:id)).to contain_exactly(2, 4, 6, 8, 10)
+  end
+
+  it "filters for non-existing dynamic attributes" do
+    expect(search(always_odd: nil).map(&:id)).to contain_exactly(2, 4, 6, 8, 10)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.5.25
+  version: 0.5.26
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -197,10 +197,11 @@ files:
 - 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/scope/search.rb
 - lib/simple/sql/connection/scope/shorthand.rb
+- lib/simple/sql/connection/scope/where.rb
 - lib/simple/sql/connection/type_info.rb
 - lib/simple/sql/connection_manager.rb
 - lib/simple/sql/formatting.rb
@@ -242,6 +243,7 @@ files:
 - spec/simple/sql/reflection_spec.rb
 - spec/simple/sql/result_count_spec.rb
 - spec/simple/sql/scope_spec.rb
+- spec/simple/sql/search_spec.rb
 - spec/simple/sql/version_spec.rb
 - spec/simple/sql_locked_spec.rb
 - spec/spec_helper.rb
@@ -293,6 +295,7 @@ test_files:
 - spec/simple/sql/reflection_spec.rb
 - spec/simple/sql/result_count_spec.rb
 - spec/simple/sql/scope_spec.rb
+- spec/simple/sql/search_spec.rb
 - spec/simple/sql/version_spec.rb
 - spec/simple/sql_locked_spec.rb
 - spec/spec_helper.rb