query-composer 1.0.0

data/lib/query/composer/version.rb

@@ -0,0 +1,11 @@
+module Query
+  class Composer
+    module Version
+      MAJOR = 1
+      MINOR = 0
+      PATCH = 0
+
+      STRING = [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/lib/query/wrapper.rb

@@ -0,0 +1,7 @@
+module Query
+  class Wrapper < Base
+    def _configure(source)
+      @arel = source
+    end
+  end
+end

data/query-composer.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "query/composer/version"
+
+Gem::Specification.new do |gem|
+  gem.version     = Query::Composer::Version::STRING
+  gem.name        = "query-composer"
+  gem.authors     = ["Jamis Buck"]
+  gem.email       = ["jamis@jamisbuck.org"]
+  gem.homepage    = "http://github.com/jamis/query-composer"
+  gem.summary     = "Modularly construct complex SQL queries"
+  gem.description = "Build complex SQL queries by defining each subquery separately. Query::Composer will then compose those subqueries together, nesting as needed, to produce the final SQL query."
+  gem.license     = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^test/})
+  gem.require_paths = ["lib"]
+
+  ##
+  # Development dependencies
+  #
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "activerecord", ">= 4.0"
+  gem.add_development_dependency "rubygems-tasks", "~> 0"
+
+  gem.add_dependency "arel", "~> 6.0"
+end

data/test/query/base_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Query
+  class BaseTest < Minitest::Test
+    def test_should_interpret_symbol_argument_as_table_name
+      q = Query::Base.new(:people)
+      assert_equal Arel::Table.new(:people), q.primary_table
+    end
+
+    def test_should_interpret_string_argument_as_table_name
+      q = Query::Base.new("people")
+      assert_equal Arel::Table.new(:people), q.primary_table
+    end
+
+    def test_should_use_Arel_Table_argument_as_primary_table
+      q = Query::Base.new(Arel::Table.new(:people))
+      assert_equal Arel::Table.new(:people), q.primary_table
+    end
+
+    def test_should_use_Arel_Nodes_TableAlias_argument_as_primary_table
+      arel = Person.all.arel.as('people')
+      q = Query::Base.new(arel)
+      assert_equal arel, q.primary_table
+    end
+
+    def test_should_treat_Arel_Nodes_TableAlias_as_query_source
+      arel = Person.all.arel.as('folks')
+      q = Query::Base.new(arel).all
+      assert_equal "SELECT folks.* FROM (SELECT \"people\".* FROM \"people\") folks", q.to_sql
+    end
+
+    def test_all_should_project_all_table_attributes
+      q = Query::Base.new(:people).all
+      assert_match /"people"\.\*/, q.to_sql
+    end
+
+    def test_reproject_should_change_attributes_in_projection
+      q = Query::Base.new(:people).all
+      q.reproject(q.primary_table[:id], q.primary_table[:first_name])
+      refute_match /"people"\.\*/, q.to_sql
+      assert_match /"people"\."id", "people"\."first_name"/, q.to_sql
+    end
+
+    def test_as_should_return_Arel_node_instance
+      q = Query::Base.new(:people).as('scooby')
+      assert_instance_of Arel::Nodes::TableAlias, q
+    end
+
+    def test_to_sql_should_convert_query_to_a_string_of_SQL
+      q = Query::Base.new(:people).all
+      assert_equal "SELECT \"people\".* FROM \"people\"", q.to_sql
+    end
+
+    def test_unrecognized_methods_should_be_delegated_to_arel
+      people = Arel::Table.new(:people)
+      companies = Arel::Table.new(:companies)
+
+      q = Query::Base.new(people).join(companies).on(people[:company_id].eq(companies[:id]))
+      assert_equal "SELECT FROM \"people\" INNER JOIN \"companies\" ON \"people\".\"company_id\" = \"companies\".\"id\"", q.to_sql
+    end
+  end
+end

