sequel 2.9.0 → 2.10.0

data/spec/adapters/sqlite_spec.rb

@@ -335,10 +335,10 @@ context "SQLite::Dataset#delete" do
   
   specify "should return the number of records affected when filtered" do
     @d.count.should == 3
-    @d.filter {:value < 3}.delete.should == 1
+    @d.filter {:value.sql_number < 3}.delete.should == 1
     @d.count.should == 2
 
-    @d.filter {:value < 3}.delete.should == 0
+    @d.filter {:value.sql_number < 3}.delete.should == 0
     @d.count.should == 2
   end
   

data/spec/integration/dataset_test.rb

@@ -66,7 +66,7 @@ describe "Simple Dataset operations in transactions" do
   specify "should insert correctly with a primary key specified inside a transaction" do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
-      sqls_should_be(/INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
+      sqls_should_be('Transaction.begin', /INSERT INTO items_insert_in_transaction \((number, id|id, number)\) VALUES \((100, 20|20, 100)\)/)
       @ds.count.should == 1
       @ds.order(:id).all.should == [{:id=>100, :number=>20}]
     end
@@ -75,7 +75,7 @@ describe "Simple Dataset operations in transactions" do
   specify "should have insert return primary key value inside a transaction" do
     INTEGRATION_DB.transaction do
       @ds.insert(:number=>20).should == 1
-      sqls_should_be(/INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
+      sqls_should_be('Transaction.begin', /INSERT INTO items_insert_in_transaction \(number\) VALUES \(20\)/)
       @ds.count.should == 1
       @ds.order(:id).all.should == [{:id=>1, :number=>20}]
     end
@@ -131,4 +131,4 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
       @ds1.intersect(@ds2.intersect(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10'
     end
   end
-end
+end

data/spec/integration/schema_test.rb

@@ -1,8 +1,27 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
+if INTEGRATION_DB.respond_to?(:schema_parse_table, true)
 describe "Database schema parser" do
+  before do
+    @iom = INTEGRATION_DB.identifier_output_method
+    @iim = INTEGRATION_DB.identifier_input_method
+    @defsch = INTEGRATION_DB.default_schema
+    clear_sqls
+  end
   after do
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.identifier_output_method = @iom
+    INTEGRATION_DB.identifier_input_method = @iim
+    INTEGRATION_DB.default_schema = @defsch
+  end
+
+  specify "should handle a database with a identifier_output_method" do
+    INTEGRATION_DB.identifier_output_method = :reverse
+    INTEGRATION_DB.identifier_input_method = :reverse
+    INTEGRATION_DB.default_schema = nil if INTEGRATION_DB.default_schema
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(nil, :reload=>true)[:items].should be_a_kind_of(Array)
+    INTEGRATION_DB.schema(:items, :reload=>true).first.first.should == :number
   end
 
   specify "should be a hash with table_names as symbols" do
@@ -71,6 +90,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items).first.last[:default].gsub(/::character varying\z/, '').gsub("'", '').should == "blah"
   end
 end
+end
 
 describe "Database schema modifiers" do
   before do
@@ -99,11 +119,9 @@ describe "Database schema modifiers" do
       INTEGRATION_DB.alter_table(:items){add_primary_key :id}
       INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id]
       @ds.columns!.should == [:number, :name, :id]
-      unless INTEGRATION_DB.url =~ /mysql/
-        INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
-        INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
-        @ds.columns!.should == [:number, :name, :id, :item_id]
-      end
+      INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
+      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
+      @ds.columns!.should == [:number, :name, :id, :item_id]
     end
   end
 
@@ -128,3 +146,35 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:id]
   end
 end
+
+if INTEGRATION_DB.respond_to?(:tables)
+describe "Database#tables" do
+  before do
+    class ::String
+      @@xxxxx = 0
+      def xxxxx
+        "xxxxx#{@@xxxxx += 1}"
+      end
+    end
+    @iom = INTEGRATION_DB.identifier_output_method
+    @iim = INTEGRATION_DB.identifier_input_method
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.identifier_output_method = @iom
+    INTEGRATION_DB.identifier_input_method = @iim
+  end
+
+  specify "should return an array of symbols" do
+    ts = INTEGRATION_DB.tables
+    ts.should be_a_kind_of(Array)
+    ts.each{|t| t.should be_a_kind_of(Symbol)}
+  end
+
+  specify "should respect the database's identifier_output_method" do
+    INTEGRATION_DB.identifier_output_method = :xxxxx
+    INTEGRATION_DB.identifier_input_method = :xxxxx
+    INTEGRATION_DB.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+  end
+end
+end

data/spec/integration/spec_helper.rb

@@ -13,10 +13,21 @@ def clear_sqls
   $sqls.clear
 end 
 
+class Spec::Example::ExampleGroup
+  def start_logging
+    require 'logger'
+    INTEGRATION_DB.loggers << Logger.new(STDOUT)
+  end
+  def stop_logging
+     INTEGRATION_DB.loggers.clear
+  end
+end
+
 if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRATION_URL']
   unless defined?(INTEGRATION_DB)
     url = defined?(INTEGRATION_URL) ? INTEGRATION_URL : ENV['SEQUEL_INTEGRATION_URL']
     INTEGRATION_DB = Sequel.connect(url)
+    #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
   end
   class Spec::Example::ExampleGroup
     def sqls_should_be(*args)

data/spec/integration/type_test.rb

@@ -1,43 +1,86 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe "Supported types" do
-  def create_items_table_with_column(name, type)
-    INTEGRATION_DB.create_table!(:items){column name, type}
+  def create_items_table_with_column(name, type, opts={})
+    INTEGRATION_DB.create_table!(:items){column name, type, opts}
     INTEGRATION_DB[:items]
   end
 
   specify "should support NULL correctly" do
-    ds = create_items_table_with_column(:number, :integer)
+    ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => nil)
     ds.all.should == [{:number=>nil}]
   end
 
