sequel 3.19.0 → 3.20.0

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 3.20.0 (2011-02-01)
+
+* Allow a :partial option to Database#indexes on MySQL to include partial indexes (roland.swingler) (#324)
+
+* Add a SQLite subadapter to the swift adapter, now that swift supports it (jeremyevans)
+
+* Update swift adapter to support swift 0.8.1, older versions no longer supported (jeremyevans)
+
+* Allow setting arbitrary JDBC properties in the jdbc adapter with the :jdbc_properties option (jeremyevans)
+
+* Use a better error message if a validates_max_length validation is applied to a nil value (jeremyevans) (#322)
+
+* Add some basic Microsoft Access support to the ado adapter, autoincrementing primary keys now work (jeremyevans)
+
+* Make class_table_inheritance plugin handle subclass associations better (jeremyevans) (#320)
+
 === 3.19.0 (2011-01-03)
 
 * Handle Date and DateTime types in prepared statements when using the jdbc adapter (jeremyevans)

data/doc/opening_databases.rdoc

@@ -113,6 +113,18 @@ many things will be broken.  The SQLNCLI10 provider appears to work well if you
 are connecting to Microsoft SQL Server, but it is not the default as that would
 break backwards compatability.
 
+Example connections:
+
+  # SQL Server
+  Sequel.connect('ado:///sequel_test?host=server%5cdb_instance')
+  Sequel.connect('ado://user:password@server/database?host=server%5cdb_instance&provider=SQLNCLI10')
+  # Access 2007
+  Sequel.ado(:conn_string=>'Provider=Microsoft.ACE.OLEDB.12.0;Data Source=drive:\\path\\filename.accdb')
+  # Access 2000
+  Sequel.ado(:conn_string=>'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=drive:\\path\\filename.mdb')
+  # Excel 2000 (for table names, use a dollar after the sheet name, e.g. Sheet1$)
+  Sequel.ado(:conn_string=>'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=drive:\\path\\filename.xls;Extended Properties=Excel 8.0;')
+
 === amalgalite 
 
 Amalgalite is an ruby extension that provides self contained access to SQLite,
@@ -254,6 +266,8 @@ The following additional options are supported:
 * :encoding - Specify the encoding/character set to use for the connection.
 * :socket - Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
 * :timeout - Sets the wait_timeout for the connection, defaults to 1 month.
+* :read_timeout - Set the timeout in seconds for reading back results to a query.
+* :connect_timeout - Set the timeout in seconds before a connection attempt is abandoned.
 
 === odbc 
 

data/doc/release_notes/3.20.0.txt

@@ -0,0 +1,41 @@
+= New Features
+
+* The swift adapter now supports an SQLite subadapter.  Use the
+  :db_type => 'sqlite' option when connecting.  You can use an
+  in memory database with the following connection string:
+  
+    swift:///?database=:memory:&db_type=sqlite
+
+* Arbitrary JDBC properties can now be set in the JDBC adapter
+  using the :jdbc_properties option when connecting.  The value
+  of this option should be a hash where keys and values are JDBC
+  property keys and values.
+  
+* Basic Microsoft Access support was added to the ado adapter.
+  The creation of autoincrementing primary key integers now works,
+  and identifiers are now quoted with [].
+
+* The Database#indexes method now supports a :partial option when
+  connecting to MySQL, which makes it include partial indexes (which
+  are usually excluded).
+
+= Other Improvements
+
+* The class_table_inheritance plugin now handles subclass
+  associations better.  Previously, the implicit eager loading code
+  had issues when you called an association method that only existed
+  in the subclass.
+
+* The error message used when a validates_max_length validation is
+  applied to a nil column value has been improved.  You can override
+  the message yourself using the :nil_message option.
+  
+* The read_timeout and connect_timeout options now work correctly in
+  the mysql adapter.
+
+* Another MySQL disconnect error message is now recognized.
+
+= Backwards Compatibility
+
+* The swift adapter was upgraded to support swift 0.8.1.  Older
+  versions of swift are no longer supported.

data/lib/sequel/adapters/ado.rb

@@ -8,11 +8,17 @@ module Sequel
 
       def initialize(opts)
         super
-        @opts[:driver] ||= 'SQL Server'
-        case @opts[:driver]
-        when 'SQL Server'
-          Sequel.ts_require 'adapters/ado/mssql'
-          extend Sequel::ADO::MSSQL::DatabaseMethods
+        case @opts[:conn_string]
+        when /Microsoft\.(Jet|ACE)\.OLEDB/io
+          Sequel.ts_require 'adapters/shared/access'
+          extend Sequel::Access::DatabaseMethods
+        when nil
+          @opts[:driver] ||= 'SQL Server'
+          case @opts[:driver]
+          when 'SQL Server'
+            Sequel.ts_require 'adapters/ado/mssql'
+            extend Sequel::ADO::MSSQL::DatabaseMethods
+          end
         end
       end
 

data/lib/sequel/adapters/jdbc.rb

@@ -168,6 +168,7 @@ module Sequel
               props.setProperty("user", opts[:user])
               props.setProperty("password", opts[:password])
             end
+            opts[:jdbc_properties].each{|k,v| props.setProperty(k.to_s, v)} if opts[:jdbc_properties]
             begin
               driver.new.connect(args[0], props)
             rescue => e2

data/lib/sequel/adapters/mysql.rb

@@ -86,7 +86,7 @@ module Sequel
       include Sequel::MySQL::DatabaseMethods
       
       # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|Lost connection to MySQL server during query)/
       
       set_adapter_scheme :mysql
       
@@ -128,10 +128,10 @@ module Sequel
           # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
           conn.options(Mysql::SET_CHARSET_NAME, encoding)
         end
-        if read_timeout = opts[:read_timeout] and Mysql::const_defined(Mysql::OPT_READ_TIMEOUT)
+        if read_timeout = opts[:read_timeout] and defined? Mysql::OPT_READ_TIMEOUT
           conn.options(Mysql::OPT_READ_TIMEOUT, read_timeout)
         end
-        if connect_timeout = opts[:connect_timeout] and Mysql::const_defined(Mysql::OPT_CONNECT_TIMEOUT)
+        if connect_timeout = opts[:connect_timeout] and defined? Mysql::OPT_CONNECT_TIMEOUT
           conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
         end
         conn.real_connect(

data/lib/sequel/adapters/shared/access.rb

@@ -0,0 +1,52 @@
+module Sequel
+  module Access
+    module DatabaseMethods
+      def database_type
+        :access
+      end
+
+      def dataset(opts = nil)
+        ds = super
+        ds.extend(DatasetMethods)
+        ds
+      end
+
+      # Doesn't work, due to security restrictions on MSysObjects
+      def tables
+        from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      end
+
+      def serial_primary_key_options
+        {:primary_key => true, :type=>:Counter}
+      end
+
+      private
+
+      def identifier_input_method_default
+        nil
+      end
+      
+      def identifier_output_method_default
+        nil
+      end
+    end
+  
+    module DatasetMethods
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+
+      def supports_intersect_except?
+        false
+      end
+
+      private
+
+      def quoted_identifier(v)
+        "[#{v}]"
+      end
+
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+    end
+  end
+end

data/lib/sequel/adapters/shared/mysql.rb

@@ -49,7 +49,11 @@ module Sequel
         :mysql
       end
 
-      # Use SHOW INDEX FROM to get the index information for the table.
+      # Use SHOW INDEX FROM to get the index information for the
+      # table.
+      #
+      # By default partial indexes are not included, you can use the
+      # option :partial to override this.
       def indexes(table, opts={})
         indexes = {}
         remove_indexes = []
@@ -59,7 +63,7 @@ module Sequel
           name = r[:Key_name]
           next if name == PRIMARY
           name = m.call(name)
-          remove_indexes << name if r[:Sub_part]
+          remove_indexes << name if r[:Sub_part] && ! opts[:partial]
           i = indexes[name] ||= {:columns=>[], :unique=>r[:Non_unique] != 1}
           i[:columns] << m.call(r[:Column_name])
         end

data/lib/sequel/adapters/swift.rb

@@ -22,6 +22,11 @@ module Sequel
         db.extend(Sequel::Swift::MySQL::DatabaseMethods)
         db.swift_class = ::Swift::DB::Mysql
       end,
+      :sqlite=>proc do |db|
+        Sequel.ts_require 'adapters/swift/sqlite'
+        db.extend(Sequel::Swift::SQLite::DatabaseMethods)
+        db.swift_class = ::Swift::DB::Sqlite3
+      end,
     }
       
     class Database < Sequel::Database
@@ -45,7 +50,7 @@ module Sequel
             raise(Error, "No :db_type option specified")
           end
         else
-          raise(Error, ":db_type option not valid, should be postgres or mysql")
+          raise(Error, ":db_type option not valid, should be postgres, mysql, or sqlite")
         end
       end
       
@@ -63,14 +68,11 @@ module Sequel
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            res = nil
-            log_yield(sql){conn.execute(sql); res = conn.results}
+            res = log_yield(sql){conn.execute(sql)}
             yield res if block_given?
             nil
           rescue SwiftError => e
             raise_error(e)
-          ensure
-            res.finish if res
           end
         end
       end
@@ -80,7 +82,7 @@ module Sequel
       def execute_dui(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.execute(sql)}
+            log_yield(sql){conn.execute(sql).rows}
           rescue SwiftError => e
             raise_error(e)
           end
@@ -92,12 +94,9 @@ module Sequel
       def execute_insert(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            res = nil
-            log_yield(sql){conn.execute(sql); (res = conn.results).insert_id}
+            log_yield(sql){conn.execute(sql).insert_id}
           rescue SwiftError => e
             raise_error(e)
-          ensure
-            res.finish if res
           end
         end
       end

data/lib/sequel/adapters/swift/postgres.rb

@@ -50,13 +50,11 @@ module Sequel
         def execute(sql, opts={})
           synchronize(opts[:server]) do |conn|
             begin
-              conn.execute(sql)
-              res = conn.results
+              res = conn.execute(sql)
               yield res if block_given?
+              nil
             rescue SwiftError => e
               raise_error(e)
-            ensure
-              res.finish if res
             end
           end
         end
@@ -66,7 +64,7 @@ module Sequel
         def execute_dui(sql, opts={})
           synchronize(opts[:server]) do |conn|
             begin
-              conn.execute(sql)
+              conn.execute(sql).rows
             rescue SwiftError => e
               raise_error(e)
             end

data/lib/sequel/adapters/swift/sqlite.rb

@@ -0,0 +1,31 @@
+Sequel.require 'adapters/shared/sqlite'
+
+module Sequel
+  module Swift
+    # Database and Dataset instance methods for SQLite specific
+    # support via Swift.
+    module SQLite
+      # Database instance methods for SQLite databases accessed via Swift.
+      module DatabaseMethods
+        include Sequel::SQLite::DatabaseMethods
+        
+        # Return instance of Sequel::Swift::SQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::Swift::SQLite::Dataset.new(self, opts)
+        end
+      end
+      
+      # Dataset class for SQLite datasets accessed via Swift.
+      class Dataset < Swift::Dataset
+        include Sequel::SQLite::DatasetMethods
+        
+        private
+        
+        # Use Swift's escape method for quoting.
+        def literal_string(s)
+          db.synchronize{|c| "#{c.escape(s)}"}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/model/associations.rb

@@ -1473,7 +1473,7 @@ module Sequel
       
         # Make sure the association is valid for this model, and return the related AssociationReflection.
         def check_association(model, association)
-          raise(Sequel::Error, "Invalid association #{association} for #{model.name}") unless reflection = model.association_reflection(association)
+          raise(Sequel::UndefinedAssociation, "Invalid association #{association} for #{model.name}") unless reflection = model.association_reflection(association)
           raise(Sequel::Error, "Eager loading is not allowed for #{model.name} association #{association}") if reflection[:allow_eager] == false
           reflection
         end
@@ -1538,7 +1538,7 @@ module Sequel
           #  specific foreign/primary key
           key_hash = {}
           # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc)}
+          reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate keys to monitor
           reflections.each{|reflection| key_hash[reflection.eager_loader_key] ||= Hash.new{|h,k| h[k] = []}}

data/lib/sequel/model/exceptions.rb

@@ -6,6 +6,9 @@ module Sequel
   # modify a single row.
   class NoExistingObject < Error; end
   
+  # Raised when an undefined association is used when eager loading.
+  class UndefinedAssociation < Error; end
+  
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error
     def initialize(errors)

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -44,7 +44,14 @@ module Sequel
         def load_associated_objects(opts, reload=false)
           name = opts[:name]
           if !associations.include?(name) && retrieved_by
-            retrieved_by.send(:eager_load, retrieved_with, name=>{})
+            begin
+              retrieved_by.send(:eager_load, retrieved_with, name=>{})
+            rescue Sequel::UndefinedAssociation
+              # This can happen if class table inheritance is used and the association
+              # is only defined in a subclass.  This particular instance can use the
+              # association, but it can't be eagerly loaded as the parent class doesn't
+              # have access to the association, and that's the class doing the eager loading.
+            end
           end
           super
         end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -232,15 +232,17 @@ module Sequel
         # Possible Options:
         # * :is - The exact size required for the value to be valid (no default)
         # * :maximum - The maximum size allowed for the value (no default)
-        # * :message - The message to use (no default, overrides :too_long, :too_short, and :wrong_length
+        # * :message - The message to use (no default, overrides :nil_message, :too_long, :too_short, and :wrong_length
         #   options if present)
         # * :minimum - The minimum size allowed for the value (no default)
+        # * :nil_message - The message to use use if :maximum option is used and the value is nil (default: 'is not present')
         # * :too_long - The message to use use if it the value is too long (default: 'is too long')
         # * :too_short - The message to use use if it the value is too short (default: 'is too short')
         # * :within - The array/range that must include the size of the value for it to be valid (no default)
         # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
         def validates_length_of(*atts)
           opts = {
+            :nil_message  => 'is not present',
             :too_long     => 'is too long',
             :too_short    => 'is too short',
             :wrong_length => 'is the wrong length'
@@ -251,7 +253,7 @@ module Sequel
           atts << opts
           validates_each(*atts) do |o, a, v|
             if m = opts[:maximum]
-              o.errors.add(a, opts[:message] || opts[:too_long]) unless v && v.size <= m
+              o.errors.add(a, opts[:message] || (v ? opts[:too_long] : opts[:nil_message])) unless v && v.size <= m
             end
             if m = opts[:minimum]
               o.errors.add(a, opts[:message] || opts[:too_short]) unless v && v.size >= m

data/lib/sequel/plugins/validation_helpers.rb

@@ -50,7 +50,7 @@ module Sequel
         :includes=>{:message=>lambda{|set| "is not in range or set: #{set.inspect}"}},
         :integer=>{:message=>lambda{"is not a number"}},
         :length_range=>{:message=>lambda{|range| "is too short or too long"}},
-        :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}},
+        :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}, :nil_message=>lambda{"is not present"}},
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
         :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
         :numeric=>{:message=>lambda{"is not a number"}},
@@ -93,8 +93,11 @@ module Sequel
         end
     
         # Check that the attribute values are not longer than the given max length.
+        #
+        # Accepts a :nil_message option that is the error message to use when the
+        # value is nil instead of being too long.
         def validates_max_length(max, atts, opts={})
-          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| validation_error_message(m, max) unless v && v.length <= max}
+          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) unless v && v.length <= max}
         end
 
         # Check that the attribute values are not shorter than the given min length.

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 19
+  MINOR = 20
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -565,6 +565,18 @@ if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and MYSQL_DB.adapter_sch
   end
 end
 
+context "A MySQL database" do
+  specify "should accept a read_timeout option when connecting" do
+    db = Sequel.connect(MYSQL_DB.opts.merge(:read_timeout=>22342))
+    proc {db.test_connection}.should_not raise_error
+  end
+
+  specify "should accept a connect_timeout option when connecting" do
+    db = Sequel.connect(MYSQL_DB.opts.merge(:connect_timeout=>22342))
+    proc {db.test_connection}.should_not raise_error
+  end
+end
+
 context "A grouped MySQL dataset" do
   before do
     MYSQL_DB[:test2].delete
@@ -648,6 +660,12 @@ context "A MySQL database" do
     @db << "CREATE INDEX posts_id_index ON posts (id(10))"
     @db.indexes(:posts).should == {}
   end
+
+  specify "should dump partial indexes if :partial option is set to true" do
+    @db.create_table(:posts){text :id}
+    @db << "CREATE INDEX posts_id_index ON posts (id(10))"
+    @db.indexes(:posts, :partial => true).should == {:posts_id_index => {:columns => [:id], :unique => false}}
+  end
 end
 
 context "MySQL::Dataset#insert and related methods" do

data/spec/adapters/sqlite_spec.rb

@@ -98,7 +98,7 @@ context "An SQLite database" do
     proc {@db.temp_store = :invalid}.should raise_error(Sequel::Error)
   end
   
-  cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite do
+  cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite, :swift do
     @db.create_table!(:time){timestamp :t; datetime :d}
     t1 = Time.at(1)
     @db[:time] << {:t => t1, :d => t1}

data/spec/core/connection_pool_spec.rb

@@ -168,7 +168,7 @@ context "A connection pool with a max size of 1" do
     cc,c1, c2 = nil
     
     t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.01;end}}
-    sleep 0.02
+    sleep 0.03
     cc.should == 'herro'
     c1.should == 'herro'
     

data/spec/extensions/validation_class_methods_spec.rb

@@ -341,6 +341,20 @@ describe Sequel::Model do
     @m.should be_valid
     @m.value = '123456'
     @m.should_not be_valid
