sequel-select-order-clauses 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4596afa94f19b82c39ae79479131ff6c60643740
+  data.tar.gz: 1eb6f016f4d7ea86d33891dc3cb85b1e508b0f16
+SHA512:
+  metadata.gz: 0dd46ee1b0e93733b06ba789868d0c0990433bf75cf530e8ea2afb6a33566194d3f62607549ba88827abe0aa9fbafae05561b92b7e72fc9b7b94f356e1fb0ed4
+  data.tar.gz: cb3caecd7a4132fb3fd74339b0d8c91d8894960a0b8dd6e5d82080c1385e65e534665a208d7ef69fd4ee6d8dbd35340b72b10806b443c4f3ad0f2f5229bed654

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'minitest',    '5.5.1'
+  gem 'minitest-rg', '5.1.0'
+
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Chris Hanks
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# Sequel::SelectOrderClauses

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler/gem_tasks'
+
+Dir["./tasks/*.rb"].sort.each &method(:require)

data/lib/sequel-select-order-clauses.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'sequel/extensions/select_order_clauses'

data/lib/sequel/extensions/select_order_clauses.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'sequel/extensions/select_order_clauses/version'
+
+module Sequel
+  module SelectOrderClauses
+    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
+
+          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
+
+          {name: name, direction: dir}
+        end
+
+      ds.clone(order_info: order_info)
+    end
+
+    private
+
+    # Our inputs should have already been simplified and normalized to the
+    # extent possible, now the nitty-gritty of defining whatever equality
+    # logic we really need to for them.
+
+    # The question at hand: can we safely assume that this expression in the
+    # SELECT clause will always represent this expression in the ORDER BY?
+    def selection_satisfies_expression?(s, e)
+      case s
+      when Sequel::SQL::AliasedExpression
+        # Order expressions can be simple references to aliases, which is a
+        # pretty simple and useful case to check for. In other words:
+        # `SELECT function() AS my_value FROM table ORDER BY my_value`
+        if e.is_a?(Symbol) && s.aliaz == e
+          true
+        else
+          # Otherwise, see whether the expression being aliased does what we
+          # want. For example:
+          # `SELECT function() AS my_value FROM table ORDER BY function()`
+          selection_satisfies_expression?(normalize_selection(s.expression), e)
+        end
+      when Sequel::SQL::QualifiedIdentifier
+        # SELECT "table"."column"
+        case e
+        when Symbol
+          # SELECT "table"."column" FROM "table" ORDER BY "column"
+          s.column == e
+        when Sequel::SQL::QualifiedIdentifier
+          # SELECT "table"."column" FROM "table" ORDER BY "table"."column"
+          s == e
+        end
+      when Sequel::SQL::ColumnAll
+        # SELECT "table".*
+        case e
+        when Sequel::SQL::QualifiedIdentifier
+          # Satisfies any column anchored on that table...
+          s.table == e.table
+        when Symbol
+          # ...or a plain column reference that we can verify lives on this
+          # model. Note that m.columns.include?(e) would leave out
+          # lazy-loaded columns.
+          respond_to?(:model) &&
+            (m = model) &&
+            m.table_name == s.table &&
+            m.db_schema.has_key?(e)
+        end
+      else
+        # These values could be anything - functions, mathematical operations,
+        # literal SQL strings, etc. Just try for simple equality.
+        s == e
+      end
+    end
+
+    # In addition to the common normalization logic in normalize_expression(),
+    # which can be applied to expressions in either the SELECT or ORDER BY
+    # clauses, this method encapsulates an assumption that is safe to make
+    # about expressions in SELECT but not in ORDER BY, that a simple
+    # identifier (a symbol) on a single-source dataset must refer to a column
+    # in the table. In an ORDER BY clause it could also refer to an alias in
+    # the SELECT clause.
+    def normalize_selection(s)
+      s = normalize_expression(s)
+
+      case s
+      when Symbol
+        if joined_dataset?
+          s # Can't make any assumptions about the source table.
+        else
+          Sequel.qualify(first_source, s)
+        end
+      else
+        s
+      end
+    end
+
+    # Move more esoteric Sequel types to the baseline of symbols representing
+    # identifiers and QualifiedIdentifiers representing table-column pairs, so
+    # that it's easier for us to do comparisons without needing to define
+    # equality logic between every combination of classes in the Sequel AST.
+    def normalize_expression(expression)
+      case expression
+      when Symbol
+        # Take care of symbol notations like :table__column___alias.
+        table, column, aliaz =
+          Sequel.split_symbol(expression).map { |part| part&.to_sym }
+
+        exp = table ? Sequel.qualify(table, column) : column
+        exp = Sequel.as(exp, aliaz) if aliaz
+        exp
+      when Sequel::SQL::Identifier
+        # Identifier objects have their uses, but not here, where a symbol is
+        # just fine.
+        expression.value.to_sym
+      when Sequel::SQL::QualifiedIdentifier
+        t = expression.table
+        c = expression.column
+
+        if t.is_a?(Symbol) && c.is_a?(Symbol)
+          expression
+        else
+          Sequel::SQL::QualifiedIdentifier.new(
+            normalize_expression(t),
+            normalize_expression(c),
+          )
+        end
+      else
+        # Other arbitrary expressions can just be passed through.
+        expression
+      end
+    end
+
+    def extract_selections(ds)
+      if selections = ds.opts[:select]
+        return selections
+      end
+
+      if (froms = ds.opts[:from]) && froms.length == 1
+        from = unwrap_alias(froms.first)
+        if from.is_a?(Sequel::Dataset)
+          extract_selections(from)
+        end
+      end
+    end
+
+    def extract_expression_name(expression)
+      case expression
+      when Symbol
+        expression
+      when Sequel::SQL::AliasedExpression
+        expression.aliaz
+      when Sequel::SQL::Identifier
+        extract_expression_name(expression.value)
+      when Sequel::SQL::QualifiedIdentifier
+        extract_expression_name(expression.column)
+      end
+    end
+
+    def unwrap_order_expression(order)
+      case order
+      when Sequel::SQL::OrderedExpression
+        order.expression
+      else
+        order
+      end
+    end
+
+    def unwrap_alias(expression)
+      case expression
+      when Sequel::SQL::AliasedExpression
+        expression.expression
+      else
+        expression
+      end
+    end
+
+    def extract_direction(order)
+      case order
+      when Sequel::SQL::OrderedExpression
+        order.descending ? :desc : :asc
+      else
+        :asc
+      end
+    end
+  end
+
+  Dataset.register_extension(:select_order_clauses, SelectOrderClauses)
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sequel
+  module SelectOrderClauses
+    VERSION = '0.0.1'
+  end
+end

