sequel-select-order-clauses 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b010f558103980a1604be1c1e9eaa84c7f357e7
-  data.tar.gz: ee47dd9e0ea2aef8d8c3997e2cd48d37a2beb326
+  metadata.gz: 23c244348f2b9b13024c0efadd677d4b6277bd32
+  data.tar.gz: 4579d5faa4e299881cce4e77c0d98306ba00f968
 SHA512:
-  metadata.gz: a3123d4161d388842ea289034b50b79546b0751033038085e6e900a3f9618c804d236b73752f0454aa95d63dbc4a8e7888329dd727394c3e8c31f665f54f126d
-  data.tar.gz: e4f1887ec9d649f5e8140bd4b924739df3e6220d55089cc38b959b5228d7a1c497eb9c91afa5faddbe2f206877bdf29e6cd70f10a6e655676adf51ff5ede8184
+  metadata.gz: afa8d9d6a552aad12cbb589e02d91ffe6fbd51ce3bd96a5a5d7722e681a04acf1aceb480881877eee6dca95658306899a971a3cef5e2a9ddeb383d5ad51ebd8e
+  data.tar.gz: 2f075bb2aa65d3ce7593861af10213de199ba0ead4fa827562348aac0869e83f07a3854152e46c45c4b76e1f64675bded6ec174904f4e5f469a5bffd29afcaf8

data/lib/sequel/extensions/select_order_clauses.rb

@@ -5,66 +5,83 @@ require 'sequel/extensions/select_order_clauses/version'
 
 module Sequel
   module SelectOrderClauses
+    def select_order
+      return self unless order = @opts[:order]
+
+      cached_dataset(:_select_order_ds) do
+        select(
+          *order.map.with_index { |o, index|
+            Sequel.as(
+              normalize_expression(unwrap_order_expression(o)),
+              "order_#{index}".to_sym,
+            )
+          }
+        )
+      end
+    end
+
     def append_order_as_selection
       return self unless order = @opts[:order]
       return self if @opts[:order_info]
 
-      # Note that since we're iterating over the order to return a modified
-      # version of this dataset, we can't modify the order in this method and
-      # remain sensible.
-      ds = self
-
-      selections = extract_selections(ds).map { |s| normalize_selection(s) }
-
-      order_info =
-        order.map.with_index do |o, index|
-          exp = normalize_expression(unwrap_order_expression(o))
-          dir = extract_direction(o)
-
-          # Try to figure out which of the select expressions is going to
-          # correspond to this order expression. This heuristic may not be
-          # perfect, but do our best and raise an error if we find more than one
-          # selection.
-          expression_selects =
-            selections.select do |s|
-              selection_satisfies_expression?(s, exp)
-            end
+      cached_dataset(:_append_order_as_selection_ds) do
+        # Note that since we're iterating over the order to return a modified
+        # version of this dataset, we can't modify the order in this method and
+        # remain sensible.
+        ds = self
+
+        selections = extract_selections(ds).map { |s| normalize_selection(s) }
+
+        order_info =
+          order.map.with_index do |o, index|
+            exp = normalize_expression(unwrap_order_expression(o))
+            dir = extract_direction(o)
 
-          name =
-            case expression_selects.length
-            when 0 then nil
-            when 1
-              expression_select = expression_selects.first
-
-              # Once we have the SELECT expression that matches our ORDER BY
-              # expression, we just extract its name so that we'll be able to
-              # figure out how we sorted records later on. The exception is if
-              # the matching SELECT expression is "table".* - in that case
-              # we'll need to get the name from the ORDER BY expression.
-              target_expression =
-                if expression_select.is_a?(Sequel::SQL::ColumnAll)
-                  exp
-                else
-                  expression_select
-                end
-
-              extract_expression_name(target_expression)
-            else
-              raise "Found more than one selection in #{inspect} that matched the expression #{exp.inspect}: #{expression_selects.inspect}"
+            # Try to figure out which of the select expressions is going to
+            # correspond to this order expression. This heuristic may not be
+            # perfect, but do our best and raise an error if we find more than one
+            # selection.
+            expression_selects =
+              selections.select do |s|
+                selection_satisfies_expression?(s, exp)
+              end
+
+            name =
+              case expression_selects.length
+              when 0 then nil
+              when 1
+                expression_select = expression_selects.first
+
+                # Once we have the SELECT expression that matches our ORDER BY
+                # expression, we just extract its name so that we'll be able to
+                # figure out how we sorted records later on. The exception is if
+                # the matching SELECT expression is "table".* - in that case
+                # we'll need to get the name from the ORDER BY expression.
+                target_expression =
+                  if expression_select.is_a?(Sequel::SQL::ColumnAll)
+                    exp
+                  else
+                    expression_select
+                  end
+
+                extract_expression_name(target_expression)
+              else
+                raise "Found more than one selection in #{inspect} that matched the expression #{exp.inspect}: #{expression_selects.inspect}"
+              end
+
+            # After all that, we still might not have been able to get a name.
+            # In that case, just append the ORDER BY expression to the SELECT
+            # clause with a special alias that we'll use later.
+            unless name
+              name = "order_#{index}".to_sym
+              ds = ds.select_append(Sequel.as(exp, name))
             end
 
-          # After all that, we still might not have been able to get a name.
-          # In that case, just append the ORDER BY expression to the SELECT
-          # clause with a special alias that we'll use later.
-          unless name
-            name = "order_#{index}".to_sym
-            ds = ds.select_append(Sequel.as(exp, name))
+            {name: name, direction: dir}.freeze
           end
 
-          {name: name, direction: dir}
-        end
-
-      ds.clone(order_info: order_info)
+        ds.clone(order_info: order_info.freeze)
+      end
     end
 
     private

data/lib/sequel/extensions/select_order_clauses/version.rb

@@ -2,6 +2,6 @@
 
 module Sequel
   module SelectOrderClauses
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/spec/select_order_clauses_spec.rb

@@ -5,6 +5,35 @@ class SelectOrderClausesSpec < Minitest::Spec
     assert Sequel::SelectOrderClauses::VERSION.is_a?(String)
   end
 
+  describe "select_order" do
+    def assert_select_order(ds:, selects:)
+      initial = ds
+      final = ds.select_order
+
+      assert_equal selects, final.opts[:select]
+
+      # Make sure that dataset is cached.
+      assert_equal final.object_id, ds.select_order.object_id
+    end
+
+    it "should select only the order clauses" do
+      assert_select_order(
+        ds: User.dataset,
+        selects: nil,
+      )
+
+      assert_select_order(
+        ds: User.dataset.order_by(Sequel.desc(:id)),
+        selects: [Sequel.as(:id, :order_0)],
+      )
+
+      assert_select_order(
+        ds: User.dataset.order_by(Sequel.desc(:id), :other_column),
+        selects: [Sequel.as(:id, :order_0), Sequel.as(:other_column, :order_1)],
+      )
+    end
+  end
+
   describe "append_order_as_selection" do
     def assert_order_append(ds:, selects_to_append:, order_names:)
       initial = ds
@@ -15,6 +44,9 @@ class SelectOrderClausesSpec < Minitest::Spec
       order_info = final.opts.fetch(:order_info)
 
       assert_equal order_names, order_info.map { |h| h.fetch(:name) }
+
+      # Make sure that dataset is cached.
+      assert_equal final.object_id, ds.append_order_as_selection.object_id
     end
 
     it "should do nothing to queries without order_by clauses" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-select-order-clauses
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-05 00:00:00.000000000 Z
+date: 2017-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler