sequel-impala 1.0.1 → 1.1.0

data/lib/thrift/thrift_hive.rb

@@ -11,7 +11,7 @@ require_relative 'hive_service_types'
 module Hive
   module Thrift
     module ThriftHive
-      class Client < ::ThriftHiveMetastore::Client 
+      class Client < ::ThriftHiveMetastore::Client
         include ::Thrift::Client
 
         def execute(query)
@@ -143,7 +143,7 @@ module Hive
 
       end
 
-      class Processor < ::ThriftHiveMetastore::Processor 
+      class Processor < ::ThriftHiveMetastore::Processor
         include ::Thrift::Processor
 
         def process_execute(seqid, iprot, oprot)

data/lib/thrift/thrift_hive_metastore.rb

@@ -9,7 +9,7 @@ require_relative 'facebook_service'
 require_relative 'hive_metastore_types'
 
 module ThriftHiveMetastore
-  class Client < ::FacebookService::Client 
+  class Client < ::FacebookService::Client
     include ::Thrift::Client
 
     def create_database(database)
@@ -959,7 +959,7 @@ module ThriftHiveMetastore
 
   end
 
-  class Processor < ::FacebookService::Processor 
+  class Processor < ::FacebookService::Processor
     include ::Thrift::Processor
 
     def process_create_database(seqid, iprot, oprot)

data/spec/dataset_test.rb

@@ -16,8 +16,8 @@ describe "Simple Dataset operations" do
     end
     @ds << {:id=>1, :number=>20}
     @ds << {:id=>2, :number=>30}
-    @ds.order(:number).all.must_equal [{:id => 1, :number=>20}, {:id => 2, :number=>30}]   
-  end 
+    @ds.order(:number).all.must_equal [{:id => 1, :number=>20}, {:id => 2, :number=>30}]
+  end
 
   it "should have insert work correctly with static SQL" do
     @db.create_table!(:items) do
@@ -25,7 +25,7 @@ describe "Simple Dataset operations" do
       Integer :number
     end
     @db["INSERT INTO #{@ds.literal(:items)} (id, number) VALUES (2, 30)"].insert
-    @ds.all.must_equal [{:id => 2, :number=>30}]   
+    @ds.all.must_equal [{:id => 2, :number=>30}]
   end
 
   it "should have insert work correctly when inserting a row with all NULL values" do
@@ -108,7 +108,7 @@ describe "Simple Dataset operations" do
     @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 1).all.must_equal []
     @db.drop_table(:items2)
   end
-  
+
 end
 
 describe "Simple Dataset operations" do
@@ -165,26 +165,26 @@ describe "Simple Dataset operations" do
     @ds.single_record.must_equal(:id=>1, :number=>10)
     @ds.single_record!.must_equal(:id=>1, :number=>10)
   end
-  
+
   it "should work correctly when returning from each without iterating over the whole result set" do
     @ds.order(:id).each{|v| break v}.must_equal(:id=>1, :number=>10)
     @ds.reverse(:id).each{|v| break v}.must_equal(:id=>1, :number=>10)
   end
-  
+
   it "should fetch a single value correctly" do
     @ds.get(:id).must_equal 1
     @ds.select(:id).single_value.must_equal 1
     @ds.select(:id).single_value!.must_equal 1
   end
-  
+
   it "should have distinct work with limit" do
     @ds.limit(1).distinct.all.must_equal [{:id=>1, :number=>10}]
   end
-  
+
   it "should fetch correctly with a limit" do
     @ds.order(:id).limit(1).all.must_equal [{:id=>1, :number=>10}]
   end
-  
+
   it "should fetch correctly with a limit and offset" do
     @ds.order(:id).limit(1, 0).all.must_equal [{:id=>1, :number=>10}]
     @ds.order(:id).limit(1, 1).all.must_equal []