data/test/query/composer_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+module Query
+  class ComposerTest < Minitest::Test
+    def setup
+      @composer = Query::Composer.new
+
+      @composer.use(:companies_set) { Company.all }
+      @composer.use(:people_set) { Query::Wrapper.new(:people, Person.all.arel) }
+
+      @composer.use(:joined_set) do |people_set, companies_set|
+        Query::Base.new(people_set).
+          project(
+            people_set[:first_name].as("first_name"),
+            companies_set[:name].as("name")).
+          join(companies_set).
+          on(people_set[:company_id].eq(companies_set[:id])).
+          order(people_set[:first_name])
+      end
+
+      @composer.use(:dep_a) { |dep_b| Person.all }
+      @composer.use(:dep_b) { |dep_a| Company.all }
+
+      @composer.use(:unknown_dep) { |bogus| Person.all }
+      @composer.use(:invalid_query) { 15 }
+    end
+
+    def test_composer_should_accept_ActiveRecord_scope
+      results = Company.find_by_sql(@composer.build(:companies_set))
+      expected = Company.all.to_a
+      assert_equal(expected, results)
+    end
+
+    def test_composer_should_accept_scope_quack_alikes
+      results = Person.find_by_sql(@composer.build(:people_set))
+      expected = Person.all.to_a
+      assert_equal(expected, results)
+    end
+
+    def test_composer_should_resolve_dependencies
+      results = Person.find_by_sql(@composer.build(:joined_set))
+      assert_equal(results.first.first_name, "Harry")
+      assert_equal(results.first.name, "Big Company")
+    end
+
+    def test_composer_should_support_derived_tables
+      results = Person.find_by_sql(@composer.build(:joined_set, use_cte: false))
+      assert_equal(results.first.first_name, "Harry")
+      assert_equal(results.first.name, "Big Company")
+    end
+
+    def test_composer_should_support_common_table_expressions
+      results = Person.find_by_sql(@composer.build(:joined_set, use_cte: true))
+      assert_equal(results.first.first_name, "Harry")
+      assert_equal(results.first.name, "Big Company")
+    end
+
+    def test_composer_should_detect_circular_dependencies
+      assert_raises Query::Composer::CircularDependency do
+        @composer.build(:dep_a)
+      end
+    end
+
+    def test_composer_should_error_when_a_dependency_isnt_recognized
+      assert_raises Query::Composer::UnknownQuery do
+        @composer.build(:unknown_dep)
+      end
+    end
+
+    def test_composer_should_ensure_component_returns_querylike
+      assert_raises Query::Composer::InvalidQuery do
+        @composer.build(:invalid_query)
+      end
+    end
+
+    def test_composer_use_should_overwrite_existing_component
+      @composer.use(:companies_set) { Company.where("id = 1") }
+      results = Company.find_by_sql(@composer.build(:companies_set))
+      assert_equal 1, results.length
+      assert_equal 1, results.first.id
+    end
+
+    def test_composer_alias_should_copy_named_component
+      @composer.alias(:companies_again, :companies_set)
+      @composer.use(:companies_set) { Company.where("id = 1") }
+
+      results = Company.find_by_sql(@composer.build(:companies_set))
+      assert_equal 1, results.length
+
+      results = Company.find_by_sql(@composer.build(:companies_again))
+      assert_equal Company.all, results
+    end
+
+    def test_composer_delete_should_remove_named_component
+      @composer.delete(:companies_set)
+
+      assert_raises Query::Composer::UnknownQuery do
+        @composer.build(:companies_set)
+      end
+    end
+  end
+end

data/test/query/wrapper_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+module Query
+  class WrapperTest < Minitest::Test
+    def test_should_allow_arbitrary_query_to_be_used_as_a_query_object
+      wrapper = Query::Wrapper.new(:people, Person.where("id=1"))
+      assert_equal "SELECT \"people\".* FROM \"people\" WHERE (id=1)", wrapper.to_sql
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+require 'minitest/autorun'
+require 'active_record'
+
+require 'query/composer'
+require 'query/base'
+require 'query/wrapper'
+
+ActiveRecord::Base.logger = Logger.new(File.open("test.log", "w"))
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: ":memory:"
+)
+
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Schema.define do
+  create_table :people do |t|
+    t.string :first_name
+    t.integer :company_id
+  end
+
+  create_table :companies do |t|
+    t.string :name
+  end
+end
+
+ActiveRecord::Base.connection.execute <<-SQL
+  INSERT INTO people (id, first_name, company_id)
+    VALUES (1, 'Harry', 1),
+           (2, 'Margaret', 1),
+           (3, 'Jesse', 2);
+SQL
+
+ActiveRecord::Base.connection.execute <<-SQL
+  INSERT INTO companies (id, name)
+    VALUES (1, 'Big Company'),
+           (2, 'Little Company');
+SQL
+
+class Person < ActiveRecord::Base
+  belongs_to :company
+end
+
+class Company < ActiveRecord::Base
+  has_many :people
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: query-composer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamis Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-26 00:00:00.000000000 Z
+dependencies:
+- !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: minitest
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  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: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Build complex SQL queries by defining each subquery separately. Query::Composer
+  will then compose those subqueries together, nesting as needed, to produce the final
+  SQL query.
+email:
+- jamis@jamisbuck.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- examples/library.rb
+- lib/query/base.rb
+- lib/query/composer.rb
+- lib/query/composer/version.rb
+- lib/query/wrapper.rb
+- query-composer.gemspec
+- test/query/base_test.rb
+- test/query/composer_test.rb
+- test/query/wrapper_test.rb
+- test/test_helper.rb
+homepage: http://github.com/jamis/query-composer
+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: Modularly construct complex SQL queries
+test_files:
+- test/query/base_test.rb
+- test/query/composer_test.rb
+- test/query/wrapper_test.rb
+- test/test_helper.rb