data/sequel-select-order-clauses.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sequel/extensions/select_order_clauses/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sequel-select-order-clauses'
+  spec.version       = Sequel::SelectOrderClauses::VERSION
+  spec.authors       = ["Chris Hanks"]
+  spec.email         = ['christopher.m.hanks@gmail.com']
+  spec.summary       = %q{Select the order clauses in a dataset}
+  spec.description   = %q{Simple support for selecting the order clauses in a dataset}
+  spec.homepage      = 'https://github.com/chanks/sequel-select-order-clauses'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sqlite3'
+
+  spec.add_dependency 'sequel', '~> 4.0'
+end

data/spec/select_order_clauses_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+class SelectOrderClausesSpec < Minitest::Spec
+  it "should have a version" do
+    assert Sequel::SelectOrderClauses::VERSION.is_a?(String)
+  end
+
+  describe "append_order_as_selection" do
+    def assert_order_append(ds:, selects_to_append:, order_names:)
+      initial = ds
+      final = ds.append_order_as_selection
+
+      assert_equal (initial.opts[:select] || []) + selects_to_append, final.opts[:select] || []
+
+      order_info = final.opts.fetch(:order_info)
+
+      assert_equal order_names, order_info.map { |h| h.fetch(:name) }
+    end
+
+    it "should do nothing to queries without order_by clauses" do
+      assert_equal User.dataset, User.dataset.append_order_as_selection
+    end
+
+    describe "for simple symbol columns" do
+      it "when they are missing" do
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(:description),
+          selects_to_append: [Sequel.as(:description, :order_0)],
+          order_names: [:order_0]
+
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(:fake_column),
+          selects_to_append: [Sequel.as(:fake_column, :order_0)],
+          order_names: [:order_0]
+      end
+
+      it "when they are present" do
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(:id),
+          selects_to_append: [],
+          order_names: [:id]
+
+        assert_order_append \
+          ds: User.dataset.select(:created_at).order_by(:created_at),
+          selects_to_append: [],
+          order_names: [:created_at]
+      end
+    end
+
+    describe "when the dataset has been made via #from_self" do
+      it "when they are present" do
+        assert_order_append \
+          ds: User.dataset.select(:id).from_self.order_by(:id),
+          selects_to_append: [],
+          order_names: [:id]
+
+        assert_order_append \
+          ds: User.dataset.select(:users__created_at).from_self.order_by(:created_at),
+          selects_to_append: [],
+          order_names: [:created_at]
+      end
+    end
+
+    describe "for qualified columns" do
+      it "when they are missing" do
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(Sequel.qualify(:other_table, :fake_column)),
+          selects_to_append: [Sequel.qualify(:other_table, :fake_column).as(:order_0)],
+          order_names: [:order_0]
+
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(:other_table__fake_column),
+          selects_to_append: [Sequel.qualify(:other_table, :fake_column).as(:order_0)],
+          order_names: [:order_0]
+      end
+
+      it "when they are present" do
+        assert_order_append \
+          ds: User.dataset.select(Sequel.qualify(:users, :id)).order_by(:id),
+          selects_to_append: [],
+          order_names: [:id]
+
+        assert_order_append \
+          ds: User.dataset.select(Sequel.qualify(:users, Sequel::SQL::Identifier.new(:id))).order_by(:id),
+          selects_to_append: [],
+          order_names: [:id]
+
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(Sequel.qualify(:users, :id)),
+          selects_to_append: [],
+          order_names: [:id]
+
+        assert_order_append \
+          ds: User.dataset.select(:created_at).order_by(:users__created_at),
+          selects_to_append: [],
+          order_names: [:created_at]
+      end
+    end
+
+    describe "for columns with aliases" do
+      it "should recognize that ORDER BY can take either the column name or its alias" do
+        assert_order_append \
+          ds: User.dataset.select(Sequel.as(:description, :des)).order_by(:des),
+          selects_to_append: [],
+          order_names: [:des]
+
+        assert_order_append \
+          ds: User.dataset.select(Sequel.as(:description, :des)).order_by(:description),
+          selects_to_append: [],
+          order_names: [:des]
+      end
+
+      it "that are also qualified" do
+        assert_order_append \
+          ds: User.dataset.select(Sequel.qualify(:users, :description).as(:des)).order_by(:description),
+          selects_to_append: [],
+          order_names: [:des]
+
+        assert_order_append \
+          ds: User.dataset.select(Sequel.qualify(:users, :description).as(:des)).order_by(:des),
+          selects_to_append: [],
+          order_names: [:des]
+
+        assert_order_append \
+          ds: User.dataset.select(Sequel.as(:description, :des)).order_by(Sequel.qualify(:users, :description)),
+          selects_to_append: [],
+          order_names: [:des]
+
+        assert_order_append \
+          ds: User.dataset.select(:created_at___c_at).order_by(:users__created_at),
+          selects_to_append: [],
+          order_names: [:c_at]
+
+        assert_order_append \
+          ds: User.dataset.select(Sequel.qualify(:users, :description).as(:des)).order_by(:description),
+          selects_to_append: [],
+          order_names: [:des]
+      end
+    end
+
+    describe "when ordering by arbitrary expressions" do
+      it "when they are missing" do
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by{function(:column1, 2)},
+          selects_to_append: [Sequel.virtual_row{function(:column1, 2)}.as(:order_0)],
+          order_names: [:order_0]
+
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by{column - 2},
+          selects_to_append: [Sequel.virtual_row{column - 2}.as(:order_0)],
+          order_names: [:order_0]
+
+        assert_order_append \
+          ds: User.dataset.select(:id).order_by(Sequel.lit('function(column1, 2)')),
+          selects_to_append: [Sequel.lit('function(column1, 2)').as(:order_0)],
+          order_names: [:order_0]
+      end
+
+      it "when they are present" do
+        assert_order_append \
+          ds: User.dataset.select{function(:column1, 2).as(:my_column)}.order_by{function(:column1, 2)},
+          selects_to_append: [],
+          order_names: [:my_column]
+      end
+
+      it "when they are present but don't have a name we can safely predict" do
+        assert_order_append \
+          ds: User.dataset.select{function(:column1, 2)}.order_by{function(:column1, 2)},
+          selects_to_append: [Sequel.virtual_row{function(:column1, 2)}.as(:order_0)],
+          order_names: [:order_0]
+      end
+    end
+
+    describe "when a selection includes a ColumnAll" do
+      describe "and is not connected to a model" do
+        it "when ordering by a column qualified to that table" do
+          assert_order_append \
+            ds: DB[:users].select_all(:users).order_by(Sequel.qualify(:users, :id)),
+            selects_to_append: [],
+            order_names: [:id]
+        end
+
+        it "when ordering by a column qualified to a different table" do
+          assert_order_append \
+            ds: DB[:users].select_all(:users).order_by(Sequel.qualify(:users_2, :id)),
+            selects_to_append: [Sequel.qualify(:users_2, :id).as(:order_0)],
+            order_names: [:order_0]
+        end
+
+        it "when ordering by an unqualified column" do
+          assert_order_append \
+            ds: DB[:users].select_all(:users).order_by(:id),
+            selects_to_append: [Sequel.as(:id, :order_0)],
+            order_names: [:order_0]
+        end
+
+        it "when ordering by an arbitrary expression" do
+          assert_order_append \
+            ds: DB[:users].select_all(:users).order_by{function(:column, 2)},
+            selects_to_append: [Sequel.virtual_row{function(:column, 2)}.as(:order_0)],
+            order_names: [:order_0]
+        end
+      end
+
+      describe "and is connected to a model so we can look up columns" do
+        it "when ordering by an unqualified column that is present in the table" do
+          assert_order_append \
+            ds: User.dataset.select_all(:users).order_by(:id),
+            selects_to_append: [],
+            order_names: [:id]
+
+          assert_order_append \
+            ds: User.dataset.select_all(:users).order_by(:description),
+            selects_to_append: [],
+            order_names: [:description]
+        end
+
+        it "when ordering by an unqualified column that is not present in the table" do
+          assert_order_append \
+            ds: User.dataset.select_all(:users).order_by(:fake_column),
+            selects_to_append: [Sequel.as(:fake_column, :order_0)],
+            order_names: [:order_0]
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'sequel'
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+Sequel::Database.extension :select_order_clauses
+
+DB = Sequel.sqlite
+
+DB.create_table :users do
+  primary_key :id
+  Time :created_at
+  String :description
+end
+
+class User < Sequel::Model; end
+
+require 'pry'
+require 'minitest/autorun'
+require 'minitest/rg'

data/tasks/specs.rb

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new :default do |t|
+  t.libs = ['spec']
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :spec => :default
+task :test => :default

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: sequel-select-order-clauses
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Hanks
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Simple support for selecting the order clauses in a dataset
+email:
+- christopher.m.hanks@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sequel-select-order-clauses.rb
+- lib/sequel/extensions/select_order_clauses.rb
+- lib/sequel/extensions/select_order_clauses/version.rb
+- sequel-select-order-clauses.gemspec
+- spec/select_order_clauses_spec.rb
+- spec/spec_helper.rb
+- tasks/specs.rb
+homepage: https://github.com/chanks/sequel-select-order-clauses
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Select the order clauses in a dataset
+test_files:
+- spec/select_order_clauses_spec.rb
+- spec/spec_helper.rb