@@ -199,7 +199,7 @@ describe "Simple Dataset operations" do
     @ds.order(:id).limit(1).offset(0).all.must_equal [{:id=>1, :number=>10}]
     @ds.order(:id).limit(1).offset(1).all.must_equal []
   end
-  
+
   it "should provide correct columns when using a limit and offset" do
     ds = @ds.order(:id).limit(1, 1)
     ds.all
@@ -223,12 +223,12 @@ describe "Simple Dataset operations" do
   it "should fetch correctly with a limit in an IN subselect" do
     @ds.where(:id=>@ds.select(:id).order(:id).limit(1)).all.must_equal [{:id=>1, :number=>10}]
   end
-  
+
   it "should fetch correctly with a limit and offset in an IN subselect" do
     @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 0)).all.must_equal [{:id=>1, :number=>10}]
     @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.must_equal []
   end
-  
+
   it "should fetch correctly when using limit and offset in a from_self" do
     ds = @ds.order(:id).limit(1, 1).from_self
     ds.all.must_equal []
@@ -274,19 +274,19 @@ describe Sequel::Dataset do
 
   it "should correctly return avg" do
     @d.avg(:value).to_i.must_equal 456
-  end 
-  
+  end
+
   it "should correctly return sum" do
     @d.sum(:value).to_i.must_equal 1368
-  end 
-  
+  end
+
   it "should correctly return max" do
-    @d.max(:value).to_i.must_equal 789 
-  end 
-  
+    @d.max(:value).to_i.must_equal 789
+  end
+
   it "should correctly return min" do
-    @d.min(:value).to_i.must_equal 123 
-  end 
+    @d.min(:value).to_i.must_equal 123
+  end
 
   it "should return the correct record count" do
     @d.count.must_equal 3
@@ -318,7 +318,7 @@ describe Sequel::Database do
      "\\\\\n",
      "\\\r\n",
      "\\\\\r\n",
-     "\\\\\n\n", 
+     "\\\\\n\n",
      "\\\\\r\n\r\n",
      "\b\a'\0\3",
      #"\t\b\a'\0\3",
@@ -395,11 +395,11 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   after(:all) do
     DB.drop_table?(:i1, :i2, :i3)
   end
-  
+
   it "should give the correct results for simple UNION" do
     @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.must_equal %w'8 9 10 20 30 38 39'
   end
-  
+
   it "should give the correct results for UNION when used with ordering and limits" do
 
     @ds1.reverse_order(:number).union(@ds2).order(:number).map{|x| x[:number].to_s}.must_equal %w'8 9 10 20 30 38 39'
@@ -439,11 +439,11 @@ describe "Common Table Expressions" do
   after(:all) do
     @db.drop_table?(:i1)
   end
-  
+
   it "should give correct results for WITH" do
     @db[:t].with(:t, @ds.filter(:parent_id=>nil).select(:id)).order(:id).map(:id).must_equal [1, 2]
   end
-  
+
   it "should support joining a dataset with a CTE" do
     @ds.inner_join(@db[:t].with(:t, @ds.filter(:parent_id=>nil)), :id => :id).select(:i1__id).order(:i1__id).map(:id).must_equal [1,2]
     @db[:t].with(:t, @ds).inner_join(@db[:s].with(:s, @ds.filter(:parent_id=>nil)), :id => :id).select(:t__id).order(:t__id).map(:id).must_equal [1,2]
@@ -483,34 +483,34 @@ describe "Window Functions" do
   after(:all) do
     @db.drop_table?(:i1)
   end
-  
+
   it "should give correct results for aggregate window functions" do
     @ds.select(:id){sum(:amount).over(:partition=>:group_id).as(:sum)}.all.
       must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
     @ds.select(:id){sum(:amount).over.as(:sum)}.all.
       must_equal [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
   end
-    
+
   it "should give correct results for ranking window functions with orders" do
     @ds.select(:id){rank{}.over(:partition=>:group_id, :order=>:id).as(:rank)}.all.
       must_equal [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>1, :id=>4}, {:rank=>2, :id=>5}, {:rank=>3, :id=>6}]
     @ds.select(:id){rank{}.over(:order=>id).as(:rank)}.all.
       must_equal [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>4, :id=>4}, {:rank=>5, :id=>5}, {:rank=>6, :id=>6}]
   end
