axiom-sql-generator 0.1.0

data/spec/unit/axiom/sql/generator/relation/unary/visit_axiom_relation_operation_reverse_spec.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Unary, '#visit_axiom_relation_operation_reverse' do
+  subject { object.visit_axiom_relation_operation_reverse(order) }
+
+  let(:relation_name) { 'users'                                          }
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { Relation::Base.new(relation_name, header, body)  }
+  let(:order)         { operand.reverse                                  }
+  let(:object)        { described_class.new                              }
+
+  context 'when the operand is a base relation' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is a projection' do
+    let(:operand) { base_relation.project([ :id, :name ]).sort_by { |r| [ r.id, r.name ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT DISTINCT "id", "name" FROM "users" ORDER BY "id" DESC, "name" DESC')   }
+    its(:to_subquery) { should eql('(SELECT DISTINCT "id", "name" FROM "users" ORDER BY "id" DESC, "name" DESC)') }
+  end
+
+  context 'when the operand is an extension' do
+    let(:operand) { base_relation.extend { |r| r.add(:one, 1) }.sort_by { |r| [ r.id, r.name, r.age, r.one ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age", 1 AS "one" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC, "one" DESC') }
+    its(:to_subquery) { should eql('(SELECT *, 1 AS "one" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC, "one" DESC)')                 }
+  end
+
+  context 'when the operand is a rename' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.rename(:id => :user_id) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "user_id" DESC, "name" DESC, "age" DESC')   }
+    its(:to_subquery) { should eql('(SELECT "id" AS "user_id", "name", "age" FROM "users" ORDER BY "user_id" DESC, "name" DESC, "age" DESC)') }
+  end
+
+  context 'when the operand is a restriction' do
+    let(:operand) { base_relation.restrict { |r| r.id.eq(1) }.sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" WHERE "id" = 1 ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" WHERE "id" = 1 ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is a summarization' do
+    context 'summarize per table dee' do
+      let(:summarize_per) { TABLE_DEE                                                                                        }
+      let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r.id.count) }.sort_by { |r| r.count } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("id") AS "count" FROM "users" ORDER BY "count" DESC')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("id") AS "count" FROM "users" ORDER BY "count" DESC)') }
+    end
+
+    context 'summarize per table dum' do
+      let(:summarize_per) { TABLE_DUM                                                                                        }
+      let(:operand)       { base_relation.summarize(summarize_per) { |r| r.add(:count, r.id.count) }.sort_by { |r| r.count } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE ORDER BY "count" DESC')   }
+      its(:to_subquery) { should eql('(SELECT COUNT ("id") AS "count" FROM "users" HAVING FALSE ORDER BY "count" DESC)') }
+    end
+
+    context 'summarize by a subset of the operand header' do
+      let(:operand) { base_relation.summarize([ :id, :name ]) { |r| r.add(:count, r.age.count) }.sort_by { |r| [ r.id, r.name, r.count ] } }
+
+      it_should_behave_like 'a generated SQL SELECT query'
+
+      its(:to_s)        { should eql('SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0 ORDER BY "id" DESC, "name" DESC, "count" DESC')   }
+      its(:to_subquery) { should eql('(SELECT "id", "name", COUNT ("age") AS "count" FROM "users" GROUP BY "id", "name" HAVING COUNT (*) > 0 ORDER BY "id" DESC, "name" DESC, "count" DESC)') }
+    end
+  end
+
+  context 'when the operand is ordered' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is reversed' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.reverse }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM "users" ORDER BY "id", "name", "age"') }
+    its(:to_subquery) { should eql('(SELECT * FROM "users" ORDER BY "id", "name", "age")')                 }
+  end
+
+  context 'when the operand is limited' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.take(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" LIMIT 1) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is an offset' do
+    let(:operand) { base_relation.sort_by { |r| [ r.id, r.name, r.age ] }.drop(1) }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" ORDER BY "id", "name", "age" OFFSET 1) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is a difference' do
+    let(:operand) { base_relation.difference(base_relation).sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") EXCEPT (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is an intersection' do
+    let(:operand) { base_relation.intersect(base_relation).sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") INTERSECT (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is a union' do
+    let(:operand) { base_relation.union(base_relation).sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM ((SELECT "id", "name", "age" FROM "users") UNION (SELECT "id", "name", "age" FROM "users")) AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+
+  context 'when the operand is a join' do
+    let(:operand) { base_relation.join(base_relation).sort_by { |r| [ r.id, r.name, r.age ] } }
+
+    it_should_behave_like 'a generated SQL SELECT query'
+
+    its(:to_s)        { should eql('SELECT "id", "name", "age" FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC') }
+    its(:to_subquery) { should eql('(SELECT * FROM (SELECT * FROM "users" AS "left" NATURAL JOIN "users" AS "right") AS "users" ORDER BY "id" DESC, "name" DESC, "age" DESC)')                 }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/visit_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation, '#visit' do
+  subject { object.visit(visitable) }
+
+  let(:described_class) { Class.new(SQL::Generator::Relation) }
+  let(:object)          { described_class.new                 }
+
+  context 'with a handled object' do
+    let(:visitable) { mock('Visitable') }
+
+    before do
+      described_class.class_eval do
+        def visit_rspec_mocks_mock(mock)
+          mock
+        end
+      end
+    end
+
+    it_should_behave_like 'a command method'
+
+    specify { expect { subject }.to change(object, :frozen?).from(false).to(true) }
+  end
+
+  context 'with a handled object more than once' do
+    let(:visitable) { mock('Visitable') }
+
+    before do
+      described_class.class_eval do
+        def visit_rspec_mocks_mock(mock)
+          mock
+        end
+      end
+    end
+
+    before do
+      object.visit(visitable)
+    end
+
+    if RUBY_VERSION >= '1.9'
+      specify { expect { subject }.to raise_error(RuntimeError) }
+    else
+      specify { expect { subject }.to raise_error(TypeError) }
+    end
+  end
+
+  context 'with an unhandled object' do
+    let(:visitable) { mock('Not Handled') }
+
+    specify { expect { subject }.to raise_error(SQL::Generator::Visitor::UnknownObject, "No handler for #{visitable.class} in #{object.class}") }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/visited_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation, '#visited?' do
+  subject { object.visited? }
+
+  let(:id)            { Attribute::Integer.new(:id)                      }
+  let(:name)          { Attribute::String.new(:name)                     }
+  let(:age)           { Attribute::Integer.new(:age, :required => false) }
+  let(:header)        { [ id, name, age ]                                }
+  let(:body)          { [ [ 1, 'Dan Kubb', 35 ] ].each                   }
+  let(:base_relation) { Relation::Base.new('users', header, body)        }
+  let(:object)        { described_class.new                              }
+
+  context 'when name is nil' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(false) }
+  end
+
+  context 'when name is set' do
+    let(:name) { 'test' }
+
+    before do
+      # subclasses set @name, but nothing in this class
+      # does does so simulate it being set
+      object.instance_variable_set(:@name, name)
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/sql/generator/visitor/class_methods/handler_for_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Visitor, '.handler_for' do
+  subject { object.handler_for(visitable_class) }
+
+  let(:object) { Class.new(SQL::Generator::Visitor) }
+
+  before :all do
+    module ::MySpec
+      class Visitable; end
+    end
+  end
+
+  after :all do
+    MySpec.class_eval { remove_const(:Visitable) }
+    Object.class_eval { remove_const(:MySpec)    }
+  end
+
+  context 'with an object handled by a public method' do
+    let(:visitable_class) { MySpec::Visitable }
+
+    before do
+      object.class_eval do
+        remove_instance_variable(:@handlers) if instance_variable_defined?(:@handlers)
+        define_method(:visit_my_spec_visitable) {}
+      end
+    end
+
+    after do
+      object.class_eval do
+        remove_instance_variable(:@handlers)
+        remove_method(:visit_my_spec_visitable)
+      end
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should == :visit_my_spec_visitable }
+  end
+
+  context 'with an object handled by a private method' do
+    let(:visitable_class) { MySpec::Visitable }
+
+    before do
+      object.class_eval do
+        remove_instance_variable(:@handlers) if instance_variable_defined?(:@handlers)
+        define_method(:visit_my_spec_visitable) {}
+        private :visit_my_spec_visitable
+      end
+    end
+
+    after do
+      object.class_eval do
+        remove_instance_variable(:@handlers)
+        remove_method(:visit_my_spec_visitable)
+      end
+    end
+
+    it_should_behave_like 'an idempotent method'
+
+    it { should == :visit_my_spec_visitable }
+  end
+
+  context 'with an unhandled object' do
+    let(:visitable_class) { Class.new }
+
+    specify { expect { subject }.to raise_error(object::UnknownObject, "No handler for #{visitable_class} in #{object}") }
+  end
+end

data/spec/unit/axiom/sql/generator/visitor/visit_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Visitor, '#visit' do
+  subject { object.visit(visitable) }
+
+  let(:visitable) { mock('handled object') }
+  let(:object)    { described_class.new    }
+
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#visit must be implemented") }
+end

data/spec/unit/axiom/sql/generator/visitor/visited_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Visitor, '#visited?' do
+  subject { object.visited? }
+
+  let(:object) { described_class.new }
+
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#visited? must be implemented") }
+end

data/spec/unit/date/iso8601_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Date, '#iso8601' do
+  subject { object.iso8601 }
+
+  context 'when the date is frozen' do
+    let(:object) { described_class.new(2010, 12, 31).freeze }
+
+    it { should respond_to(:to_s) }
+
+    it { should == '2010-12-31' }
+  end
+
+  context 'when the date is not frozen' do
+    let(:object) { described_class.new(2010, 12, 31) }
+
+    it { should respond_to(:to_s) }
+
+    it { should == '2010-12-31' }
+  end
+end

data/spec/unit/date_time/iso8601_spec.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe DateTime, '#iso8601' do
+
+  # ruby 1.9.3 has problems with fractional nanoseconds
+  def self.it_supports_nanoseconds(message = 'returns the expected date-time', &block)
+    if RUBY_VERSION >= '1.9.3'
+      it(message) { pending('Fix rounding error in 1.9.3', &block) }
+    else
+      it(message, &block)
+    end
+  end
+
+  let(:object)          { described_class.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds) }
+  let(:nsec_in_seconds) { 1 - Rational(1, 10**9)                                          }
+
+  context 'with no arguments' do
+    subject { object.iso8601 }
+
+    context 'when the datetime is frozen' do
+      before do
+        object.freeze
+      end
+
+      it { should respond_to(:to_s) }
+
+      it_supports_nanoseconds do
+        should == '2010-12-31T23:59:59+00:00'
+      end
+    end
+
+    context 'when the datetime is not frozen' do
+      it { should respond_to(:to_s) }
+
+      it { should == '2010-12-31T23:59:59+00:00' }
+    end
+  end
+
+  context 'with a time scale of 0' do
+    subject { object.iso8601(time_scale) }
+
+    let(:time_scale) { 0 }
+
+    context 'when the datetime is frozen' do
+      before do
+        object.freeze
+      end
+
+      it { should respond_to(:to_s) }
+
+      it_supports_nanoseconds do
+        should == '2010-12-31T23:59:59+00:00'
+      end
+    end
+
+    context 'when the datetime is not frozen' do
+      it { should respond_to(:to_s) }
+
+      it { should == '2010-12-31T23:59:59+00:00' }
+    end
+  end
+
+  context 'with a time scale of 1' do
+    subject { object.iso8601(time_scale) }
+
+    let(:time_scale) { 1 }
+
+    context 'when the datetime is frozen' do
+      before do
+        object.freeze
+      end
+
+      it { should respond_to(:to_s) }
+
+      it_supports_nanoseconds do
+        should == '2010-12-31T23:59:59.9+00:00'
+      end
+    end
+
+    context 'when the datetime is not frozen' do
+      it { should respond_to(:to_s) }
+
+      it { should == '2010-12-31T23:59:59.9+00:00' }
+    end
+  end
+
+  context 'with a time scale of 9' do
+    subject { object.iso8601(time_scale) }
+
+    let(:time_scale) { 9 }
+
+    context 'when the datetime is frozen' do
+      before do
+        object.freeze
+      end
+
+      it { should respond_to(:to_s) }
+
+      it_supports_nanoseconds do
+        should == '2010-12-31T23:59:59.999999999+00:00'
+      end
+    end
+
+    context 'when the datetime is not frozen' do
+      it { should respond_to(:to_s) }
+
+      it { should == '2010-12-31T23:59:59.999999999+00:00' }
+    end
+  end
+end