+    @m.errors[:value].should == ['is too long']
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors[:value].should == ['is not present']
+  end
+
+  specify "should validate length_of with maximum using customized error messages" do
+    @c.validates_length_of :value, :maximum => 5, :too_long=>'tl', :nil_message=>'np'
+    @m.value = '123456'
+    @m.should_not be_valid
+    @m.errors[:value].should == ['tl']
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors[:value].should == ['np']
   end
 
   specify "should validate length_of with minimum" do

data/spec/extensions/validation_helpers_spec.rb

@@ -210,6 +210,20 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.should be_valid
     @m.value = '123456'
     @m.should_not be_valid
+    @m.errors[:value].should == ['is longer than 5 characters']
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors[:value].should == ['is not present']
+  end
+
+  specify "should support validates_max_length with nil value" do
+    @c.set_validations{validates_max_length(5, :value, :message=>'tl', :nil_message=>'np')}
+    @m.value = '123456'
+    @m.should_not be_valid
+    @m.errors[:value].should == ['tl']
+    @m.value = nil
+    @m.should_not be_valid
+    @m.errors[:value].should == ['np']
   end
 
   specify "should support validates_min_length" do

data/spec/integration/plugin_test.rb

@@ -90,6 +90,10 @@ describe "Class Table Inheritance Plugin" do
     @db[:employees][:id=>i].should == nil
   end
   