-    
+
   it "should give correct results for aggregate window functions with orders" do
     @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:id).as(:sum)}.all.
       must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
     @ds.select(:id){sum(:amount).over(:order=>:id).as(:sum)}.all.
       must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
   end
-  
+
   it "should give correct results for aggregate window functions with frames" do
     @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:id, :frame=>:all).as(:sum)}.all.
       must_equal [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
     @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>:all).as(:sum)}.all.
       must_equal [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
-      
+
     @ds.select(:id){sum(:amount).over(:partition=>:group_id, :order=>:id, :frame=>:rows).as(:sum)}.all.
       must_equal [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
     @ds.select(:id){sum(:amount).over(:order=>:id, :frame=>:rows).as(:sum)}.all.
@@ -537,7 +537,7 @@ describe Sequel::SQL::Constants do
   after do
     @db.drop_table?(:constants)
   end
-  
+
   it "should have working CURRENT_TIMESTAMP" do
     @db.create_table!(:constants){DateTime :ts}
     @ds.insert(:ts=>Sequel::CURRENT_TIMESTAMP)
@@ -572,7 +572,7 @@ describe "Sequel::Dataset#import and #multi_insert" do
     @ids.all.must_equal [{:i=>10}, {:i=>20}]
     @db.drop_table(:exp2)
   end
-  
+
   it "should have import work with the :slice_size option" do
     @ids.import([:i], [[10], [20], [30]], :slice_size=>1)
     @ids.all.must_equal [{:i=>10}, {:i=>20}, {:i=>30}]
@@ -593,20 +593,20 @@ describe "Sequel::Dataset convenience methods" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "#empty? should return whether the dataset returns no rows" do
     @ds.empty?.must_equal true
     @ds.insert(20, 10)
     @ds.empty?.must_equal false
   end
-  
+
   it "#empty? should work correctly for datasets with limits" do
     ds = @ds.limit(1)
     ds.empty?.must_equal true
     ds.insert(20, 10)
     ds.empty?.must_equal false
   end
-  
+
   it "#empty? should work correctly for datasets with limits and offsets" do
     ds = @ds.order(:a).limit(1, 1)
     ds.empty?.must_equal true
@@ -615,7 +615,7 @@ describe "Sequel::Dataset convenience methods" do
     ds.insert(20, 10)
     ds.empty?.must_equal false
   end
-  
+
   it "#group_and_count should return a grouping by count" do
     @ds.group_and_count(:a).order{count(:a)}.all.must_equal []
     @ds.insert(20, 10)
@@ -625,7 +625,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.insert(30, 30)
     @ds.group_and_count(:a).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:a=>30, :count=>1}, {:a=>20, :count=>2}]
   end
-  
+
   it "#group_and_count should support column aliases" do
     @ds.group_and_count(:a___c).order{count(:a)}.all.must_equal []
     @ds.insert(20, 10)
@@ -635,7 +635,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.insert(30, 30)
     @ds.group_and_count(:a___c).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
   end
-  
+
   it "#range should return the range between the maximum and minimum values" do
     @ds = @ds.unordered
     @ds.insert(20, 10)
@@ -643,7 +643,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.range(:a).must_equal(20..30)
     @ds.range(:b).must_equal(10..10)
   end
-  
+
   it "#interval should return the different between the maximum and minimum values" do
     @ds = @ds.unordered
     @ds.insert(20, 10)
@@ -652,7 +652,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.interval(:b).to_i.must_equal 0
   end
 end
-  
+
 describe "Sequel::Dataset main SQL methods" do
   before do
     @db = DB
@@ -662,21 +662,21 @@ describe "Sequel::Dataset main SQL methods" do
   after do
     @db.drop_table?(:d)
   end
