order_query 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14a1cc9219fd6bb2221967eef338dcabee8854f1
-  data.tar.gz: e4a8c908c803e2c8afad23a0b278473043087cc7
+  metadata.gz: 04dd1e3cb69ac7b1cd363629e1449f2eec4bd921
+  data.tar.gz: 1d2533afcfea18fe8a1b06ac63dec068ef59cf8f
 SHA512:
-  metadata.gz: e93eb1ec39fab70c1895d34aeef9bbfab92c8da4b7c2962c7a822f4e0df5501331c4a5c733a471fdcfb61b287d4e9cebfd8ea668b258d957755e942011384ee1
-  data.tar.gz: 4ec32294d12907c1245607f2f2f79a9f205e9f7c7d7396f4b7a1bd1877fb597262cf29e7aa53d81aad512efc36a9737dbf68601f9828f69b7b16adaa77dc77eb
+  metadata.gz: f708515aa23195a7cb3051fca8848d1382190429ed9f2055cf0d0bc07b7b66b83c8792d5f1c3fdbbe6c7d3df2f62ec0571cc95755baeec621470c6464c838a05
+  data.tar.gz: 7650728e46013f47e129d9a4e939ef531c687bda7315f8326737d628f1b8bee509395a072c079e342d04e2e34640ea9cde5b4f504eed25625ee05082c61f0a3a

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.2.1
+
+* `complete` now defaults to true for list attributes as well.
+
 ## 0.2.0
 
 * Dynamic query methods renamed to `order_by`

data/README.md

@@ -16,7 +16,7 @@ This is slow. Here is where `order_query` comes in!
 Add to Gemfile:
 
 ```ruby
-gem 'order_query', '~> 0.2.0'
+gem 'order_query', '~> 0.2.1'
 ```
 
 ## Usage
@@ -27,7 +27,7 @@ Define a list of order conditions with `order_query`:
 class Post < ActiveRecord::Base
   include OrderQuery
   order_query :order_for_index, [
-    [:pinned, [true, false], complete: true],
+    [:pinned, [true, false]],
     [:published_at, :desc],
     [:id, :desc]
   ]
@@ -37,11 +37,11 @@ end
 An order condition is specified as an attribute name, optionally an ordered list of values, and a sort direction.
 Additional options are:
 
-| option     | description                                                                                             |
-|------------|---------------------------------------------------------------------------------------------------------|
-| unique     | Unique attribute, avoids redundant comparisons. Default: `true` for primary key, `false` otherwise.     |
-| complete   | Complete attribute, avoids redundant comparisons. Default: `false` for ordered lists, `true` otherwise. |
-| sql        | Customize attribute value SQL                                                                           |
+| option     | description                                                                |
+|------------|----------------------------------------------------------------------------|
+| unique     | Unique attribute. Default: `true` for primary key, `false` otherwise.      |
+| complete   | Enum attribute contains all the possible values. Default: `true`.          |
+| sql        | Customize attribute value SQL                                              |
 
 ### Order scopes
 