-  specify "should support integer type" do
-    ds = create_items_table_with_column(:number, :integer)
+  specify "should support generic integer type" do
+    ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 2)
     ds.all.should == [{:number=>2}]
   end
+  
+  specify "should support generic fixnum type" do
+    ds = create_items_table_with_column(:number, Fixnum)
+    ds.insert(:number => 2)
+    ds.all.should == [{:number=>2}]
+  end
+  
+  specify "should support generic bignum type" do
+    ds = create_items_table_with_column(:number, Bignum)
+    ds.insert(:number => 2**34)
+    ds.all.should == [{:number=>2**34}]
+  end
+  
+  specify "should support generic float type" do
+    ds = create_items_table_with_column(:number, Float)
+    ds.insert(:number => 2.1)
+    ds.all.should == [{:number=>2.1}]
+  end
+  
+  specify "should support generic numeric type" do
+    ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+    ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
+    ds.insert(:number => BigDecimal.new('2.123456789'))
+    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+  end
 
-  specify "should support varchar type" do
-    ds = create_items_table_with_column(:name, 'varchar(255)'.lit)
+  specify "should support generic string type" do
+    ds = create_items_table_with_column(:name, String)
     ds.insert(:name => 'Test User')
     ds.all.should == [{:name=>'Test User'}]
   end
   
-  specify "should support date type" do
-    ds = create_items_table_with_column(:dat, :date)
+  specify "should support generic date type" do
+    ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
-    x = ds.first[:dat]
-    x = x.iso8601.to_date if Time === x
-    x.to_s.should == d.to_s
+    ds.first[:dat].should == d
   end
   
-  specify "should support time type" do
-    ds = create_items_table_with_column(:tim, :time)
+  specify "should support generic datetime type" do
+    ds = create_items_table_with_column(:tim, DateTime)
+    t = DateTime.now
+    ds.insert(:tim => t)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+    ds = create_items_table_with_column(:tim, Time)
     t = Time.now
     ds.insert(:tim => t)