-  
+
   it "#exists should return a usable exists clause" do
     @ds.filter(@db[:d___c].filter(:c__a=>:d__b).exists).all.must_equal []
     @ds.insert(20, 30)
     @ds.insert(10, 20)
     @ds.filter(@db[:d___c].filter(:c__a=>:d__b).exists).all.must_equal [{:a=>10, :b=>20}]
   end
-  
+
   it "#filter and #exclude should work with placeholder strings" do
     @ds.insert(20, 30)
     @ds.filter("a > ?", 15).all.must_equal [{:a=>20, :b=>30}]
     @ds.exclude("b < ?", 15).all.must_equal [{:a=>20, :b=>30}]
     @ds.filter("b < ?", 15).invert.all.must_equal [{:a=>20, :b=>30}]
   end
-  
+
   it "#and and #or should work correctly" do
     @ds.insert(20, 30)
     @ds.filter(:a=>20).and(:b=>30).all.must_equal [{:a=>20, :b=>30}]
@@ -701,7 +701,7 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.insert(20, 30)
     @ds.select_group(:b___c).all.must_equal [{:c=>30}]
   end
-  
+
   it "#having should work correctly" do
     @ds.unordered!
     @ds.select{[b, max(a).as(c)]}.group(:b).having{max(a) > 30}.all.must_equal []
@@ -710,7 +710,7 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.insert(40, 20)
     @ds.select{[b, max(a).as(c)]}.group(:b).having{max(a) > 30}.all.each{|h| h[:c] = h[:c].to_i}.must_equal [{:b=>20, :c=>40}]
   end
-  
+
   it "#having should work without a previous group" do
     @ds.unordered!
     @ds.select{max(a).as(c)}.having{max(a) > 30}.all.must_equal []
@@ -732,13 +732,13 @@ describe "Sequel::Dataset convenience methods" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "should have working #map" do
     @ds.map(:a).must_equal [1, 5]
     @ds.map(:b).must_equal [2, 6]
     @ds.map([:a, :b]).must_equal [[1, 2], [5, 6]]
   end
-  
+
   it "should have working #to_hash" do
     @ds.to_hash(:a).must_equal(1=>{:a=>1, :b=>2, :c=>3, :d=>4}, 5=>{:a=>5, :b=>6, :c=>7, :d=>8})
     @ds.to_hash(:b).must_equal(2=>{:a=>1, :b=>2, :c=>3, :d=>4}, 6=>{:a=>5, :b=>6, :c=>7, :d=>8})
@@ -777,7 +777,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.select_map([Sequel.qualify(:a, :a).as(:e), Sequel.qualify(:a, :b).as(:f)]).must_equal [[1, 2], [5, 6]]
     @ds.select_map([Sequel.identifier(:a).qualify(:a).as(:e), Sequel.qualify(:a, :b).as(:f)]).must_equal [[1, 2], [5, 6]]
   end
-  
+
   it "should have working #select_order_map" do
     @ds.select_order_map(:a).must_equal [1, 5]
     @ds.select_order_map(Sequel.desc(:a__b)).must_equal [6, 2]
@@ -829,7 +829,7 @@ describe "Sequel::Dataset DSL support" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "should work with standard mathematical operators" do
     @ds.insert(20, 10)
     @ds.get{a + b}.to_i.must_equal 30
@@ -837,7 +837,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.get{a * b}.to_i.must_equal 200
     @ds.get{a / b}.to_i.must_equal 2
   end
-  
+
   it "should work with bitwise AND and OR operators" do
     @ds.insert(3, 5)
     @ds.get{a.sql_number | b}.to_i.must_equal 7
@@ -845,26 +845,26 @@ describe "Sequel::Dataset DSL support" do
     @ds.get{a.sql_number | b | 8}.to_i.must_equal 15
     @ds.get{a.sql_number & b & 8}.to_i.must_equal 0
   end