@@ -77,7 +77,7 @@ class Issue < ActiveRecord::Base
   order_query :order_display, [
     # Pass an array for attribute order, and an optional sort direction for the array,
     # default is *:desc*, so that first in the array <=> first in the result
-    [:priority, %w(high medium low), :desc, complete: true],
+    [:priority, %w(high medium low), :desc],
     # Sort attribute can be a method name, provided you pass :sql for the attribute
     [:valid_votes_count, :desc, sql: '(votes - suspicious_votes)'],
     # Default sort order for non-array attributes is :asc, just like SQL
@@ -164,8 +164,9 @@ ORDER BY
 LIMIT 1
 ```
 
-The top-level `x0 OR ..` clause is actually wrapped with `x0' AND (x0 OR ...)`, where *x0'* is a non-strict condition,
-for [performance reasons](https://github.com/glebm/order_query/issues/3). This can be disabled with `OrderQuery::WhereBuilder.wrap_top_level_or = false`.
+The actual query is a bit different because `order_query` wraps the top-level `OR` with a (redundant) non-strict condition `x0' AND (x0 OR ...)`
+for [performance reasons](https://github.com/glebm/order_query/issues/3).
+This can be disabled with `OrderQuery.wrap_top_level_or = false`.
 
 See how this affects query planning in Markus Winand's slides on [Pagination done the Right Way](http://use-the-index-luke.com/blog/2013-07/pagination-done-the-postgresql-way).
 

data/lib/order_query/condition.rb

@@ -16,18 +16,12 @@ module OrderQuery
         else
           @order = spec[1] || :asc
       end
-      @options  = options
-      @unique   = if options.key?(:unique)
-                    !!options[:unique]
-                  else
-                    name.to_s == scope.primary_key
-                  end
-      @complete = if options.key?(:complete)
-                    !!options[:complete]
-                  else
-                    !@order_enum
-                  end
-
+      @options  = options.reverse_merge(
+          unique:   name.to_s == scope.primary_key,
+          complete: true
+      )
+      @unique   = @options[:unique]
+      @complete = @options[:complete]
       @sql = SQL::Condition.new(self, scope)
     end
 
@@ -40,14 +34,17 @@ module OrderQuery
     end
 
     # @param [Object] value
-    # @param [:before, :after] mode
-    # @return [Array] valid order values before / after passed (depending on the mode)
-    def filter_values(value, mode, strict = true)
+    # @param [:before, :after] side
+    # @return [Array] valid order values before / after passed (depending on the side)
+    # @example for [:difficulty, ['Easy', 'Normal', 'Hard']]:
+    #  enum_side('Normal', :after) #=> ['Hard']
+    #  enum_side('Normal', :after, false) #=> ['Normal', 'Hard']
+    def enum_side(value, side, strict = true)
       ord = order_enum
       pos = ord.index(value)
       if pos
         dir = order
-        if mode == :after && dir == :desc || mode == :before && dir == :asc
+        if side == :after && dir == :desc || side == :before && dir == :asc
           ord.from pos + (strict ? 1 : 0)
         else
           ord.first pos + (strict ? 0 : 1)

data/lib/order_query/point.rb

@@ -48,19 +48,23 @@ module OrderQuery
 
     # @return [ActiveRecord::Relation]
     def after
-      records :after
+      side :after
     end
 
     # @return [ActiveRecord::Relation]
     def before
-      records :before
+      side :before
     end
 
-    # @param [:before, :after] direction
+    # @param [:before, :after] side
     # @return [ActiveRecord::Relation]
-    def records(direction)
-      query, query_args = @where_sql.build(direction)
-      scope = (direction == :after ? space.scope : space.reverse_scope)
+    def side(side)
+      query, query_args = @where_sql.build(side)
+      scope = if side == :after
+                space.scope
+              else
+                space.reverse_scope
+              end
       if query.present?
         scope.where(query, *query_args)
       else
@@ -68,6 +72,10 @@ module OrderQuery
       end
     end
 
+    def value(cond)
+      record.send(cond.name)
+    end
+
     protected
 
     # @param [ActiveRecord::Base] rec

data/lib/order_query/sql/order_by.rb

@@ -22,15 +22,17 @@ module OrderQuery
 
       # @return [Array<String>]
       def order_by_sql_clauses
-        space.conditions.map { |cond|
-          if cond.order_enum
-            cond.order_enum.map { |v|
-              "#{cond.sql.column_name}=#{cond.sql.quote v} #{cond.order.to_s.upcase}"
-            }.join(', ').freeze
-          else
-            "#{cond.sql.column_name} #{sort_direction_sql cond.order}".freeze
-          end
-        }
+        space.conditions.map { |cond| condition_clause cond }
+      end
+
+      def condition_clause(cond)
+        dir_sql = sort_direction_sql cond.order
+        col_sql = cond.sql.column_name
+        if cond.order_enum
+          cond.order_enum.map { |v| "#{col_sql}=#{cond.sql.quote v} #{dir_sql}" }.join(', ').freeze
+        else
+          "#{col_sql} #{dir_sql}".freeze
+        end
       end
 
       SORT_DIRECTIONS = [:asc, :desc].freeze

data/lib/order_query/sql/where.rb

@@ -10,87 +10,97 @@ module OrderQuery
         @point = point
       end
 
-      # @param [:before or :after] mode
-      # @return [query, parameters] conditions that exclude all elements not before / after the current one
-      def build(mode)
-        conditions = point.space.conditions
-        # pairs of [x0, y0]
-        pairs = conditions.map { |cond|
-          [where_relative(cond, mode, true), (where_eq(cond) unless cond.unique?)].reject { |x|
-            x.nil? || x == WHERE_IDENTITY || x == WHERE_NONE
-          }.compact
+      # Join condition pairs with OR, and nest within each other with AND
+      # @param [:before or :after] side
+      # @return [query, parameters] WHERE conditions matching records strictly before / after this one
+      #   sales < 5 OR
+      #   sales = 5 AND (
+      #     invoice < 3 OR
+      #     invoices = 3 AND (
+      #       ... ))
+      def build(side)
+        # generate pairs of terms such as sales < 5, sales = 5
+        parts = point.space.conditions.map { |cond|
+          [where_side(cond, side, true), where_tie(cond)].reject { |x| x == WHERE_IDENTITY }
         }
-        query = group_operators pairs
-        return query unless ::OrderQuery.wrap_top_level_or
-        # Wrap top level OR clause for performance, see https://github.com/glebm/order_query/issues/3
+        # group pairwise with OR, and nest with AND
+        query = foldr_terms parts.map { |terms| join_terms 'OR'.freeze, *terms }, 'AND'.freeze
+        if ::OrderQuery.wrap_top_level_or
+          # wrap in a redundant AND clause for performance
+          query = wrap_top_level_or query, parts, side
+        end
+        query
+      end
+
+      protected
+
+      # @param [String] sql_operator SQL operator
+      # @return [query, params] terms right-folded with sql_operator
+      #   [A, B, C, ...] -> A AND (B AND (C AND ...))
+      def foldr_terms(terms, sql_operator)
+        foldr_i WHERE_IDENTITY, terms do |a, b, i|
+          join_terms sql_operator, a, (i > 1 ? wrap_term_with_parens(b) : b)
+        end
+      end
+
+      # joins terms with an operator
+      # @return [query, parameters]
+      def join_terms(op, *terms)
+        [terms.map(&:first).reject(&:empty?).join(" #{op} "), terms.map(&:second).reduce([], :+)]
+      end
+
+      def wrap_term_with_parens(t)
+        ["(#{t[0]})", t[1]]
+      end
+
+      # Wrap top level OR clause to help DB with using the index
+      # Before:
+      #   (sales < 5 OR
+      #     (sales = 5 AND ...))
+      # After:
+      #   (sales <= 5 AND
+      #    (sales < 5 OR
+      #       (sales = 5 AND ...)))
+      # Read more at https://github.com/glebm/order_query/issues/3
+      def wrap_top_level_or(query, pairs, side)
         top_pair_idx = pairs.index(&:present?)
         if top_pair_idx &&
             (top_pair = pairs[top_pair_idx]).length == 2 &&
-            (top_level_cond = conditions[top_pair_idx]) &&
-            (redundant_cond = where_relative(top_level_cond, mode, false)) != top_pair.first
-          join_terms 'AND'.freeze, redundant_cond, wrap_parens(query)
+            top_pair.first != (redundant_cond = where_side(point.space.conditions[top_pair_idx], side, false))
+          join_terms 'AND'.freeze, redundant_cond, wrap_term_with_parens(query)
         else
           query
         end
       end
 
-      # Join condition pairs internally with OR, and nested within each other with AND
-      # @param [Array] term_pairs of query terms [[x0, y0], [x1, y1], ...],
-      #                xi, yi are pairs of [query, parameters]
-      # @return [query, parameters]
-      #   x0 OR
-      #   y0 AND (x1 OR
-      #           y1 AND (x2 OR
-      #                   y2 AND x3))
-      #
-      # Since x matches order criteria with values that come before / after the current record,
-      # and y matches order criteria with values equal to the current record's value (for resolving ties),
-      # the resulting condition matches just the elements that come before / after the record
-      def group_operators(term_pairs)
-        # create "x OR y" string
-        disjunctive = join_terms 'OR'.freeze, *term_pairs[0]
-        rest        = term_pairs.from(1)
-        if rest.present?
-          # nest the remaining pairs recursively, appending them with " AND "
-          rest_grouped = group_operators rest
-          join_terms 'AND'.freeze, disjunctive, (rest.length == 1 ? rest_grouped : wrap_parens(rest_grouped))
+      # @return [query, params] tie-breaker unless condition is unique
+      def where_tie(cond)
+        if cond.unique?
+          WHERE_IDENTITY
         else
-          disjunctive
+          where_eq(cond)
         end
       end
 
-      def wrap_parens(t)
-        ["(#{t[0]})", t[1]]
-      end
-
-      # joins terms with an operator
-      # @return [query, parameters]
-      def join_terms(op, *terms)
-        [terms.map { |t| t.first.presence }.compact.join(" #{op} "),
-         terms.map(&:second).reduce(:+) || []]
-      end
-
-      # @param [:before or :after] mode
+      # @param [:before or :after] side
       # @return [query, params] return query conditions for attribute values before / after the current one
-      def where_relative(cond, mode, strict = true)
-        value = attr_value cond
+      def where_side(cond, side, strict = true, value = point.value(cond))
         if cond.order_enum
-          values = cond.filter_values(value, mode, strict)
+          values = cond.enum_side(value, side, strict)
           if cond.complete? && values.length == cond.order_enum.length
             WHERE_IDENTITY
           else
             where_in cond, values
           end
         else
-          where_ray cond, value, mode, strict
+          where_ray cond, value, side, strict
         end
       end
 
-
       def where_in(cond, values)
         case values.length
           when 0
-            WHERE_NONE
+            WHERE_IDENTITY
           when 1
             where_eq cond, values[0]
           else
@@ -98,7 +108,7 @@ module OrderQuery
         end
       end
 
-      def where_eq(cond, value = attr_value(cond))
+      def where_eq(cond, value = point.value(cond))
         [%Q(#{cond.sql.column_name} = ?).freeze, [value]]
       end
 
@@ -110,10 +120,16 @@ module OrderQuery
       end
 
       WHERE_IDENTITY = [''.freeze, [].freeze].freeze
-      WHERE_NONE     = ['∅'.freeze, [].freeze].freeze
 
-      def attr_value(cond)
-        point.record.send cond.name
+      private
+
+      # Inject with index from right to left, turning [a, b, c] into a + (b + c)
+      # Passes an index to the block, counting from the right
+      # Read more about folds:
+      # * http://www.haskell.org/haskellwiki/Fold
+      # * http://en.wikipedia.org/wiki/Fold_(higher-order_function)
+      def foldr_i(z, xs, &f)
+        xs.reverse_each.each_with_index.inject(z) { |b, (a, i)| f.call a, b, i }
       end
     end
   end

data/lib/order_query/version.rb

@@ -1,3 +1,3 @@
 module OrderQuery
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/order_query_spec.rb

@@ -88,7 +88,7 @@ describe 'OrderQuery' do
             issues = ds.map do |attr|
               Issue.new(priority: attr[0], votes: attr[1], suspicious_votes: attr[2], updated_at: attr[3])
             end
-            issues.reverse_each(&:save!)
+            issues.shuffle.reverse_each(&:save!)
             expect(Issue.display_order.to_a).to eq(issues)
             issues.each_slice(2) do |prev, cur|
               cur ||= issues.first

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: order_query
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Gleb Mazovetskiy