-    x = ds.first[:tim]
-    [t.strftime('%H:%M:%S'), t.iso8601].should include(x.respond_to?(:strftime) ? x.strftime('%H:%M:%S') : x.to_s)
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+  end
+  
+  specify "should support generic file type" do
+    ds = create_items_table_with_column(:name, File)
+    ds.insert(:name => ("a\0"*300).to_blob)
+    ds.all.should == [{:name=>("a\0"*300).to_blob}]
+  end
+  
+  specify "should support generic boolean type" do
+    ds = create_items_table_with_column(:number, TrueClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
+    ds = create_items_table_with_column(:number, FalseClass)
+    ds.insert(:number => true)
+    ds.all.should == [{:number=>true}]
   end
 end

data/spec/sequel_core/connection_pool_spec.rb

@@ -88,6 +88,20 @@ context "A connection pool handling connections" do
   end
 end
 
+context "A connection pool handling connection errors" do 
+  specify "#hold should raise a Sequel::DatabaseConnectionError if an exception is raised by the connection_proc" do
+    cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS){raise Interrupt}
+    proc{cpool.hold{:block_return}}.should raise_error(Sequel::DatabaseConnectionError)
+    cpool.created_count.should == 0
+  end
+
+  specify "#hold should raise a Sequel::DatabaseConnectionError if nil is returned by the connection_proc" do
+    cpool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS){nil}
+    proc{cpool.hold{:block_return}}.should raise_error(Sequel::DatabaseConnectionError)
+    cpool.created_count.should == 0
+  end
+end
+
 class DummyConnection
   @@value = 0
   def initialize

data/spec/sequel_core/core_sql_spec.rb

@@ -161,7 +161,7 @@ context "#desc" do
   end
 
   specify "should format a DESC clause for a function" do
-    :avg[:test].desc.to_s(@ds).should == 'avg(test) DESC'
+    :avg.sql_function(:test).desc.to_s(@ds).should == 'avg(test) DESC'
   end
 end
 
@@ -177,7 +177,7 @@ context "#asc" do
   end
 
   specify "should format a ASC clause for a function" do
-    :avg[:test].asc.to_s(@ds).should == 'avg(test) ASC'
+    :avg.sql_function(:test).asc.to_s(@ds).should == 'avg(test) ASC'
   end
 end
 
@@ -193,7 +193,7 @@ context "#as" do
   end
 
   specify "should format a AS clause for a function" do
-    :avg[:test].as(:avg).to_s(@ds).should == 'avg(test) AS avg'
+    :avg.sql_function(:test).as(:avg).to_s(@ds).should == 'avg(test) AS avg'
   end
   
   specify "should format a AS clause for a literal value" do
@@ -222,14 +222,14 @@ context "Column references" do
   end
   
   specify "should be quoted properly in SQL functions" do
-    @ds.literal(:avg[:xyz]).should == "avg(`xyz`)"
-    @ds.literal(:avg[:xyz, 1]).should == "avg(`xyz`, 1)"
-    @ds.literal(:avg[:xyz].as(:a)).should == "avg(`xyz`) AS `a`"
+    @ds.literal(:avg.sql_function(:xyz)).should == "avg(`xyz`)"
+    @ds.literal(:avg.sql_function(:xyz, 1)).should == "avg(`xyz`, 1)"
+    @ds.literal(:avg.sql_function(:xyz).as(:a)).should == "avg(`xyz`) AS `a`"
   end
 
   specify "should be quoted properly in ASC/DESC clauses" do
     @ds.literal(:xyz.asc).should == "`xyz` ASC"
-    @ds.literal(:avg[:xyz, 1].desc).should == "avg(`xyz`, 1) DESC"
+    @ds.literal(:avg.sql_function(:xyz, 1).desc).should == "avg(`xyz`, 1) DESC"
   end
   
   specify "should be quoted properly in a cast function" do
@@ -245,6 +245,17 @@ context "Blob" do
   end
 end
 