-  
+
   it "should work with the bitwise compliment operator" do
     @ds.insert(-3, 3)
     @ds.get{~a.sql_number}.to_i.must_equal 2
     @ds.get{~b.sql_number}.to_i.must_equal(-4)
   end
-  
+
   it "should work with the bitwise xor operator" do
     @ds.insert(3, 5)
     @ds.get{a.sql_number ^ b}.to_i.must_equal 6
     @ds.get{a.sql_number ^ b ^ 1}.to_i.must_equal 7
   end
-  
+
   it "should work with the modulus operator" do
     @ds.insert(3, 5)
     @ds.get{a.sql_number % 4}.to_i.must_equal 3
     @ds.get{b.sql_number % 4}.to_i.must_equal 1
     @ds.get{a.sql_number % 4 % 2}.to_i.must_equal 1
   end
-  
+
   it "should work with inequality operators" do
     @ds.insert(10, 11)
     @ds.insert(11, 11)
@@ -875,12 +875,12 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter{a < b}.select_order_map(:a).must_equal [10]
     @ds.filter{a <= b}.select_order_map(:a).must_equal [10, 11, 20]
   end
-  
+
   it "should work with casting and string concatentation" do
     @ds.insert(20, 20)
     @ds.get{Sequel.cast(a, String).sql_string + Sequel.cast(b, String)}.must_equal '2020'
   end
-  
+
   it "should work with ordering" do
     @ds.insert(10, 20)
     @ds.insert(20, 10)
@@ -888,14 +888,14 @@ describe "Sequel::Dataset DSL support" do
     @ds.order(Sequel.asc(:a), Sequel.asc(:b)).all.must_equal [{:a=>10, :b=>20}, {:a=>20, :b=>10}]
     @ds.order(Sequel.desc(:a), Sequel.desc(:b)).all.must_equal [{:a=>20, :b=>10}, {:a=>10, :b=>20}]
   end
-  
+
   it "should work with qualifying" do
     @ds.insert(10, 20)
     @ds.get(:a__b).must_equal 20
     @ds.get{a__b}.must_equal 20
     @ds.get(Sequel.qualify(:a, :b)).must_equal 20
   end
-  
+
   it "should work with aliasing" do
     @ds.insert(10, 20)
     @ds.get(:a__b___c).must_equal 20
@@ -903,12 +903,12 @@ describe "Sequel::Dataset DSL support" do
     @ds.get(Sequel.qualify(:a, :b).as(:c)).must_equal 20
     @ds.get(Sequel.as(:b, :c)).must_equal 20
   end
-  
+
   it "should work with selecting all columns of a table" do
     @ds.insert(20, 10)
     @ds.select_all(:a).all.must_equal [{:a=>20, :b=>10}]
   end
-  
+
   it "should work with ranges as hash values" do
     @ds.insert(20, 10)
     @ds.filter(:a=>(10..30)).all.must_equal [{:a=>20, :b=>10}]
@@ -918,7 +918,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:a=>(25..30)).all.must_equal [{:a=>20, :b=>10}]
     @ds.exclude(:a=>(10..15)).all.must_equal [{:a=>20, :b=>10}]
   end
-  
+
   it "should work with nil as hash value" do
     @ds.insert(20, nil)
     @ds.filter(:a=>nil).all.must_equal []
@@ -926,7 +926,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:b=>nil).all.must_equal []
     @ds.exclude(:a=>nil).all.must_equal [{:a=>20, :b=>nil}]
   end
-  
+
   it "should work with arrays as hash values" do
     @ds.insert(20, 10)
     @ds.filter(:a=>[10]).all.must_equal []
@@ -934,7 +934,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:a=>[10]).all.must_equal [{:a=>20, :b=>10}]
     @ds.exclude(:a=>[20, 10]).all.must_equal []
   end
-  
+
   it "should work with ranges as hash values" do
     @ds.insert(20, 10)
     @ds.filter(:a=>(10..30)).all.must_equal [{:a=>20, :b=>10}]
