qdsl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd1c1b61ff92582af4dbb84566ac95128698db36
+  data.tar.gz: 746092cbe04dfa4b583dc7f3a0e2e9b43976ee1a
+SHA512:
+  metadata.gz: 187f3afba4a996b5f2010c4b67b0645daa9d4912f837d3d7ce28b7ee34fe59fe545b3791403b3bb5098037f2fbb2e085d2beda687405162d65874ab6ce302a8c
+  data.tar.gz: 7935cb02ccdecf88385d27d68aca1c2c9faa10823aadbe5032332ec3a4b233485c0eb74e8c13ff5c77044da678bab626c399a1f301c5fe44a2a1510861a8beda

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qdsl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Richard Cook
+
+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,120 @@
+# qdsl
+
+[![Install gem](https://badge.fury.io/rb/qdsl.png)](https://rubygems.org/gems/qdsl)
+[![Build status](https://travis-ci.org/rcook/qdsl.png)](https://travis-ci.org/rcook/qdsl)
+
+qdsl is SQL query builder DSL for Ruby: think of it as "hygienic macros for
+SQL". Note that this gem is in its very early development stages and is very far
+from complete. Here are the main talking points:
+
+* It's most likely riddled with bugs.
+* It is intended to have minimal external dependencies: it doesn't currently
+depend on any database adapters or anything like that since it is intended to
+generate only text and query parameter bindings.
+* It will generate PostgreSQL-compatible SQL, since that's what I care about.
+* It is intended to allow clean and straightforward composition of SQL queries
+and subqueries.
+* It takes a similar approach to other SQL Ruby-embedded DSLs (e.g.
+[SQLDSL](https://github.com/dydx/SQLDSL)) but differs as follows:
+  * It attempts to validate the query: column names are currently supported and
+the intention is to support column types too.
+  * It automatically generates table aliases in order to cleanly scope column
+names and to remove some of the confusion around joining tables with identically
+named columns.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'qdsl'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install qdsl
+```
+
+## Usage
+
+qdsl allows us to build SQL queries in a fairly natural way as a series of
+Ruby chained method calls. A few examples are given below.
+
+### Reference the gem
+
+```ruby
+require 'qdsl'
+```
+
+### Define a table
+
+```ruby
+clients = Qdsl::Table.new(
+  :clients,
+  :id,
+  :first_name,
+  :last_name
+)
+```
+
+This does not connect to a database or anything like that. This is just a way
+to define a table name and the list of column names from which we can build
+subsequent queries. Eventually, we might support generating these `Table`
+objects from Active Record models, but until that day comes, this is how we
+define data sources.
+
+### Define a query
+
+This is based on the most complex query defined in the gem's test suite:
+
+```ruby
+subquery = Qdsl::select(:id, :first_name, :last_name).
+  from(clients)
+query = Qdsl::select { |t0, t1| [t0.first_name, t1.last_name] }.
+  from(subquery).
+  inner_join(subquery).on { |t0, t1| t0.id.equals(t1.id) }.
+  where { |t0, t1| t0.first_name.equals('str0').and(t1.last_name.equals('str1')) }
+```
+
+Calling `render` on the query object `query` yields SQL that looks something
+like the following:
+
+```sql
+SELECT _00.first_name, _01.last_name
+FROM (
+  SELECT _02.id, _02.first_name, _02.last_name
+  FROM clients AS _02
+) AS _00
+INNER JOIN (
+  SELECT _03.id, _03.first_name, _03.last_name
+  FROM clients AS _03
+) AS _01
+ON _00.id = _01.id
+WHERE (_00.first_name = :_param00) AND (_01.last_name = :_param01)
+```
+
+The `parameters` attribute on the `Context` object populated by `render` will
+define the keys `_param00` and `_param01` with values `str0` and `str1`
+respectively. Notice the following:
+
+* The use of code blocks to perform validation of column names
+* Rudimentary support for boolean expressions
+* Replacement of string literals with query parameters
+* Automatic generation of table aliases in order to avoid column name collisions
+
+
+## Contributing
+
+1. Fork it from [here](https://github.com/rcook/qdsl/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new pull request
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task default: :test
+

data/lib/and.rb

@@ -0,0 +1,16 @@
+module Qdsl
+  class And < Boolean
+    def initialize(exprs)
+      super 'AND', exprs
+    end
+
+    def and(expr)
+      And.new(@exprs + [expr])
+    end
+
+    def or(expr)
+      Or.new([self, expr])
+    end
+  end
+end
+

data/lib/boolean.rb

@@ -0,0 +1,14 @@
+module Qdsl
+  class Boolean < Expression
+    def initialize(operator, exprs)
+      @operator = operator
+      @exprs = exprs
+    end
+
+    def render(context, ids)
+      expr_results = @exprs.collect { |x| render_operand(context, ids, x) }
+      expr_results.collect { |x| "(#{x})" }.join(" #{@operator} ")
+    end
+  end
+end
+

data/lib/column.rb

@@ -0,0 +1,43 @@
+module Qdsl
+  class Column
+    attr_reader :name, :alias_name, :source
+
+    def self.[](obj)
+      if obj.is_a?(Column)
+        obj
+      elsif obj.is_a?(String) || obj.is_a?(Symbol)
+        Column.new(obj)
+      else
+        raise "Cannot convert object of class \"#{obj.class.name}\" to column"
+      end
+    end
+
+    def initialize(name, alias_name = nil, source = nil)
+      @name = name.to_s
+      @alias_name = alias_name.nil? ? nil : alias_name.to_s
+      @source = source
+    end
+
+    def with_name(name)
+      Column.new(name, @alias_name, @source)
+    end
+
+    def with_alias_name(alias_name)
+      Column.new(@name, alias_name, @source)
+    end
+    alias_method :as, :with_alias_name
+
+    def with_source(source)
+      Column.new(@name, @alias_name, source)
+    end
+
+    def render(context, id)
+      @alias_name ? "#{id}.#{@name} AS #{@alias_name}" : "#{id}.#{@name}"
+    end
+
+    def equals(column)
+      Equals.new(self, column)
+    end
+  end
+end
+

data/lib/context.rb

@@ -0,0 +1,23 @@
+module Qdsl
+  class Context
+    attr_reader :parameters
+
+    def initialize
+      @id_base = 0
+      @parameters = {}
+    end
+
+    def id
+      result = "_#{@id_base.to_s.rjust(2, '0')}"
+      @id_base += 1
+      result
+    end
+
+    def add_parameter(value)
+      parameter_id = "_param#{@parameters.size.to_s.rjust(2, '0')}"
+      @parameters[parameter_id] = value
+      parameter_id
+    end
+  end
+end
+

data/lib/equals.rb

@@ -0,0 +1,23 @@
+module Qdsl
+  class Equals < Expression
+    def initialize(column0, column1)
+      @column0 = column0
+      @column1 = column1
+    end
+
+    def and(expr)
+      And.new([self, expr])
+    end
+
+    def or(expr)
+      Or.new([self, expr])
+    end
+
+    def render(context, ids)
+      column0_result = render_operand(context, ids, @column0)
+      column1_result = render_operand(context, ids, @column1)
+      "#{column0_result} = #{column1_result}"
+    end
+  end
+end
+

data/lib/expression.rb

@@ -0,0 +1,21 @@
+module Qdsl
+  class Expression
+    protected
+
+    def render_operand(context, ids, operand)
+      if operand.is_a?(String)
+        parameter_id = context.add_parameter(operand)
+        ":#{parameter_id}"
+      elsif operand.is_a?(TrueClass)
+        'TRUE'
+      elsif operand.is_a?(FalseClass)
+        'FALSE'
+      elsif operand.is_a?(Expression)
+        operand.render(context, ids)
+      else
+        operand.render(context, ids[operand.source])
+      end
+    end
+  end
+end
+

data/lib/funky_proxy.rb

@@ -0,0 +1,20 @@
+module Qdsl
+  class FunkyProxy
+    def initialize(source)
+      @source = source
+      source.column_names.each do |column|
+        (class << self; self; end).class_eval do
+          define_method column do
+            Column.new(column, nil, source)
+          end
+        end
+      end
+    end
+
+    def [](name)
+      raise unless @source.column_names.include?(name.to_s)
+      Column.new(name.to_s, nil, @source)
+    end
+  end
+end
+

data/lib/inner_join.rb

@@ -0,0 +1,11 @@
+module Qdsl
+  class InnerJoin
+    attr_reader :source, :predicate
+
+    def initialize(source, predicate)
+      @source = source
+      @predicate = predicate
+    end
+  end
+end
+

data/lib/inner_join_builder.rb

@@ -0,0 +1,14 @@
+module Qdsl
+  class InnerJoinBuilder
+    def initialize(query_builder, source)
+      @query_builder = query_builder
+      @source = source
+    end
+
+    def on
+      predicate = yield(FunkyProxy.new(@query_builder.source), FunkyProxy.new(@source))
+      @query_builder.add_inner_join(@source, predicate)
+    end
+  end
+end
+

data/lib/or.rb

@@ -0,0 +1,16 @@
+module Qdsl
+  class Or < Boolean
+    def initialize(exprs)
+      super 'OR', exprs
+    end
+
+    def and(expr)
+      And.new([self, expr])
+    end
+
+    def or(expr)
+      Or.new(@exprs + [expr])
+    end
+  end
+end
+

data/lib/qdsl.rb

@@ -0,0 +1,27 @@
+require 'qdsl/version'
+
+%w{
+  expression
+  boolean
+  and
+  column
+  context
+  equals
+  funky_proxy
+  inner_join
+  inner_join_builder
+  or
+  qdsl
+  select
+  table
+  table_query
+}.each do |file_name|
+  require_relative file_name
+end
+
+module Qdsl
+  def self.select(*columns, &block)
+    Select.new(columns.collect { |x| Column[x] }, &block)
+  end
+end
+

data/lib/qdsl/version.rb

@@ -0,0 +1,4 @@
+module Qdsl
+  VERSION = '0.0.1'
+end
+

data/lib/select.rb

@@ -0,0 +1,95 @@
+module Qdsl
+  class SelectQuery
+    attr_reader :column_names
+
+    def initialize(select, column_names)
+      @select = select
+      @column_names = column_names
+    end
+
+    def render(context, depth, id)
+      select_result = @select.render(context, depth)
+      "(\n#{select_result}) AS #{id}"
+    end
+  end
+
+  class Select
+    attr_reader :source
+
+    def initialize(columns, &block)
+      @columns = columns
+      @block = block
+      @inner_joins = []
+    end
+
+    def from(source)
+      @source = source.create_query
+      self
+    end
+
+def create_query
+  # Clone columns?
+  column_names = @columns.collect(&:name)
+  SelectQuery.new(self, column_names)
+end
+
+    def where
+      sources = [@source] + @inner_joins.collect(&:source)
+      proxies = sources.collect { |x| FunkyProxy.new(x) }
+      @where = yield(proxies.size == 1 ? proxies.first : proxies)
+      self
+    end
+
+    def inner_join(source)
+      InnerJoinBuilder.new(self, source.create_query)
+    end
+
+    def add_inner_join(source, predicate)
+      @inner_joins << InnerJoin.new(source, predicate)
+      self
+    end
+
+    def render(context = nil, depth = 0)
+      context ||= Context.new
+
+      indent = '  ' * depth
+
+      unknown_columns = @columns.select { |x| !@source.column_names.include?(x.name) }
+      raise "One or more unknown columns: #{unknown_columns.collect(&:name).join(', ')}" unless unknown_columns.empty?
+
+      columns = @columns.collect { |x| x.with_source(@source) }
+
+      sources = [@source] + @inner_joins.collect(&:source)
+
+      extra_columns = if @block
+        proxies = sources.collect { |x| FunkyProxy.new(x) }
+        [*@block.call(proxies.size == 1 ? proxies.first : proxies)]
+      else
+        []
+      end
+
+      ids = sources.inject({}) { |acc, x| acc[x] = context.id; acc }
+
+      column_results = (columns + extra_columns).collect { |x| x.render(context, ids[x.source]) }
+
+      fragments = []
+
+      fragments << "#{indent}SELECT #{column_results.join(', ')}\n"
+      fragments << "#{indent}FROM #{@source.render(context, depth + 1, ids[@source])}\n"
+
+      @inner_joins.each do |inner_join|
+        predicate_result = inner_join.predicate.render(context, ids)
+        fragments << "#{indent}INNER JOIN #{inner_join.source.render(context, depth + 1, ids[inner_join.source])}\n"
+        fragments << "#{indent}ON #{predicate_result}\n"
+      end
+
+      if @where
+        predicate_result = @where.render(context, ids)
+        fragments << "#{indent}WHERE #{predicate_result}"
+      end
+
+      fragments.join
+    end
+  end
+end
+

data/lib/table.rb

@@ -0,0 +1,15 @@
+module Qdsl
+  class Table
+    attr_reader :column_names
+
+    def initialize(name, *column_names)
+      @name = name
+      @column_names = column_names.collect(&:to_s)
+    end
+
+    def create_query
+      TableQuery.new(@name, @column_names)
+    end
+  end
+end
+

data/lib/table_query.rb

@@ -0,0 +1,15 @@
+module Qdsl
+  class TableQuery
+    attr_reader :column_names
+
+    def initialize(name, column_names)
+      @name = name
+      @column_names = column_names
+    end
+
+    def render(context, depth, id)
+      "#{@name} AS #{id}"
+    end
+  end
+end
+

data/qdsl.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qdsl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'qdsl'
+  spec.version       = Qdsl::VERSION
+  spec.authors       = ['Richard Cook']
+  spec.email         = ['rcook@rcook.org']
+  spec.summary       = %q{SQL query builder DSL for Ruby}
+  spec.description   = %q{Think of it as "hygienic macros for SQL}
+  spec.homepage      = ''
+  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.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest'
+end
+

data/test/column_test.rb

@@ -0,0 +1,115 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class ColumnTest < Minitest::Test
+    def test_convert_from_column
+      column = Column.new('name', 'alias_name', 'source')
+      result = Column[column]
+      assert_equal column, result
+    end
+
+    def test_convert_from_string
+      result = Column['name']
+      assert_equal 'name', result.name
+      assert_nil result.alias_name
+      assert_nil result.source
+    end
+
+    def test_convert_from_symbol
+      result = Column[:name]
+      assert_equal 'name', result.name
+      assert_nil result.alias_name
+      assert_nil result.source
+    end
+
+    def test_initialize_strings
+      result = Column.new('name', 'alias_name', 'source')
+      assert_equal 'name', result.name
+      assert_equal 'alias_name', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_initialize_symbols
+      result = Column.new(:name, :alias_name, :source)
+      assert_equal 'name', result.name
+      assert_equal 'alias_name', result.alias_name
+      assert_equal :source, result.source
+    end
+
+    def test_initialize_name_only_string
+      result = Column.new('name')
+      assert_equal 'name', result.name
+      assert_nil result.alias_name
+      assert_nil result.source
+    end
+
+    def test_initialize_name_only_symbol
+      result = Column.new(:name)
+      assert_equal 'name', result.name
+      assert_nil result.alias_name
+      assert_nil result.source
+    end
+
+    def test_with_name_string
+      result = Column.new('name', 'alias_name', 'source').with_name('new_name')
+      assert_equal 'new_name', result.name
+      assert_equal 'alias_name', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_with_name_symbol
+      result = Column.new('name', 'alias_name', 'source').with_name(:new_name)
+      assert_equal 'new_name', result.name
+      assert_equal 'alias_name', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_with_alias_name_string
+      result = Column.new('name', 'alias_name', 'source').with_alias_name('new_alias_name')
+      assert_equal 'name', result.name
+      assert_equal 'new_alias_name', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_with_alias_name_symbol
+      result = Column.new('name', 'alias_name', 'source').with_alias_name(:new_alias_name)
+      assert_equal 'name', result.name
+      assert_equal 'new_alias_name', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_with_source
+      result = Column.new('name', 'alias_name', 'source').with_source('new_source')
+      assert_equal 'name', result.name
+      assert_equal 'alias_name', result.alias_name
+      assert_equal 'new_source', result.source
+    end
+
+    def test_as_string
+      result = Column.new('name', 'alias_name', 'source').as('new_name_alias')
+      assert_equal 'name', result.name
+      assert_equal 'new_name_alias', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_as_symbol
+      result = Column.new('name', 'alias_name', 'source').as(:new_name_alias)
+      assert_equal 'name', result.name
+      assert_equal 'new_name_alias', result.alias_name
+      assert_equal 'source', result.source
+    end
+
+    def test_render_name_only
+      column = Column.new('name')
+      result = column.render(Context.new, 'id')
+      assert_equal 'id.name', result
+    end
+
+    def test_render_alias_name
+      column = Column.new('name', 'alias_name')
+      result = column.render(Context.new, 'id')
+      assert_equal 'id.name AS alias_name', result
+    end
+  end
+end
+

data/test/context_test.rb

@@ -0,0 +1,19 @@
+require_relative 'minitest_helper'
+require_relative 'query_test'
+
+module Qdsl
+  class ContextTest < QueryTest
+    def test_simple
+      query = Qdsl::select(:first_name).from(@clients).where { |t| t.id.equals('Cook') }
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.first_name ' +
+        'FROM clients AS _00 ' +
+        'WHERE _00.id = :_param00', result
+      assert_equal 1, context.parameters.size
+      assert_equal 'Cook', context.parameters['_param00']
+    end
+  end
+end
+

data/test/end_to_end_test.rb

@@ -0,0 +1,26 @@
+require_relative 'minitest_helper'
+require_relative 'query_test'
+
+module Qdsl
+  class EndToEndTest < QueryTest
+    def test_aliases
+      query = Qdsl::select(
+        Column[:id].as(:alias0),
+        Column['first_name'].as(:alias1),
+        Column.new(:last_name).as(:alias2)
+      ).from(@clients)
+      result = query.render
+
+      assert_sql 'SELECT _00.id AS alias0, _00.first_name AS alias1, _00.last_name AS alias2 FROM clients AS _00', result
+    end
+
+    def test_unknown_column
+      query = Qdsl::select(:unknown).from(@clients)
+
+      assert_raises RuntimeError do
+        query.render
+      end
+    end
+  end
+end
+

data/test/expression_test.rb

@@ -0,0 +1,108 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class ExpressionTest < QueryTest
+    def test_simple_and
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| t.first_name.equals('Richard').and(t.last_name.equals('Cook')) }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE (_00.first_name = :_param00) AND (_00.last_name = :_param01)', result
+      assert_equal 2, context.parameters.size
+      assert_equal 'Richard', context.parameters['_param00']
+      assert_equal 'Cook', context.parameters['_param01']
+    end
+
+    def test_multiple_and
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| t.first_name.equals('Richard').and(t.last_name.equals('Cook')).and(t.id.equals('ID')) }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE (_00.first_name = :_param00) AND (_00.last_name = :_param01) AND (_00.id = :_param02)', result
+      assert_equal 3, context.parameters.size
+      assert_equal 'Richard', context.parameters['_param00']
+      assert_equal 'Cook', context.parameters['_param01']
+      assert_equal 'ID', context.parameters['_param02']
+    end
+
+    def test_simple_or
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| t.first_name.equals('Richard').or(t.last_name.equals('Cook')) }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE (_00.first_name = :_param00) OR (_00.last_name = :_param01)', result
+      assert_equal 2, context.parameters.size
+      assert_equal 'Richard', context.parameters['_param00']
+      assert_equal 'Cook', context.parameters['_param01']
+    end
+
+    def test_multiple_or
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| t.first_name.equals('Richard').or(t.last_name.equals('Cook')).or(t.id.equals('ID')) }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE (_00.first_name = :_param00) OR (_00.last_name = :_param01) OR (_00.id = :_param02)', result
+      assert_equal 3, context.parameters.size
+      assert_equal 'Richard', context.parameters['_param00']
+      assert_equal 'Cook', context.parameters['_param01']
+      assert_equal 'ID', context.parameters['_param02']
+    end
+
+    def big_or(ids, t)
+      ids.collect { |x| t[x].equals(true) }.inject { |acc, x| acc.or(x) }
+    end
+
+    def test_multiple_or2
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| big_or([:value0, :value1, :value2, :value3], t) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE (_00.value0 = TRUE) OR (_00.value1 = TRUE) OR (_00.value2 = TRUE) OR (_00.value3 = TRUE)', result
+    end
+
+    def test_boolean
+      query = Qdsl::select(:id).
+        from(@clients).
+        where { |t| t.first_name.equals('Richard').or(t.last_name.equals('Cook')).and(t.id.equals('ID').or(t.id.equals('OTHER_ID'))) }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.id ' +
+        'FROM clients AS _00 ' +
+        'WHERE ((_00.first_name = :_param00) OR ' +
+        '(_00.last_name = :_param01)) ' +
+        'AND ((_00.id = :_param02) OR ' +
+        '(_00.id = :_param03))', result
+      assert_equal 4, context.parameters.size
+      assert_equal 'Richard', context.parameters['_param00']
+      assert_equal 'Cook', context.parameters['_param01']
+      assert_equal 'ID', context.parameters['_param02']
+      assert_equal 'OTHER_ID', context.parameters['_param03']
+    end
+  end
+end
+

data/test/inner_join_test.rb

@@ -0,0 +1,65 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class InnerJoinTest < QueryTest
+    def test_inner_join_simple
+      query = Qdsl::select { |t0, t1| [t0.id, t1.member_id] }.
+        from(@clients).
+        inner_join(@members).on { |f, j| f.id.equals(j.id) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id, _01.member_id ' +
+        'FROM clients AS _00 ' +
+        'INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+
+    def test_inner_join
+      query = Qdsl::select { |t0, t1| [t0.id, t1.member_id] }.
+        from(@clients).
+        inner_join(@members).on { |t0, t1| t0.id.equals(t1.first_name) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id, _01.member_id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.first_name', result
+    end
+
+    def test_multiple_inner_joins
+      query = Qdsl::select { |t0, t1, t2| [t0.id, t1.member_id, t2.name] }.
+        from(@clients).
+        inner_join(@members).on { |f, j| f.id.equals(j.first_name) }.
+        inner_join(@colours).on { |f, j| f.first_name.equals(j.name) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id, _01.member_id, _02.name ' +
+        'FROM clients AS _00 ' +
+        'INNER JOIN members AS _01 ON _00.id = _01.first_name ' +
+        'INNER JOIN colours AS _02 ON _00.first_name = _02.name', result
+    end
+
+    def test_multiple_inner_join_same
+      query = Qdsl::select { |t0, t1| [t0.id, t1.id] }.
+        from(@clients).
+        inner_join(@clients).on { |f, j| f.id.equals(j.first_name) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id, _01.id FROM ' +
+        'clients AS _00 ' +
+        'INNER JOIN clients AS _01 ON _00.id = _01.first_name', result
+    end
+
+    def test_multiple_inner_join_same_where
+      query = Qdsl::select { |t0, t1, t2| [t0.id, t1.id] }.
+        from(@clients).
+        inner_join(@clients).on { |f, j| f.id.equals(j.first_name) }.
+        inner_join(@clients).on { |f, j| f.id.equals(j.first_name) }.
+        where { |t0, t1, t2| t0.id.equals(t1.id) }
+      result = query.render
+
+      assert_sql 'SELECT _00.id, _01.id FROM ' +
+        'clients AS _00 ' +
+        'INNER JOIN clients AS _01 ON _00.id = _01.first_name ' +
+        'INNER JOIN clients AS _02 ON _00.id = _02.first_name ' +
+        'WHERE _00.id = _01.id', result
+    end
+  end
+end
+

data/test/minitest_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'qdsl'
+
+require 'minitest/autorun'
+require 'minitest/pride'
+

data/test/query_test.rb

@@ -0,0 +1,40 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class QueryTest < Minitest::Test
+    def setup
+      @clients = Table.new(
+        :clients,
+        :id,
+        :first_name,
+        :last_name,
+        :value0,
+        :value1,
+        :value2,
+        :value3
+      )
+      @members = Table.new(
+        :members,
+        :id,
+        :first_name,
+        :middle_name,
+        :last_name,
+        :member_id
+      )
+      @colours = Table.new(
+        :colours,
+        :id,
+        :name
+      )
+    end
+
+    def assert_sql(expected, actual)
+      expected.gsub! /\s*\n\s*/, ' '
+      expected.strip!
+      actual.gsub! /\s*\n\s*/, ' '
+      actual.strip!
+      assert_equal expected, actual
+    end
+  end
+end
+

data/test/select_test.rb

@@ -0,0 +1,96 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class SelectTest < QueryTest
+    def test_single_table_select_single_column_string
+      query = Qdsl::select('id').from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00', result
+    end
+
+    def test_single_table_select_single_column_symbol
+      query = Qdsl::select(:id).from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00', result
+    end
+
+    def test_single_table_select_single_column_method
+      query = Qdsl::select { |t| t.id }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00', result
+    end
+
+    def test_single_table_select_single_column_name_string
+      query = Qdsl::select { |t| t['id'] }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00', result
+    end
+
+    def test_single_table_select_single_column_name_symbol
+      query = Qdsl::select { |t| t[:id] }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00', result
+    end
+
+    def test_single_table_select_two_columns_string
+      query = Qdsl::select('id', 'first_name').from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id, _00.first_name FROM clients AS _00', result
+    end
+
+    def test_single_table_select_two_columns_symbol
+      query = Qdsl::select(:id, :first_name).from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id, _00.first_name FROM clients AS _00', result
+    end
+
+    def test_single_table_select_two_columns_method
+      query = Qdsl::select { |t| [t.id, t.first_name] }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id, _00.first_name FROM clients AS _00', result
+    end
+
+    def test_single_table_select_two_columns_name_string
+      query = Qdsl::select { |t| [t['id'], t['first_name']] }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id, _00.first_name FROM clients AS _00', result
+    end
+
+    def test_single_table_select_two_columns_name_symbol
+      query = Qdsl::select { |t| [t[:id], t[:first_name]] }.from(@clients)
+      result = query.render
+      assert_sql 'SELECT _00.id, _00.first_name FROM clients AS _00', result
+    end
+
+    def test_two_tables_select_single_column_string
+      query = Qdsl::select('id').from(@clients).inner_join(@members).on { |t0, t1| t0.id.equals(t1.id) }
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+
+    def test_two_tables_select_single_column_symbol
+      query = Qdsl::select(:id).from(@clients).inner_join(@members).on { |t0, t1| t0.id.equals(t1.id) }
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+
+    def test_two_tables_select_single_column_method
+      query = Qdsl::select { |t0, t1| t0.id }.from(@clients).inner_join(@members).on { |t0, t1| t0.id.equals(t1.id) }
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+
+    def test_two_tables_select_single_column_name_string
+      query = Qdsl::select { |t0, t1| t0['id'] }.from(@clients).inner_join(@members).on { |t0, t1| t0.id.equals(t1.id) }
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+
+    def test_two_tables_select_single_column_name_symbol
+      query = Qdsl::select { |t0, t1| t0[:id] }.from(@clients).inner_join(@members).on { |t0, t1| t0.id.equals(t1.id) }
+      result = query.render
+      assert_sql 'SELECT _00.id FROM clients AS _00 INNER JOIN members AS _01 ON _00.id = _01.id', result
+    end
+  end
+end
+

data/test/subquery_test.rb

@@ -0,0 +1,66 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class SubqueryTest < QueryTest
+    def test_simple
+      subquery = Qdsl::select(:id, :first_name, :last_name).from(@clients)
+      query = Qdsl::select(:first_name).from(subquery)
+
+      assert_sql <<-EOL, query.render
+SELECT _00.first_name
+FROM (
+  SELECT _01.id, _01.first_name, _01.last_name
+  FROM clients AS _01
+) AS _00
+      EOL
+    end
+
+    def test_subquery_inner_join
+      subquery = Qdsl::select(:id, :first_name, :last_name).from(@clients)
+      query = Qdsl::select { |t0, t1| [t0.first_name, t1.last_name] }.
+        from(subquery).
+        inner_join(subquery).on { |t0, t1| t0.id.equals(t1.id) }
+
+      assert_sql <<-EOL, query.render
+SELECT _00.first_name, _01.last_name
+FROM (
+  SELECT _02.id, _02.first_name, _02.last_name
+  FROM clients AS _02
+) AS _00
+INNER JOIN (
+  SELECT _03.id, _03.first_name, _03.last_name
+  FROM clients AS _03
+) AS _01
+ON _00.id = _01.id
+      EOL
+    end
+
+    def test_subquery_inner_join_where
+      subquery = Qdsl::select(:id, :first_name, :last_name).from(@clients)
+      query = Qdsl::select { |t0, t1| [t0.first_name, t1.last_name] }.
+        from(subquery).
+        inner_join(subquery).on { |t0, t1| t0.id.equals(t1.id) }.
+        where { |t0, t1| t0.first_name.equals('str0').and(t1.last_name.equals('str1')) }
+
+      context = Context.new
+      assert_sql <<-EOL, query.render(context)
+SELECT _00.first_name, _01.last_name
+FROM (
+  SELECT _02.id, _02.first_name, _02.last_name
+  FROM clients AS _02
+) AS _00
+INNER JOIN (
+  SELECT _03.id, _03.first_name, _03.last_name
+  FROM clients AS _03
+) AS _01
+ON _00.id = _01.id
+WHERE (_00.first_name = :_param00) AND (_01.last_name = :_param01)
+        EOL
+
+        assert_equal 2, context.parameters.size
+        assert_equal 'str0', context.parameters['_param00']
+        assert_equal 'str1', context.parameters['_param01']
+      end
+  end
+end
+

data/test/where_test.rb

@@ -0,0 +1,21 @@
+require_relative 'minitest_helper'
+
+module Qdsl
+  class WhereTest < QueryTest
+    def test_simple_where
+      query = Qdsl::select(:first_name).
+        from(@clients).
+        where { |t| t.id.equals('Cook') }
+
+      context = Context.new
+      result = query.render(context)
+
+      assert_sql 'SELECT _00.first_name ' +
+        'FROM clients AS _00 ' +
+        'WHERE _00.id = :_param00', result
+      assert_equal 1, context.parameters.size
+      assert_equal 'Cook', context.parameters['_param00']
+    end
+  end
+end
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: qdsl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Richard Cook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: Think of it as "hygienic macros for SQL
+email:
+- rcook@rcook.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/and.rb
+- lib/boolean.rb
+- lib/column.rb
+- lib/context.rb
+- lib/equals.rb
+- lib/expression.rb
+- lib/funky_proxy.rb
+- lib/inner_join.rb
+- lib/inner_join_builder.rb
+- lib/or.rb
+- lib/qdsl.rb
+- lib/qdsl/version.rb
+- lib/select.rb
+- lib/table.rb
+- lib/table_query.rb
+- qdsl.gemspec
+- test/column_test.rb
+- test/context_test.rb
+- test/end_to_end_test.rb
+- test/expression_test.rb
+- test/inner_join_test.rb
+- test/minitest_helper.rb
+- test/query_test.rb
+- test/select_test.rb
+- test/subquery_test.rb
+- test/where_test.rb
+homepage: ''
+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.4.5
+signing_key: 
+specification_version: 4
+summary: SQL query builder DSL for Ruby
+test_files:
+- test/column_test.rb
+- test/context_test.rb
+- test/end_to_end_test.rb
+- test/expression_test.rb
+- test/inner_join_test.rb
+- test/minitest_helper.rb
+- test/query_test.rb
+- test/select_test.rb
+- test/subquery_test.rb
+- test/where_test.rb