+if RUBY_VERSION < '1.9.0'
+  context "Symbol#[]" do
+    specify "should format an SQL Function" do
+      ds = Sequel::Dataset.new(nil)
+      ds.literal(:xyz[]).should == 'xyz()'
+      ds.literal(:xyz[1]).should == 'xyz(1)'
+      ds.literal(:xyz[1, 2, :abc[3]]).should == 'xyz(1, 2, abc(3))'
+    end
+  end
+end
+
 context "Symbol#*" do
   setup do
     @ds = Sequel::Dataset.new(nil)
@@ -263,7 +274,6 @@ context "Symbol#*" do
   specify "should support qualified symbols if no argument" do
     :xyz__abc.*.to_s(@ds).should == 'xyz.abc.*'
   end
-
 end
 
 context "Symbol" do
@@ -333,13 +343,13 @@ context "Symbol" do
   end
   
   specify "should support upper case outer functions" do
-    :COUNT['1'].to_s(@ds).should == "COUNT('1')"
+    :COUNT.sql_function('1').to_s(@ds).should == "COUNT('1')"
   end
   
   specify "should inhibit string literalization" do
     db = Sequel::Database.new
     ds = db[:t]
-    ds.select(:COUNT['1']).sql.should == "SELECT COUNT('1') FROM t"
+    ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1') FROM t"
   end
   
   specify "should support cast method and its cast_as alias" do
@@ -471,14 +481,14 @@ end
 
 context "Sequel::SQL::Function#==" do
   specify "should be true for functions with the same name and arguments, false otherwise" do
-    a = :date[:t]
-    b = :date[:t]
+    a = :date.sql_function(:t)
+    b = :date.sql_function(:t)
     a.should == b
     (a == b).should == true
-    c = :date[:c]
+    c = :date.sql_function(:c)
     a.should_not == c
     (a == c).should == false
-    d = :time[:c]
+    d = :time.sql_function(:c)
     a.should_not == d
     c.should_not == d
     (a == d).should == false

data/spec/sequel_core/database_spec.rb

@@ -6,7 +6,8 @@ context "A new Database" do
   end
   teardown do
     Sequel.quote_identifiers = false
-    Sequel.upcase_identifiers = false
+    Sequel.identifier_input_method = nil
+    Sequel.identifier_output_method = nil
   end
   
   specify "should receive options" do
@@ -74,6 +75,48 @@ context "A new Database" do
     db.upcase_identifiers = false
     db.upcase_identifiers?.should == false
   end
+  
+  specify "should respect the :identifier_input_method option" do
+    Sequel.identifier_input_method = nil
+    db = Sequel::Database.new(:identifier_input_method=>nil)
+    db.identifier_input_method.should == nil
+    db.identifier_input_method = :downcase
+    db.identifier_input_method.should == :downcase
+    db = Sequel::Database.new(:identifier_input_method=>:upcase)
+    db.identifier_input_method.should == :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.should == nil
+    Sequel.identifier_input_method = :downcase
+    db = Sequel::Database.new(:identifier_input_method=>nil)
+    db.identifier_input_method.should == nil
+    db.identifier_input_method = :upcase
+    db.identifier_input_method.should == :upcase
+    db = Sequel::Database.new(:identifier_input_method=>:upcase)
+    db.identifier_input_method.should == :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.should == nil
+  end
+  
+  specify "should respect the :identifier_output_method option" do
+    Sequel.identifier_output_method = nil
+    db = Sequel::Database.new(:identifier_output_method=>nil)
+    db.identifier_output_method.should == nil
+    db.identifier_output_method = :downcase
+    db.identifier_output_method.should == :downcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase)
+    db.identifier_output_method.should == :upcase
+    db.identifier_output_method = nil
+    db.identifier_output_method.should == nil
+    Sequel.identifier_output_method = :downcase
+    db = Sequel::Database.new(:identifier_output_method=>nil)
+    db.identifier_output_method.should == nil
+    db.identifier_output_method = :upcase
+    db.identifier_output_method.should == :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase)
+    db.identifier_output_method.should == :upcase
+    db.identifier_output_method = nil
+    db.identifier_output_method.should == nil
+  end
 
   specify "should use the default Sequel.quote_identifiers value" do
     Sequel.quote_identifiers = true