@@ -944,7 +944,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.exclude(:a=>(25..30)).all.must_equal [{:a=>20, :b=>10}]
     @ds.exclude(:a=>(10..15)).all.must_equal [{:a=>20, :b=>10}]
   end
-  
+
   it "should work with CASE statements" do
     @ds.insert(20, 10)
     @ds.filter(Sequel.case({{:a=>20}=>20}, 0) > 0).all.must_equal [{:a=>20, :b=>10}]
@@ -952,7 +952,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter(Sequel.case({20=>20}, 0, :a) > 0).all.must_equal [{:a=>20, :b=>10}]
     @ds.filter(Sequel.case({15=>20}, 0, :a) > 0).all.must_equal []
   end
-  
+
   it "should work with multiple value arrays" do
     @ds.insert(20, 10)
     @ds.quote_identifiers = false
@@ -960,7 +960,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter([:a, :b]=>[[10, 20]]).all.must_equal []
     @ds.filter([:a, :b]=>[[20, 10], [1, 2]]).all.must_equal [{:a=>20, :b=>10}]
     @ds.filter([:a, :b]=>[[10, 10], [20, 20]]).all.must_equal []
-    
+
     @ds.exclude([:a, :b]=>[[20, 10]]).all.must_equal []
     @ds.exclude([:a, :b]=>[[10, 20]]).all.must_equal [{:a=>20, :b=>10}]
     @ds.exclude([:a, :b]=>[[20, 10], [1, 2]]).all.must_equal []
@@ -993,7 +993,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter([:a, :b]=>[]).all.must_equal []
     @ds.exclude([:a, :b]=>[]).all.must_equal [{:a=>20, :b=>10}]
   end
-  
+
   it "should work empty arrays with nulls" do
     @ds = @ds.extension(:empty_array_consider_nulls)
     @ds.insert(nil, nil)
@@ -1008,7 +1008,7 @@ describe "Sequel::Dataset DSL support" do
     pr[@ds.get(Sequel.expr([:a, :b]=>[]))].must_equal nil
     pr[@ds.get(~Sequel.expr([:a, :b]=>[]))].must_equal nil
   end
-  
+
   it "should work empty arrays with nulls and the empty_array_ignore_nulls extension" do
     ds = @ds
     ds.insert(nil, nil)
@@ -1043,7 +1043,7 @@ describe "SQL Extract Function" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "should return the part of the datetime asked for" do
     t = Time.now
     def @ds.supports_timestamp_timezones?() false end
@@ -1069,7 +1069,7 @@ describe "Dataset string methods" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "#grep should return matching rows" do
     @ds.insert('foo', 'bar')
     @ds.grep(:a, 'foo').all.must_equal [{:a=>'foo', :b=>'bar'}]
@@ -1079,7 +1079,7 @@ describe "Dataset string methods" do
     @ds.grep([:a, :b], %w'foo bar').all.must_equal [{:a=>'foo', :b=>'bar'}]
     @ds.grep([:a, :b], %w'boo far').all.must_equal []
   end
-  
+
   it "#grep should work with :all_patterns and :all_columns options" do
     @ds.insert('foo bar', ' ')
     @ds.insert('foo d', 'bar')
@@ -1098,7 +1098,7 @@ describe "Dataset string methods" do
     @ds.grep([:a, :b], %w'%baz% %foo%', :all_columns=>true, :all_patterns=>true).all.must_equal []
     @ds.grep([:a, :b], %w'%boo% %foo%', :all_columns=>true, :all_patterns=>true).all.must_equal [{:a=>'foo boo', :b=>'boo foo'}]
   end
-  
+
   it "#like should return matching rows" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).like('foo')).all.must_equal [{:a=>'foo', :b=>'bar'}]
@@ -1108,7 +1108,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:a).like('bar')).all.must_equal [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(Sequel.expr(:a).like('foo', 'bar')).all.must_equal []
   end
-  
+
   it "#like should be case sensitive" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).like('Foo')).all.must_equal []
