square-arel 2.0.9.20110222133018

data/lib/arel/visitors/visitor.rb

@@ -0,0 +1,27 @@
+module Arel
+  module Visitors
+    class Visitor
+      def accept object
+        visit object
+      end
+
+      private
+
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{(klass.name || '').gsub('::', '_')}"
+      end
+
+      def visit object
+        send DISPATCH[object.class], object
+      rescue NoMethodError => e
+        raise e if respond_to?(DISPATCH[object.class], true)
+        superklass = object.class.ancestors.find { |klass|
+          respond_to?(DISPATCH[klass], true)
+        }
+        raise(TypeError, "Cannot visit #{object.class}") unless superklass
+        DISPATCH[object.class] = DISPATCH[superklass]
+        retry
+      end
+    end
+  end
+end

data/lib/arel/visitors/where_sql.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Visitors
+    class WhereSql < Arel::Visitors::ToSql
+      def visit_Arel_Nodes_SelectCore o
+        "WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }"
+      end
+    end
+  end
+end

data/square-arel.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{square-arel}
+  s.version = "2.0.9.20110222133018"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Patterson", "Bryan Halmkamp", "Emilio Tagua", "Nick Kallen"]
+  s.date = %q{2011-02-22}
+  s.description = %q{Arel is a Relational Algebra for Ruby. It 1) simplifies the generation complex of SQL queries and it 2) adapts to various RDBMS systems. It is intended to be a framework framework; that is, you can build your own ORM with it, focusing on innovative object and collection modeling as opposed to database compatibility and query generation.}
+  s.email = ["aaron@tenderlovemaking.com", "bryan@brynary.com", "miloops@gmail.com", "nick@example.org"]
+  s.extra_rdoc_files = ["History.txt", "MIT-LICENSE.txt", "Manifest.txt", "README.markdown"]
+  s.files = [".autotest", "History.txt", "MIT-LICENSE.txt", "Manifest.txt", "README.markdown", "Rakefile", "square-arel.gemspec", "lib/arel.rb", "lib/arel/attributes.rb", "lib/arel/attributes/attribute.rb", "lib/arel/compatibility/wheres.rb", "lib/arel/crud.rb", "lib/arel/delete_manager.rb", "lib/arel/deprecated.rb", "lib/arel/expression.rb", "lib/arel/expressions.rb", "lib/arel/insert_manager.rb", "lib/arel/nodes.rb", "lib/arel/nodes/and.rb", "lib/arel/nodes/as.rb", "lib/arel/nodes/assignment.rb", "lib/arel/nodes/avg.rb", "lib/arel/nodes/between.rb", "lib/arel/nodes/binary.rb", "lib/arel/nodes/count.rb", "lib/arel/nodes/delete_statement.rb", "lib/arel/nodes/does_not_match.rb", "lib/arel/nodes/equality.rb", "lib/arel/nodes/except.rb", "lib/arel/nodes/exists.rb", "lib/arel/nodes/function.rb", "lib/arel/nodes/greater_than.rb", "lib/arel/nodes/greater_than_or_equal.rb", "lib/arel/nodes/group.rb", "lib/arel/nodes/grouping.rb", "lib/arel/nodes/having.rb", "lib/arel/nodes/in.rb", "lib/arel/nodes/inner_join.rb", "lib/arel/nodes/insert_statement.rb", "lib/arel/nodes/intersect.rb", "lib/arel/nodes/join.rb", "lib/arel/nodes/less_than.rb", "lib/arel/nodes/less_than_or_equal.rb", "lib/arel/nodes/limit.rb", "lib/arel/nodes/lock.rb", "lib/arel/nodes/matches.rb", "lib/arel/nodes/max.rb", "lib/arel/nodes/min.rb", "lib/arel/nodes/node.rb", "lib/arel/nodes/not.rb", "lib/arel/nodes/not_equal.rb", "lib/arel/nodes/not_in.rb", "lib/arel/nodes/offset.rb", "lib/arel/nodes/on.rb", "lib/arel/nodes/or.rb", "lib/arel/nodes/ordering.rb", "lib/arel/nodes/outer_join.rb", "lib/arel/nodes/select_core.rb", "lib/arel/nodes/select_statement.rb", "lib/arel/nodes/sql_literal.rb", "lib/arel/nodes/string_join.rb", "lib/arel/nodes/sum.rb", "lib/arel/nodes/table_alias.rb", "lib/arel/nodes/top.rb", "lib/arel/nodes/unary.rb", "lib/arel/nodes/union.rb", "lib/arel/nodes/union_all.rb", "lib/arel/nodes/unqualified_column.rb", "lib/arel/nodes/update_statement.rb", "lib/arel/nodes/values.rb", "lib/arel/predications.rb", "lib/arel/relation.rb", "lib/arel/select_manager.rb", "lib/arel/sql/engine.rb", "lib/arel/sql_literal.rb", "lib/arel/table.rb", "lib/arel/tree_manager.rb", "lib/arel/update_manager.rb", "lib/arel/visitors.rb", "lib/arel/visitors/depth_first.rb", "lib/arel/visitors/dot.rb", "lib/arel/visitors/join_sql.rb", "lib/arel/visitors/mssql.rb", "lib/arel/visitors/mysql.rb", "lib/arel/visitors/oracle.rb", "lib/arel/visitors/order_clauses.rb", "lib/arel/visitors/postgresql.rb", "lib/arel/visitors/sqlite.rb", "lib/arel/visitors/to_sql.rb", "lib/arel/visitors/visitor.rb", "lib/arel/visitors/where_sql.rb", "test/attributes/test_attribute.rb", "test/helper.rb", "test/nodes/test_as.rb", "test/nodes/test_count.rb", "test/nodes/test_delete_statement.rb", "test/nodes/test_equality.rb", "test/nodes/test_insert_statement.rb", "test/nodes/test_node.rb", "test/nodes/test_not.rb", "test/nodes/test_or.rb", "test/nodes/test_select_core.rb", "test/nodes/test_select_statement.rb", "test/nodes/test_sql_literal.rb", "test/nodes/test_sum.rb", "test/nodes/test_update_statement.rb", "test/support/fake_record.rb", "test/test_activerecord_compat.rb", "test/test_attributes.rb", "test/test_crud.rb", "test/test_delete_manager.rb", "test/test_insert_manager.rb", "test/test_select_manager.rb", "test/test_table.rb", "test/test_update_manager.rb", "test/visitors/test_depth_first.rb", "test/visitors/test_dot.rb", "test/visitors/test_join_sql.rb", "test/visitors/test_mssql.rb", "test/visitors/test_mysql.rb", "test/visitors/test_oracle.rb", "test/visitors/test_postgres.rb", "test/visitors/test_sqlite.rb", "test/visitors/test_to_sql.rb"]
+  s.homepage = %q{http://github.com/rails/arel}
+  s.rdoc_options = ["--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{arel}
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{Arel is a Relational Algebra for Ruby}
+  s.test_files = ["test/attributes/test_attribute.rb", "test/nodes/test_as.rb", "test/nodes/test_count.rb", "test/nodes/test_delete_statement.rb", "test/nodes/test_equality.rb", "test/nodes/test_insert_statement.rb", "test/nodes/test_node.rb", "test/nodes/test_not.rb", "test/nodes/test_or.rb", "test/nodes/test_select_core.rb", "test/nodes/test_select_statement.rb", "test/nodes/test_sql_literal.rb", "test/nodes/test_sum.rb", "test/nodes/test_update_statement.rb", "test/test_activerecord_compat.rb", "test/test_attributes.rb", "test/test_crud.rb", "test/test_delete_manager.rb", "test/test_insert_manager.rb", "test/test_select_manager.rb", "test/test_table.rb", "test/test_update_manager.rb", "test/visitors/test_depth_first.rb", "test/visitors/test_dot.rb", "test/visitors/test_join_sql.rb", "test/visitors/test_mssql.rb", "test/visitors/test_mysql.rb", "test/visitors/test_oracle.rb", "test/visitors/test_postgres.rb", "test/visitors/test_sqlite.rb", "test/visitors/test_to_sql.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<minitest>, [">= 2.0.0"])
+      s.add_development_dependency(%q<hoe>, [">= 2.8.0"])
+    else
+      s.add_dependency(%q<minitest>, [">= 2.0.0"])
+      s.add_dependency(%q<hoe>, [">= 2.8.0"])
+    end
+  else
+    s.add_dependency(%q<minitest>, [">= 2.0.0"])
+    s.add_dependency(%q<hoe>, [">= 2.8.0"])
+  end
+end

data/test/attributes/test_attribute.rb

@@ -0,0 +1,664 @@
+require 'helper'
+
+module Arel
+  module Attributes
+    describe 'attribute' do
+      describe '#not_eq' do
+        it 'should create a NotEqual node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq(10).must_be_kind_of Nodes::NotEqual
+        end
+
+        it 'should generate != in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
+          }
+        end
+
+        it 'should handle nil' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq(nil)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
+          }
+        end
+      end
+
+      describe '#not_eq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2)
+          }
+        end
+      end
+
+      describe '#not_eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2)
+          }
+        end
+      end
+
+      describe '#gt' do
+        it 'should create a GreaterThan node' do
+          relation = Table.new(:users)
+          relation[:id].gt(10).must_be_kind_of Nodes::GreaterThan
+        end
+
+        it 'should generate >= in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
+          }
+        end
+      end
+
+      describe '#gt_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gt_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2)
+          }
+        end
+      end
+
+      describe '#gt_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gt_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gt_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2)
+          }
+        end
+      end
+
+      describe '#gteq' do
+        it 'should create a GreaterThanOrEqual node' do
+          relation = Table.new(:users)
+          relation[:id].gteq(10).must_be_kind_of Nodes::GreaterThanOrEqual
+        end
+
+        it 'should generate >= in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
+          }
+        end
+      end
+
+      describe '#gteq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gteq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe '#gteq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].gteq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].gteq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2)
+          }
+        end
+      end
+
+      describe '#lt' do
+        it 'should create a LessThan node' do
+          relation = Table.new(:users)
+          relation[:id].lt(10).must_be_kind_of Nodes::LessThan
+        end
+
+        it 'should generate < in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
+          }
+        end
+      end
+
+      describe '#lt_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lt_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2)
+          }
+        end
+      end
+
+      describe '#lt_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lt_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lt_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2)
+          }
+        end
+      end
+
+      describe '#lteq' do
+        it 'should create a LessThanOrEqual node' do
+          relation = Table.new(:users)
+          relation[:id].lteq(10).must_be_kind_of Nodes::LessThanOrEqual
+        end
+
+        it 'should generate <= in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
+          }
+        end
+      end
+
+      describe '#lteq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lteq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe '#lteq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].lteq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].lteq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2)
+          }
+        end
+      end
+
+      describe '#average' do
+        it 'should create a AVG node' do
+          relation = Table.new(:users)
+          relation[:id].average.must_be_kind_of Nodes::Avg
+        end
+
+        # FIXME: backwards compat. Is this really necessary?
+        it 'should set the alias to "avg_id"' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].average
+          mgr.to_sql.must_be_like %{
+            SELECT AVG("users"."id") AS avg_id
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#maximum' do
+        it 'should create a MAX node' do
+          relation = Table.new(:users)
+          relation[:id].maximum.must_be_kind_of Nodes::Max
+        end
+
+        # FIXME: backwards compat. Is this really necessary?
+        it 'should set the alias to "max_id"' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].maximum
+          mgr.to_sql.must_be_like %{
+            SELECT MAX("users"."id") AS max_id
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#minimum' do
+        it 'should create a Min node' do
+          relation = Table.new(:users)
+          relation[:id].minimum.must_be_kind_of Nodes::Min
+        end
+      end
+
+      describe '#sum' do
+        it 'should create a SUM node' do
+          relation = Table.new(:users)
+          relation[:id].sum.must_be_kind_of Nodes::Sum
+        end
+
+        # FIXME: backwards compat. Is this really necessary?
+        it 'should set the alias to "sum_id"' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id].sum
+          mgr.to_sql.must_be_like %{
+            SELECT SUM("users"."id") AS sum_id
+            FROM "users"
+          }
+        end
+      end
+
+      describe '#count' do
+        it 'should return a count node' do
+          relation = Table.new(:users)
+          relation[:id].count.must_be_kind_of Nodes::Count
+        end
+
+        it 'should take a distinct param' do
+          relation = Table.new(:users)
+          count = relation[:id].count(nil)
+          count.must_be_kind_of Nodes::Count
+          count.distinct.must_be_nil
+        end
+      end
+
+      describe '#eq' do
+        it 'should return an equality node' do
+          attribute = Attribute.new nil, nil, nil
+          equality = attribute.eq 1
+          equality.left.must_equal attribute
+          equality.right.must_equal 1
+          equality.must_be_kind_of Nodes::Equality
+        end
+
+        it 'should generate = in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(10)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" = 10
+          }
+        end
+
+        it 'should handle nil' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq(nil)
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL
+          }
+        end
+      end
+
+      describe '#eq_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_any([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2)
+          }
+        end
+
+        it 'should not eat input' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1,2]
+          mgr.where relation[:id].eq_any(values)
+          values.must_equal [1,2]
+        end
+      end
+
+      describe '#eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+
+        it 'should not eat input' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          values = [1,2]
+          mgr.where relation[:id].eq_all(values)
+          values.must_equal [1,2]
+        end
+      end
+
+      describe '#matches' do
+        it 'should create a Matches node' do
+          relation = Table.new(:users)
+          relation[:name].matches('%bacon%').must_be_kind_of Nodes::Matches
+        end
+
+        it 'should generate LIKE in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches('%bacon%')
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe '#matches_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].matches_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_any(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#matches_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].matches_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].matches_all(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#does_not_match' do
+        it 'should create a DoesNotMatch node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match('%bacon%').must_be_kind_of Nodes::DoesNotMatch
+        end
+
+        it 'should generate NOT LIKE in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match('%bacon%')
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%'
+          }
+        end
+      end
+
+      describe '#does_not_match_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_any(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#does_not_match_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:name].does_not_match_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%')
+          }
+        end
+      end
+
+      describe '#in' do
+        it 'can be constructed with a list' do
+        end
+
+        it 'should return an in node' do
+          attribute = Attribute.new nil, nil, nil
+          node = Nodes::In.new attribute, [1,2,3]
+          node.left.must_equal attribute
+          node.right.must_equal [1, 2, 3]
+        end
+
+        it 'should generate IN in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in([1,2,3])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe '#in_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].in_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_any([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe '#in_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].in_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].in_all([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4))
+          }
+        end
+      end
+
+      describe '#not_in' do
+        it 'can be constructed with a list' do
+        end
+
+        it 'should return a NotIn node' do
+          attribute = Attribute.new nil, nil, nil
+          node = Nodes::NotIn.new attribute, [1,2,3]
+          node.left.must_equal attribute
+          node.right.must_equal [1, 2, 3]
+        end
+
+        it 'should generate NOT IN in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in([1,2,3])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3)
+          }
+        end
+      end
+
+      describe '#not_in_any' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_in_any([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ORs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_any([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe '#not_in_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].not_in_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].not_in_all([[1,2], [3,4]])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4))
+          }
+        end
+      end
+
+      describe '#eq_all' do
+        it 'should create a Grouping node' do
+          relation = Table.new(:users)
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
+        end
+
+        it 'should generate ANDs in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:id].eq_all([1,2])
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
+          }
+        end
+      end
+
+      describe '#asc' do
+        it 'should create an Ordering node' do
+          relation = Table.new(:users)
+          relation[:id].asc.must_be_kind_of Nodes::Ordering
+        end
+
+        it 'should generate ASC in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].asc
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC
+          }
+        end
+      end
+
+      describe '#desc' do
+        it 'should create an Ordering node' do
+          relation = Table.new(:users)
+          relation[:id].desc.must_be_kind_of Nodes::Ordering
+        end
+
+        it 'should generate DESC in sql' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.order relation[:id].desc
+          mgr.to_sql.must_be_like %{
+            SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC
+          }
+        end
+      end
+    end
+
+    describe 'equality' do
+      describe '#to_sql' do
+        it 'should produce sql' do
+          table = Table.new :users
+          condition = table['id'].eq 1
+          condition.to_sql.must_equal '"users"."id" = 1'
+        end
+      end
+    end
+  end
+end