polysearch 0.1.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21bf6d369ed9516908e5ac52bb3b5688335e05952e920741cccd40d73b2279d8
-  data.tar.gz: 7257fa7063ad0b250c7d3b602a7acc5bc3b42984b6fefa47202629eedbb03018
+  metadata.gz: e527bae221d08edf537ee05002258f8cdf982c09f0748eccfee8f170fb83629e
+  data.tar.gz: 3f4d4d07575755d6a89e2d20be671128a861305cc5f41b7437a7d4c88a0a7bb2
 SHA512:
-  metadata.gz: 8995e6d99585aadc2add2e47b9d18829313dd29853468c706e0297a4361b633acbe593db5fcd34e0a2890cc1832f4758d95f74d3a10ad990fde0dc41e91f348b
-  data.tar.gz: c6e75132f957e688b23ef5499fc8af50189edeb470ed664ad3dab4ca5096a3a343e7e33902d98fb0db2113b7993610b8126ee20653bac026787c7c3397c9d380
+  metadata.gz: '09093059f97e4f6af87403c21e8eb3b834ba82acfaebfa9708992f7028304d59bfc32cad6a7c38b482d7045a535f6e7c1cbc379416e594ec2fcef65b9a17d445'
+  data.tar.gz: 03f1cf68155d2cf68431e032459363c43252c7bfe359e93a43db3f2cb3ef4827f784ea16ee7539ed34999ad30936a82f735c2eb57857773eb23c6d319ffa581e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polysearch (0.1.0)
+    polysearch (0.2.3)
       rails (>= 6.0)
 
 GEM
@@ -84,13 +84,9 @@ GEM
     marcel (1.0.1)
     method_source (1.0.0)
     mini_mime (1.0.3)
-    mini_portile2 (2.5.1)
     minitest (5.14.4)
     nio4r (2.5.7)
-    nokogiri (1.11.4)
-      mini_portile2 (~> 2.5.0)
-      racc (~> 1.4)
-    nokogiri (1.11.4-arm64-darwin)
+    nokogiri (1.11.5-arm64-darwin)
       racc (~> 1.4)
     parallel (1.20.1)
     parser (3.0.1.1)

data/README.md