@@ -96,14 +139,56 @@ context "A new Database" do
     Sequel::Database.upcase_identifiers = false
     Sequel::Database.new({}).upcase_identifiers?.should == false
   end
+  
+  specify "should use the default Sequel.identifier_input_method value" do
+    Sequel.identifier_input_method = :downcase
+    Sequel::Database.new({}).identifier_input_method.should == :downcase
+    Sequel.identifier_input_method = :upcase
+    Sequel::Database.new({}).identifier_input_method.should == :upcase
+    Sequel::Database.identifier_input_method = :downcase
+    Sequel::Database.new({}).identifier_input_method.should == :downcase
+    Sequel::Database.identifier_input_method = :upcase
+    Sequel::Database.new({}).identifier_input_method.should == :upcase
+  end
+  
+  specify "should use the default Sequel.identifier_output_method value" do
+    Sequel.identifier_output_method = :downcase
+    Sequel::Database.new({}).identifier_output_method.should == :downcase
+    Sequel.identifier_output_method = :upcase
+    Sequel::Database.new({}).identifier_output_method.should == :upcase
+    Sequel::Database.identifier_output_method = :downcase
+    Sequel::Database.new({}).identifier_output_method.should == :downcase
+    Sequel::Database.identifier_output_method = :upcase
+    Sequel::Database.new({}).identifier_output_method.should == :upcase
+  end
 
-  specify "should respect the upcase_indentifiers_default method if Sequel.upcase_identifiers = nil" do
-    Sequel.upcase_identifiers = nil
-    Sequel::Database.new({}).upcase_identifiers?.should == true
-    x = Class.new(Sequel::Database){def upcase_identifiers_default; false end}
-    x.new({}).upcase_identifiers?.should == false
-    y = Class.new(Sequel::Database){def upcase_identifiers_default; true end}
-    y.new({}).upcase_identifiers?.should == true
+  specify "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
+    Sequel.quote_identifiers = nil
+    Sequel::Database.new({}).quote_identifiers?.should == true
+    x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
+    x.new({}).quote_identifiers?.should == false
+    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
+    y.new({}).quote_identifiers?.should == true
+  end
+  
+  specify "should respect the identifier_input_method_default method" do
+    class Sequel::Database
+      @@identifier_input_method = nil
+    end
+    x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
+    x.new({}).identifier_input_method.should == :downcase
+    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
+    y.new({}).identifier_input_method.should == :camelize
+  end
+  
+  specify "should respect the identifier_output_method_default method if Sequel.upcase_identifiers = nil" do
+    class Sequel::Database
+      @@identifier_output_method = nil
+    end
+    x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
+    x.new({}).identifier_output_method.should == :upcase
+    y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
+    y.new({}).identifier_output_method.should == :underscore
   end
 
   specify "should just use a :uri option for jdbc with the full connection string" do
@@ -180,7 +265,7 @@ context "Database#dataset" do
   end
   
   specify "should provide a filtered #from dataset if a block is given" do
-    d = @db.from(:mau) {:x > 100}
+    d = @db.from(:mau) {:x.sql_number > 100}
     d.should be_a_kind_of(Sequel::Dataset)
     d.sql.should == 'SELECT * FROM mau WHERE (x > 100)'
   end
@@ -869,7 +954,7 @@ context "Database#fetch" do
     ds.select_sql.should == 'select * from xyz'
     ds.sql.should == 'select * from xyz'
     
-    ds.filter!(:price < 100)
+    ds.filter!(:price.sql_number < 100)
     ds.select_sql.should == 'select * from xyz'
     ds.sql.should == 'select * from xyz'
   end
@@ -1008,7 +1093,7 @@ context "Database#get" do
     @db.get(1).should == 1
     @db.sqls.last.should == 'SELECT 1'
     
-    @db.get(:version[])
+    @db.get(:version.sql_function)
     @db.sqls.last.should == 'SELECT version()'
   end
 end