+  specify "should handle associations only defined in subclasses" do
+    Employee.filter(:id=>@i2).all.first.manager.id.should == @i4
+  end
+
   # See http://www.sqlite.org/src/tktview/3338b3fa19ac4abee6c475126a2e6d9d61f26ab1
   cspecify "should insert rows into all tables", :sqlite do
     e = Executive.create(:name=>'Ex2', :num_managers=>8, :num_staff=>9)

data/spec/integration/prepared_statement_test.rb

@@ -251,11 +251,11 @@ describe "Bound Argument Types" do
     @ds.filter(:t=>@ds.ba(:$x, :timestamp)).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end
 
-  cspecify "should handle blob type", [:swift], [:jdbc, :postgres] do
+  cspecify "should handle blob type", [:swift] do
     @ds.filter(:file=>@ds.ba(:$x, :bytea)).prepare(:first, :ps_blob).call(:x=>@vs[:file])[:file].should == @vs[:file]
   end
 
-  specify "should handle float type" do
+  cspecify "should handle float type", [:swift, :sqlite] do
     @ds.filter(:f=>@ds.ba(:$x, :"double precision")).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].should == @vs[:f]
   end
 

data/spec/integration/type_test.rb

@@ -39,13 +39,13 @@ describe "Supported types" do
     ds.all.should == [{:number=>2**34}]
   end
   
-  specify "should support generic float type" do
+  cspecify "should support generic float type", [:swift, :sqlite] do
     ds = create_items_table_with_column(:number, Float)
     ds.insert(:number => 2.1)
     ds.all.should == [{:number=>2.1}]
   end
   
-  cspecify "should support generic numeric type", [:odbc, :mssql] do
+  cspecify "should support generic numeric type", [:odbc, :mssql], [:swift, :sqlite] 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')}]
@@ -79,7 +79,7 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift], [:jdbc, :postgres] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name => ("a\0"*300).to_sequel_blob)
     ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  hash: 75
+  hash: 87
   prerelease: false
   segments: 
   - 3
-  - 19
+  - 20
   - 0
-  version: 3.19.0
+  version: 3.20.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-03 00:00:00 -08:00
+date: 2011-02-01 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -83,6 +83,7 @@ extra_rdoc_files:
 - doc/release_notes/3.17.0.txt
 - doc/release_notes/3.18.0.txt
 - doc/release_notes/3.19.0.txt
+- doc/release_notes/3.20.0.txt
 files: 
 - MIT-LICENSE
 - CHANGELOG
@@ -133,6 +134,7 @@ files:
 - doc/release_notes/3.17.0.txt
 - doc/release_notes/3.18.0.txt
 - doc/release_notes/3.19.0.txt
+- doc/release_notes/3.20.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc
@@ -311,12 +313,14 @@ files:
 - lib/sequel/adapters/shared/postgres.rb
 - lib/sequel/adapters/shared/progress.rb
 - lib/sequel/adapters/shared/sqlite.rb
+- lib/sequel/adapters/shared/access.rb
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/utils/stored_procedures.rb
 - lib/sequel/adapters/mysql2.rb
 - lib/sequel/adapters/swift.rb
 - lib/sequel/adapters/swift/mysql.rb
 - lib/sequel/adapters/swift/postgres.rb
+- lib/sequel/adapters/swift/sqlite.rb
 - lib/sequel/connection_pool.rb
 - lib/sequel/connection_pool/sharded_single.rb
 - lib/sequel/connection_pool/sharded_threaded.rb