@@ -1,6 +1,10 @@
+[![Lines of Code](http://img.shields.io/badge/lines_of_code-237-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
+
 # Polysearch
 
-#### Simplified polymorphic full text + similarity search based on postgres
+Simplified polymorphic full text + similarity search based on postgres.
+
+> NOTE: This project is narrower in scope and more opinionated than [pg_search](https://github.com/Casecommons/pg_search).
 
 ## Requirements
 
@@ -43,23 +47,43 @@
       after_save_commit :update_polysearch
 
       def to_tsvectors
-        []
-          .then { |list| list << make_tsvector(first_name, weight: "A") }
-          .then { |list| list << make_tsvector(last_name, weight: "A") }
-          .then { |list| list << make_tsvector(email, weight: "B") }
+        [
+          make_tsvector(first_name, weight: "A"),
+          make_tsvector(last_name, weight: "A"),
+          make_tsvector(nickname, weight: "B")
+        ]
       end
     end
     ```
 
-1. Start searching
+    If you have existing records that need to create/update a polysearch record, you can save them like this.
 
+    ```ruby
+    User.find_each(&:update_polysearch)
     ```
-    User.create first_name: "Nate", last_name: "Hopkins", email: "nhopkins@mailinator.com"
 
-    User.polysearch("nate")
-    User.polysearch("ntae") # misspellings also return results
-    User.polysearch("nate").where(created_at: 1.day.ago..Current.time) # active record chaining
-    User.polysearch("nate").order(created_at: :desc) # chain additional ordering after the polysearch scope
+1. Start searching
+
+    ```ruby
+    User.create first_name: "Shawn", last_name: "Spencer", nickname: "Maverick"
+
+    # find natural language matches (faster)
+    User.full_text_search("shawn")
+
+    # find similarity matches, best for misspelled search terms (slower)
+    User.similarity_search("shwn")
+
+    # perform both a full text search and similarity search
+    User.combined_search("shwn")
+
+    # perform a full text search and fall back to similarity search (faster than combined_search)
+    User.polysearch("shwn")
+
+    # calculate counts (explicitly pass :id to omit search rankings)
+    User.full_text_search("shawn").count(:id)
+    User.similarity_search("shwn").count(:id)
+    User.combined_search("shwn").count(:id)
+    User.polysearch("shwn").count(:id)
     ```
 
 ## License

data/app/models/{record.rb → polysearch/record.rb}

@@ -33,39 +33,57 @@ module Polysearch
 
     # scopes ....................................................................
 
-    scope :select_fts_rank, ->(value, *selects, rank_alias: nil) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), value])
+    scope :select_full_text_search_rank, ->(value, *selects) {
+      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), arel_search_value(value)])
       ts_rank = Arel::Nodes::NamedFunction.new("ts_rank", [arel_table[:value], plainto_tsquery])
-
-      rank_alias ||= "fts_rank"
       selects << Arel.star if selects.blank?
-      selects << ts_rank.as(rank_alias)
-      select(*selects).order("#{rank_alias} desc")
+      selects << ts_rank.as("search_rank")
+      select(*selects).reorder("search_rank desc")
     }
 
-    scope :fts, ->(value) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), value])
-      where(Arel::Nodes::InfixOperation.new("@@", arel_table[:value], plainto_tsquery))
+    scope :full_text_search, ->(value) {
+      if value.blank?
+        all
+      else
+        plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), arel_search_value(value)])
+        where(Arel::Nodes::InfixOperation.new("@@", arel_table[:value], plainto_tsquery))
+      end
     }
 
-    scope :select_similarity_rank, ->(value, *selects, rank_alias: nil) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-
-      rank_alias ||= "similarity_rank"
+    scope :select_similarity_rank, ->(value, *selects) {
+      similarity = Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], arel_search_value(value)])
       selects << Arel.star if selects.blank?
-      selects << Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], value]).as(rank_alias)
-      select(*selects).order("#{rank_alias} desc")
+      selects << similarity.as("search_rank")
+      select(*selects).order("search_rank desc")
+    }
+
+    scope :similarity_search, ->(value) {
+      if value.blank?
+        all
+      else
+        where Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], arel_search_value(value)]).gt(0)
+      end
+    }
+
+    scope :combined_search, ->(value) {
+      subquery = <<~SQL
+        (
+          #{select_full_text_search_rank(value).full_text_search(value).except(:order).to_sql}
+          UNION ALL
+          #{select_similarity_rank(value).similarity_search(value).except(:order).to_sql}
+        ) AS #{table_name}
+      SQL
+      from(subquery).order("search_rank desc")
     }
 
-    scope :similar, ->(value, range: 0.01) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      where Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], value]).gteq(range)
+    scope :polysearch, ->(value) {
+      if value.blank?
+        all
+      else
+        full_text_search(value).exists? ?
+          select_full_text_search_rank(value).full_text_search(value) :
+          select_similarity_rank(value).similarity_search(value)
+      end
     }
 
     # additional config (i.e. accepts_nested_attribute_for etc...) ..............
@@ -74,6 +92,10 @@ module Polysearch
 
     # class methods .............................................................
     class << self
+      def arel_search_value(value)
+        value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
+        Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value]))
+      end
     end
 
     # public instance methods ...................................................

data/app/models/{concerns → polysearch}/searchable.rb

@@ -36,39 +36,54 @@ module Polysearch
       has_one :polysearch, as: :searchable, class_name: "Polysearch::Record", inverse_of: "searchable"
       after_destroy :destroy_polysearch
 
+      scope :full_text_search, ->(value) {
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.full_text_search(value).select_full_text_search_rank(value))
+      }
+
+      scope :similarity_search, ->(value) {
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.similarity_search(value).select_similarity_rank(value))
+      }
+
+      scope :combined_search, ->(value) {
+        subquery = <<~SQL
+          (
+            SELECT #{table_name}.*, searchable_polysearches.search_rank from (#{Polysearch::Record.combined_search(value).except(:order).to_sql}) searchable_polysearches
+            LEFT JOIN LATERAL (select * from #{table_name} WHERE id = searchable_polysearches.searchable_id) #{table_name} ON TRUE
+          ) #{table_name}
+        SQL
+        from(subquery).order("search_rank desc")
+      }
+
       scope :polysearch, ->(value) {
-        if value.blank?
-          all
-        else
-          fts_rank_alias = "#{table_name.singularize}_fts_rank"
-          similarity_rank_alias = "#{table_name.singularize}_similarity_rank"
-
-          fts = Polysearch::Record
-            .select_fts_rank(value, :searchable_id, rank_alias: fts_rank_alias)
-            .select_similarity_rank(value, :searchable_id, rank_alias: similarity_rank_alias)
-            .where(searchable_type: name)
-            .fts(value).or(Polysearch::Record.similar(value))
-
-          query = <<~SQL
-            SELECT searchables.*, fts.#{fts_rank_alias}, fts.#{similarity_rank_alias} from (#{fts.to_sql}) fts
-            LEFT JOIN LATERAL (select * from #{table_name} WHERE id = fts.searchable_id) searchables ON TRUE
-          SQL
-
-          select(Arel.star).from(Arel::Nodes::SqlLiteral.new("(#{query})").as(table_name))
-            .reorder(fts_rank_alias => :desc, similarity_rank_alias => :desc)
-        end
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.polysearch(value))
       }
     end
 
     def update_polysearch
+      return unless persisted?
       tsvectors = to_tsvectors.compact.uniq
       return if tsvectors.blank?
+
       tsvectors.pop while tsvectors.size > 500
       tsvectors.concat similarity_words_tsvectors
       tsvector = tsvectors.join(" || ")
-      fts = Polysearch::Record.where(searchable: self).first_or_create
-      fts.update_value tsvector
-      fts.update_columns words: similarity_words.join(" ")
+
+      attributes = {
+        searchable_type: self.class.name,
+        searchable_id: id,
+        words: similarity_words.join(" "),
+        created_at: Time.current,
+        updated_at: Time.current
+      }
+
+      result = Polysearch::Record.upsert(
+        attributes,
+        unique_by: [:searchable_type, :searchable_id],
+        returning: :id
+      )
+
+      record = Polysearch::Record.find_by(id: result.first["id"])
+      record.update_value tsvector
     end
 
     # Polysearch::Searchable#to_tsvectors is abstract... a noop by default

data/bin/loc

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+cloc --exclude-dir=test --include-ext=rb .

data/lib/polysearch.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "polysearch/version"
-require_relative "../app/models/record"
-require_relative "../app/models/concerns/searchable"
+require_relative "../app/models/polysearch/record"
+require_relative "../app/models/polysearch/searchable"
 
 module Polysearch
   class Engine < Rails::Engine

data/lib/polysearch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polysearch
-  VERSION = "0.1.0"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polysearch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.3
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-18 00:00:00.000000000 Z
+date: 2021-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -92,9 +92,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- app/models/concerns/searchable.rb
-- app/models/record.rb
+- app/models/polysearch/record.rb
+- app/models/polysearch/searchable.rb
 - bin/console
+- bin/loc
 - bin/setup
 - bin/standardize
 - lib/generators/polysearch/migration_generator.rb