@@ -1118,7 +1118,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:b).like('baR')).all.must_equal [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(Sequel.expr(:a).like('FOO', 'BAR')).all.must_equal [{:a=>'foo', :b=>'bar'}]
   end
-  
+
   it "#ilike should return matching rows, in a case insensitive manner" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).ilike('Foo')).all.must_equal [{:a=>'foo', :b=>'bar'}]
@@ -1128,7 +1128,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:a).ilike('baR')).all.must_equal [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(Sequel.expr(:a).ilike('FOO', 'BAR')).all.must_equal []
   end
-  
+
   it "#like with regexp return matching rows" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).like(/fo/)).all.must_equal [{:a=>'foo', :b=>'bar'}]
@@ -1138,7 +1138,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:a).like(/fo$/)).all.must_equal [{:a=>'foo', :b=>'bar'}]
     @ds.exclude(Sequel.expr(:a).like(/fo/, /ar/)).all.must_equal []
   end
-  
+
   it "#like with regexp should be case sensitive if regexp is case sensitive" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).like(/Fo/)).all.must_equal []
@@ -1155,7 +1155,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:b).like(/baR/i)).all.must_equal []
     @ds.exclude(Sequel.expr(:a).like(/FOO/i, /BAR/i)).all.must_equal []
   end
-  
+
   it "#ilike with regexp should return matching rows, in a case insensitive manner" do
     @ds.insert('foo', 'bar')
     @ds.filter(Sequel.expr(:a).ilike(/Fo/)).all.must_equal [{:a=>'foo', :b=>'bar'}]
@@ -1165,7 +1165,7 @@ describe "Dataset string methods" do
     @ds.exclude(Sequel.expr(:b).ilike(/baR/)).all.must_equal []
     @ds.exclude(Sequel.expr(:a).ilike(/FOO/, /BAR/)).all.must_equal []
   end
-  
+
   it "should work with strings created with Sequel.join" do
     @ds.insert('foo', 'bar')
     @ds.get(Sequel.join([:a, "bar"])).must_equal 'foobar'
@@ -1190,14 +1190,14 @@ describe "Dataset identifier methods" do
   after(:all) do
     @db.drop_table?(:a)
   end
-  
+
   it "#identifier_output_method should change how identifiers are output" do
     @ds.identifier_output_method = :upcase
     @ds.first.must_equal(:AB=>1)
     @ds.identifier_output_method = :uprev
     @ds.first.must_equal(:BA=>1)
   end
-  
+
   it "should work with a nil identifier_output_method" do
     @ds.identifier_output_method = nil
     [{:ab=>1}, {:AB=>1}].must_include(@ds.first)
@@ -1218,14 +1218,14 @@ describe "Dataset defaults and overrides" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "#set_defaults should set defaults that can be overridden" do
     @ds = @ds.set_defaults(:a=>10)
     @ds.insert
     @ds.insert(:a=>20)
     @ds.all.must_equal [{:a=>10}, {:a=>20}]
   end
-  
+
   it "#set_overrides should set defaults that cannot be overridden" do
     @ds = @ds.set_overrides(:a=>10)
     @ds.insert
@@ -1243,7 +1243,7 @@ describe "Emulated functions" do
   after do
     @db.drop_table?(:a)
   end
-  
+
   it "Sequel.char_length should return the length of characters in the string" do
     @ds.get(Sequel.char_length(:a)).must_equal nil
     @ds.insert(:a=>'foo')
@@ -1254,7 +1254,7 @@ describe "Emulated functions" do
     @ds.insert(:a=>' foo22 ')
     @ds.get(Sequel.char_length(:a)).must_equal 7
   end
-  
+
   it "Sequel.trim should return the string with spaces trimmed from both sides" do
     @ds.get(Sequel.trim(:a)).must_equal nil
     @ds.insert(:a=>'foo')