axiom-sql-generator 0.1.0

data/spec/unit/axiom/sql/generator/function/string/visit_axiom_function_string_length_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Function::String, '#visit_axiom_function_string_length' do
+  subject { object.visit_axiom_function_string_length(length) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Function::String } }
+  let(:length)          { Attribute::String.new(:name).length                                             }
+  let(:object)          { described_class.new                                                             }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('LENGTH ("name")') }
+end

data/spec/unit/axiom/sql/generator/identifier/visit_identifier_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Identifier, '#visit_identifier' do
+  subject { object.visit_identifier(identifier) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Identifier } }
+  let(:object)          { described_class.new                                                       }
+
+  context 'with an identifier containing no quotes' do
+    let(:identifier) { 'users' }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users"') }
+  end
+
+  context 'with an identifier containing quotes' do
+    let(:identifier) { 'users"name' }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users""name"') }
+  end
+end

data/spec/unit/axiom/sql/generator/literal/class_methods/dup_frozen_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '.dup_frozen' do
+  subject { object.dup_frozen(object_arg) }
+
+  let(:object) { SQL::Generator::Literal }
+
+  context 'with a frozen object' do
+    let(:object_arg) { Time.now.freeze }
+
+    it { should_not equal(object_arg) }
+
+    it { should == object_arg }
+  end
+
+  context 'with a non-frozen object' do
+    let(:object_arg) { Time.now }
+
+    it { should equal(object_arg) }
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_class_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_class' do
+  subject { object.visit_class(klass) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  before do
+    Object.class_eval { remove_const(:NamedClass) if const_defined?(:NamedClass) }
+    class ::NamedClass; end
+  end
+
+  context 'with a named class' do
+    let(:klass) { NamedClass.freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'NamedClass'") }
+  end
+
+  context 'with an anonymous class' do
+    let(:klass) { described_class }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('NULL') }
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_date_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_date' do
+  subject { object.visit_date(date) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:date)            { Date.new(2010, 12, 31).freeze                                          }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql("'2010-12-31'") }
+end

data/spec/unit/axiom/sql/generator/literal/visit_date_time_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_date_time' do
+  subject { object.visit_date_time(date_time) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:nsec_in_seconds) { Rational(nsec, 10**9)                                                  }
+  let(:object)          { described_class.new                                                    }
+
+  context 'when the DateTime is UTC' do
+    let(:offset) { 0 }
+
+    context 'and the nanoseconds are equal to 0' do
+      let(:nsec)      { 0                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000+00:00'") }
+    end
+
+    context 'and the nanoseconds are greater than 0' do
+      let(:nsec)      { 1                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 23, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000001+00:00'") }
+    end
+  end
+
+  context 'when the DateTime is not UTC' do
+    let(:offset) { Rational(-8, 24) }
+
+    context 'and the nanoseconds are equal to 0' do
+      let(:nsec)      { 0                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 15, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000+00:00'") }
+    end
+
+    context 'and the nanoseconds are greater than 0' do
+      let(:nsec)      { 1                                                                       }
+      let(:date_time) { DateTime.new(2010, 12, 31, 15, 59, 59 + nsec_in_seconds, offset).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000001+00:00'") }
+    end
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_enumerable_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_enumerable' do
+  subject { object.visit_enumerable(enumerable) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:enumerable)      { [ 1, 2 ].freeze                                                        }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('(1, 2)') }
+end

data/spec/unit/axiom/sql/generator/literal/visit_false_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_false_class' do
+  subject { object.visit_false_class(false) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('FALSE') }
+end

data/spec/unit/axiom/sql/generator/literal/visit_nil_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_nil_class' do
+  subject { object.visit_nil_class(nil) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('NULL') }
+end

data/spec/unit/axiom/sql/generator/literal/visit_numeric_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_numeric' do
+  subject { object.visit_numeric(numeric) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  context 'with an Integer' do
+    let(:numeric) { 1 }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1') }
+  end
+
+  context 'with a Float' do
+    let(:numeric) { 1.0 }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('1.0') }
+  end
+
+  context 'with a BigDecimal' do
+    let(:numeric) { BigDecimal('1.0') }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('0.1E1') }
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_string_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_string' do
+  subject { object.visit_string(string) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  context 'with a string containing no quotes' do
+    let(:string) { 'string'.freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'string'") }
+  end
+
+  context 'with a string containing quotes' do
+    let(:string) { "string'name".freeze }
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql("'string''name'") }
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_time_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_time' do
+  subject { object.visit_time(time) }
+
+  # Time#iso8601 is currently broken in JRuby 1.7.0.dev when fractional seconds are not 0
+  def self.time_iso8601_broken?
+    RUBY_PLATFORM.include?('java') && JRUBY_VERSION <= '1.7.0.dev' && RUBY_VERSION >= '1.9.2'
+  end
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  before :all do
+    @original_tz = ENV['TZ']
+  end
+
+  after :all do
+    ENV['TZ'] = @original_tz
+  end
+
+  context 'when the Time is UTC' do
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                               }
+      let(:time) { Time.utc(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                               }
+      let(:time) { Time.utc(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+
+  context 'when the Time is local, and the local time zone is UTC' do
+    before :all do
+      ENV['TZ'] = 'UTC'
+    end
+
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                                 }
+      let(:time) { Time.local(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                                 }
+      let(:time) { Time.local(2010, 12, 31, 23, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+
+  context 'when the Time is local, and the local time zone is not UTC' do
+    before :all do
+      ENV['TZ'] = 'America/Vancouver'
+    end
+
+    context 'and the microseconds are equal to 0' do
+      let(:usec) { 0                                                 }
+      let(:time) { Time.local(2010, 12, 31, 15, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      its(:to_s) { should eql("'2010-12-31T23:59:59.000000000Z'") }
+    end
+
+    context 'and the microseconds are greater than 0' do
+      let(:usec) { 1                                                 }
+      let(:time) { Time.local(2010, 12, 31, 15, 59, 59, usec).freeze }
+
+      it_should_behave_like 'a generated SQL expression'
+
+      unless time_iso8601_broken?
+        its(:to_s) { should eql("'2010-12-31T23:59:59.000001000Z'") }
+      end
+    end
+  end
+end

data/spec/unit/axiom/sql/generator/literal/visit_true_class_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Literal, '#visit_true_class' do
+  subject { object.visit_true_class(true) }
+
+  let(:described_class) { Class.new(SQL::Generator::Visitor) { include SQL::Generator::Literal } }
+  let(:object)          { described_class.new                                                    }
+
+  it_should_behave_like 'a generated SQL expression'
+
+  its(:to_s) { should eql('TRUE') }
+end

data/spec/unit/axiom/sql/generator/relation/binary/base/to_subquery_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary::Base, '#to_subquery' do
+  subject { object.to_subquery }
+
+  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 no object visited' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should respond_to(:to_s) }
+
+    it { should be_frozen }
+
+    its(:to_s) { should == '' }
+  end
+
+  context 'when a base relation is visited' do
+    before do
+      object.visit(base_relation)
+    end
+
+    it_should_behave_like 'a generated SQL expression'
+
+    its(:to_s) { should eql('"users"') }
+  end
+end

data/spec/unit/axiom/sql/generator/relation/binary/base/visit_axiom_relation_base_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SQL::Generator::Relation::Binary::Base, '#visit_axiom_relation_base' do
+  subject { object.visit_axiom_relation_base(base_relation) }
+
+  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(:object)        { described_class.new                              }
+
+  it_should_behave_like 'a generated SQL SELECT query'
+
+  its(:name) { should eql('users') }
+
+  its(:to_subquery) { should eql('"users"') }
+end