sequel 3.18.0 → 3.19.0

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 3.19.0 (2011-01-03)
+
+* Handle Date and DateTime types in prepared statements when using the jdbc adapter (jeremyevans)
+
+* Handle Date, DateTime, Time, SQL::Blob, true, and false in prepared statements when using the SQLite adapter (jeremyevans)
+
+* Use varbinary(max) instead of image for the generic blob type on MSSQL (jeremyevans)
+
+* Close prepared statements when disconnecting when using SQLite (jeremyevans)
+
+* Allow reflecting on validations in the validation_class_methods plugin (jeremyevans)
+
+* Allow passing a primary key value to the add_* association method (gucki)
+
+* When typecasting model column values, check the classes of the new and existing values (jeremyevans)
+
+* Improve type translation performance in the postgres, mysql, and sqlite adapters by using methods instead of procs (jeremyevans)
+
 === 3.18.0 (2010-12-01)
 
 * Allow the user to control how the connection pool deals with attempts to access shards that aren't configured (jeremyevans)

data/Rakefile

@@ -43,7 +43,7 @@ end
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/**/*.rb doc/*.rdoc doc/release_notes/*.txt"
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb doc/*.rdoc doc/release_notes/*.txt"
 end
 
 ### Website
@@ -59,7 +59,7 @@ task :website_rdoc=>[:website_rdoc_main, :website_rdoc_adapters, :website_rdoc_p
 Rake::RDocTask.new(:website_rdoc_main) do |rdoc|
   rdoc.rdoc_dir = "www/public/rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/*.rb lib/sequel/*.rb lib/sequel/{connection_pool,dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt lib/sequel/extensions/migration.rb"
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/*.rb lib/sequel/*.rb lib/sequel/{connection_pool,dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt lib/sequel/extensions/migration.rb"
 end
 
 Rake::RDocTask.new(:website_rdoc_adapters) do |rdoc|

data/doc/release_notes/3.19.0.txt

@@ -0,0 +1,67 @@
+= New Features
+
+* The add_* association methods now accept a primary key, and
+  associates the receiver to the associated model object with that
+  primary key:
+  
+    artist.add_album(42)
+    # equivalent to: artist.add_album(Album[42])
+
+* The validation_class_methods plugin now has the ability to
+  reflect on validations:
+  
+    Album.plugin :validation_class_methods
+    Album.validates_acceptance_of(:a)
+    Album.validation_reflections
+    # => {:a=>[[:acceptance, {:tag=>:acceptance, :allow_nil=>true,
+                :message=>"is not accepted", :accept=>"1"}]]}
+
+= Other Improvements
+
+* In the postgres, mysql, and sqlite adapters, typecasting now uses
+  methods instead of procs.  Since methods aren't closures (while
+  procs are), this makes typecasting faster (up to 15%).
+
+* When typecasting model column values, the classes of the new and
+  existing values are checked in addition to the values themselves.
+  Previously, if the new and existing values were equal (i.e. 1.0
+  and 1), it wouldn't update the value.  Now, if the classes are
+  different, it always updates the value.
+
+* Date and DateTime objects are now handled correctly when using
+  prepared statements/bound variables in the jdbc adapter.
+  
+* Date, DateTime, Time, true, false, and SQL::Blob objects are now
+  handled correctly when using prepared statements/bound variables
+  in the sqlite adapter.
+
+* Sequel now uses varbinary(max) instead of image for the generic
+  File (blob) type on Microsoft SQL Server.  This makes it possible
+  to use an SQL::Blob object as a prepared statement argument.
+  
+* Sequel now handles blobs better in the Amalgalite adapter.
+
+* When disconnecting a connection using the sqlite adapter, all
+  open prepared statements are now closed first.  Previously,
+  attempting to disconnect a connection with open prepared statements
+  resulted in an error.
+
+* The license file has been renamed from COPYING to MIT-LICENSE, to
+  make it easier to determine at a glance which license is used.
+
+= Backwards Compatibility
+
+* Because Sequel switched the generic File type from image to
+  varbinary(max) on Microsoft SQL Server, any migrations/schema
+  modification methods that used the File type will now result in a
+  different column type than before.
+
+* The MYSQL_TYPE_PROCS, PG_TYPE_PROCS, and SQLITE_TYPE_PROCS
+  constants have been removed from the mysql, postgres, and sqlite
+  adapters, respectively.  The UNIX_EPOCH_TIME_FORMAT and
+  FALSE_VALUES constants have also been removed from the sqlite
+  adapter.
+
+* Typecasting in the sqlite adapters now uses to_i and to_f instead
+  of Integer() and Float() with rescues.  If you put non-numeric
+  data in numeric columns on SQLite, this could cause problems.

data/doc/sharding.rdoc

@@ -112,6 +112,31 @@ the shard to use.  This is fairly easy using a Sequel::Model:
   
   Rainbow.plaintext_for_hash("e580726d31f6e1ad216ffd87279e536d1f74e606")
 
+The connection pool can be further controlled to change how it handles attempts
+to access shards that haven't been configured.  The default is
+to assume the :default shard.  However, you can specify a
+different shard using the :servers_hash option when connecting
+to the database:
+
+  DB = Sequel.connect(..., :servers_hash=>Hash.new(:some_shard))
+
+You can also use this feature to raise an exception if an
+unconfigured shard is used:
+
+  DB = Sequel.connect(..., :servers_hash=>Hash.new{raise ...})
+
+If you specify a :servers_hash option to raise an exception for non configured
+shards you should also explicitly specify a :read_only entry in your :servers option
+for the case where a shard is not specified. In most cases it is sufficient
+to make the :read_only entry the same as the :default shard:
+
+  servers = {:read_only => {}}
+  (('0'..'9').to_a + ('a'..'f').to_a).each do |hex|
+    servers[hex.to_sym] = {:host=>"hash_host_#{hex}"}
+  end
+  DB=Sequel.connect('postgres://hash_host/hashes', :servers=>servers, 
+    :servers_hash=>Hash.new{raise Exception.new("Invalid Server")}) 
+
 === Sharding Plugin
 
 Sequel comes with a sharding plugin that makes it easy to use sharding with model objects.

data/lib/sequel/adapters/amalgalite.rb

@@ -36,7 +36,7 @@ module Sequel
       # type doesn't match a known type, just return the value.
       def result_value_of(declared_type, value)
         if value.is_a?(::Amalgalite::Blob)
-          SQL::Blob.new(value.source)
+          SQL::Blob.new(value.to_s)
         elsif value.is_a?(String) && declared_type
           (meth = self.class.sql_to_method(declared_type.downcase)) ? send(meth, value) : value
         else

data/lib/sequel/adapters/dbi.rb

@@ -88,7 +88,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |s|
           begin
             @columns = s.column_names.map{|c| output_identifier(c)}

data/lib/sequel/adapters/firebird.rb

@@ -201,7 +201,7 @@ module Sequel
 
       # Yield all rows returned by executing the given SQL and converting
       # the types.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |s|
           begin
             @columns = s.fields.map{|c| output_identifier(c.name)}

data/lib/sequel/adapters/informix.rb

@@ -37,7 +37,7 @@ module Sequel
     class Dataset < Sequel::Dataset
       SELECT_CLAUSE_METHODS = clause_methods(:select, %w'limit distinct columns from join where having group compounds order')
 
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |cursor|
           begin
             col_map = nil

data/lib/sequel/adapters/jdbc.rb

@@ -191,7 +191,7 @@ module Sequel
         return execute_prepared_statement(sql, opts, &block) if [Symbol, Dataset].any?{|c| sql.is_a?(c)}
         synchronize(opts[:server]) do |conn|
           statement(conn) do |stmt|
-            if block_given?
+            if block
               yield log_yield(sql){stmt.executeQuery(sql)}
             else
               case opts[:type]
@@ -338,14 +338,25 @@ module Sequel
         JavaxNaming::InitialContext.new.lookup(jndi_name).connection
       end
             
-      # Support fractional seconds for Time objects used in bound variables
-      def java_sql_timestamp(time)
-        millis = time.to_i * 1000
-        ts = java.sql.Timestamp.new(millis)
-        ts.setNanos(time.usec * 1000)
+      # Support Date objects used in bound variables
+      def java_sql_date(date)
+        java.sql.Date.new(Time.local(date.year, date.month, date.day).to_i * 1000)
+      end
+
+      # Support DateTime objects used in bound variables
+      def java_sql_datetime(datetime)
+        ts = java.sql.Timestamp.new(Time.local(datetime.year, datetime.month, datetime.day, datetime.hour, datetime.min, datetime.sec).to_i * 1000)
+        ts.setNanos((datetime.sec_fraction * (RUBY_VERSION >= '1.9.0' ?  1000000000 : 86400000000000)).to_i)
         ts
       end
 
+      # Support fractional seconds for Time objects used in bound variables
+      def java_sql_timestamp(time)
+        ts = java.sql.Timestamp.new(time.to_i * 1000)
+        ts.setNanos(RUBY_VERSION >= '1.9.0' ? time.nsec : time.usec * 1000)
+        ts
+      end 
+      
       # Log the given SQL and then execute it on the connection, used by
       # the transaction code.
       def log_connection_execute(conn, sql)
@@ -389,18 +400,22 @@ module Sequel
           cps.setBytes(i, arg.to_java_bytes)
         when String
           cps.setString(i, arg)
-        when Date, Java::JavaSql::Date
-          cps.setDate(i, arg)
-        when DateTime, Java::JavaSql::Timestamp
-          cps.setTimestamp(i, arg)
-        when Time
-          cps.setTimestamp(i, java_sql_timestamp(arg))
         when Float
           cps.setDouble(i, arg)
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
         when nil
           cps.setNull(i, JavaSQL::Types::NULL)
+        when DateTime
+          cps.setTimestamp(i, java_sql_datetime(arg))
+        when Date
+          cps.setDate(i, java_sql_date(arg))
+        when Time
+          cps.setTimestamp(i, java_sql_timestamp(arg))
+        when Java::JavaSql::Timestamp
+          cps.setTimestamp(i, arg)
+        when Java::JavaSql::Date
+          cps.setDate(i, arg)
         else
           cps.setObject(i, arg)
         end

data/lib/sequel/adapters/mysql.rb

@@ -10,33 +10,58 @@ Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
   module MySQL
-    # Mapping of type numbers to conversion procs
-    MYSQL_TYPES = {}
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s.to_i != 0 end
+      def blob(s) ::Sequel::SQL::Blob.new(s) end
+      def integer(s) s.to_i end
+      def float(s) s.to_f end
+      def decimal(s) ::BigDecimal.new(s) end
+      def date(s) ::Sequel.string_to_date(s) end
+      def time(s) ::Sequel.string_to_time(s) end
+      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
+      def date_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
+      def time_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
+      def timestamp_conv(s) ::Sequel::MySQL.convert_date_time(:database_to_application_timestamp, s) end
+    end.new
 
-    # Use only a single proc for each type to save on memory
-    MYSQL_TYPE_PROCS = {
-      [0, 246]  => lambda{|v| BigDecimal.new(v)},                         # decimal
-      [1]  => lambda{|v| convert_tinyint_to_bool ? v.to_i != 0 : v.to_i}, # tinyint
-      [2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},                  # integer
-      [4, 5]  => lambda{|v| v.to_f},                                      # float
-      [10, 14]  => lambda{|v| convert_date_time(:string_to_date, v)},     # date
-      [7, 12] => lambda{|v| convert_date_time(:database_to_application_timestamp, v)},   # datetime
-      [11]  => lambda{|v| convert_date_time(:string_to_time, v)},         # time
-      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}       # blob
-    }
-    MYSQL_TYPE_PROCS.each do |k,v|
+    # Hash with integer keys and callable values for converting MySQL types.
+    MYSQL_TYPES = {}
+    {
+      [0, 246]  => tt.method(:decimal),
+      [2, 3, 8, 9, 13, 247, 248]  => tt.method(:integer),
+      [4, 5]  => tt.method(:float),
+      [249, 250, 251, 252]  => tt.method(:blob)
+    }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
-    
-    @convert_invalid_date_time = false
+
+    # Modify the type translator used for the tinyint type based
+    # on the value given.
+    def self.convert_tinyint_to_bool=(v)
+      MYSQL_TYPES[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
+      @convert_tinyint_to_bool = v
+    end
+    self.convert_tinyint_to_bool = convert_tinyint_to_bool
 
     class << self
       # By default, Sequel raises an exception if in invalid date or time is used.
       # However, if this is set to nil or :nil, the adapter treats dates
       # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
       # it returns the strings as is.  
-      attr_accessor :convert_invalid_date_time
+      attr_reader :convert_invalid_date_time
+    end
+
+    # Modify the type translators for the date, time, and timestamp types
+    # depending on the value given.
+    def self.convert_invalid_date_time=(v)
+      MYSQL_TYPES[11] = TYPE_TRANSLATOR.method(v == false ? :time : :time_conv)
+      m = TYPE_TRANSLATOR.method(v == false ? :date : :date_conv)
+      [10, 14].each{|i| MYSQL_TYPES[i] = m}
+      m = TYPE_TRANSLATOR.method(v == false ? :timestamp : :timestamp_conv)
+      [7, 12].each{|i| MYSQL_TYPES[i] = m}
+      @convert_invalid_date_time = v
     end
+    self.convert_invalid_date_time = false
 
     # If convert_invalid_date_time is nil, :nil, or :string and
     # the conversion raises an InvalidValue exception, return v

data/lib/sequel/adapters/odbc.rb

@@ -87,7 +87,7 @@ module Sequel
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
       TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
 
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), i+=1]}

data/lib/sequel/adapters/oracle.rb

@@ -102,7 +102,7 @@ module Sequel
     class Dataset < Sequel::Dataset
       include DatasetMethods
 
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |cursor|
           begin
             @columns = cursor.get_col_names.map{|c| output_identifier(c)}

data/lib/sequel/adapters/postgres.rb

@@ -88,32 +88,45 @@ module Sequel
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
     
-    # Hash with integer keys and proc values for converting PostgreSQL types.
-    PG_TYPES = {}
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s == 't' end
+      def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
+      def integer(s) s.to_i end
+      def float(s) s.to_f end
+      def numeric(s) ::BigDecimal.new(s) end
+      def date(s) ::Sequel.string_to_date(s) end
+      def date_iso(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
+      def time(s) ::Sequel.string_to_time(s) end
+      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
+    end.new
 
-    # Use a single proc for each type to conserve memory
-    PG_TYPE_PROCS  = {
-      [16] => lambda{|s| s == 't'}, # boolean
-      [17] => lambda{|s| ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))}, # bytea
-      [20, 21, 22, 23, 26] => lambda{|s| s.to_i}, # integer
-      [700, 701] => lambda{|s| s.to_f}, # float
-      [790, 1700] => lambda{|s| BigDecimal.new(s)}, # numeric
-      [1082] => lambda{|s| @use_iso_date_format ? Date.new(*s.split("-").map{|x| x.to_i}) : Sequel.string_to_date(s)}, # date
-      [1083, 1266] => lambda{|s| Sequel.string_to_time(s)}, # time
-      [1114, 1184] => lambda{|s| Sequel.database_to_application_timestamp(s)}, # timestamp
-    }
-    PG_TYPE_PROCS.each do |k,v|
+    # Hash with integer keys and callable values for converting PostgreSQL types.
+    PG_TYPES = {}
+    {
+      [16] => tt.method(:boolean),
+      [17] => tt.method(:bytea),
+      [20, 21, 22, 23, 26] => tt.method(:integer),
+      [700, 701] => tt.method(:float),
+      [790, 1700] => tt.method(:numeric),
+      [1083, 1266] => tt.method(:time),
+      [1114, 1184] => tt.method(:timestamp)
+    }.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}
     end
     
-    @use_iso_date_format = true
-
     class << self
       # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
       # the date in a known format that Sequel can parse faster.  This can be turned off
       # if you require a date style other than ISO.
-      attr_accessor :use_iso_date_format
+      attr_reader :use_iso_date_format
+    end
+
+    # Modify the type translator for the date type depending on the value given.
+    def self.use_iso_date_format=(v)
+      PG_TYPES[1082] = TYPE_TRANSLATOR.method(v ? :date_iso : :date)
+      @use_iso_date_format = v
     end
+    self.use_iso_date_format = true
     
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.

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

@@ -181,9 +181,9 @@ module Sequel
         :bit
       end
       
-      # MSSQL uses image type for blobs
+      # MSSQL uses varbinary(max) type for blobs
       def type_literal_generic_file(column)
-        :image
+        :'varbinary(max)'
       end
 
       # support for clustered index type

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

@@ -356,7 +356,7 @@ module Sequel
       end
       
       # HAVING requires GROUP BY on SQLite
-      def having(*cond, &block)
+      def having(*cond)
         raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") unless @opts[:group]
         super
       end

data/lib/sequel/adapters/sqlite.rb

@@ -10,27 +10,36 @@ module Sequel
   # Top level module for holding all SQLite-related modules and classes
   # for Sequel.
   module SQLite
-    UNIX_EPOCH_TIME_FORMAT = /\A\d+\z/.freeze
+    TYPE_TRANSLATOR = tt = Class.new do
+      FALSE_VALUES = %w'0 false f no n'.freeze
+      def boolean(s) !FALSE_VALUES.include?(s.downcase) end
+      def blob(s) ::Sequel::SQL::Blob.new(s) end
+      def integer(s) s.to_i end
+      def float(s) s.to_f end
+      def numeric(s) ::BigDecimal.new(s) rescue s end
+      def date(s) ::Sequel.string_to_date(s) end
+      def time(s) ::Sequel.string_to_time(s) end
+      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
+    end.new
+
+    # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
-    FALSE_VALUES = %w'0 false f no n'.freeze
-    SQLITE_TYPE_PROCS = {
-      %w'timestamp datetime' => proc{|v| Sequel.database_to_application_timestamp(v)},
-      %w'date' => proc{|v| Sequel.string_to_date(v)},
-      %w'time' => proc{|v| Sequel.string_to_time(v)},
-      %w'bit bool boolean' => proc{|v| !FALSE_VALUES.include?(v.downcase)},
-      %w'integer smallint mediumint int bigint' => proc{|v| Integer(v) rescue v},
-      %w'numeric decimal money' => proc{|v| BigDecimal.new(v) rescue v},
-      %w'float double real dec fixed' + ['double precision'] => proc{|v| Float(v) rescue v},
-      %w'blob' => proc{|v| ::Sequel::SQL::Blob.new(v)}
-    }
-    SQLITE_TYPE_PROCS.each do |k,v|
+    {
+      %w'timestamp datetime' => tt.method(:timestamp),
+      %w'date' => tt.method(:date),
+      %w'time' => tt.method(:time),
+      %w'bit bool boolean' => tt.method(:boolean),
+      %w'integer smallint mediumint int bigint' => tt.method(:integer),
+      %w'numeric decimal money' => tt.method(:numeric),
+      %w'float double real dec fixed' + ['double precision'] => tt.method(:float),
+      %w'blob' => tt.method(:blob)
+    }.each do |k,v|
       k.each{|n| SQLITE_TYPES[n] = v}
     end
     
     # Database class for SQLite databases used with Sequel and the
     # ruby-sqlite3 driver.
     class Database < Sequel::Database
-      UNIX_EPOCH_TIME_FORMAT = /\A\d+\z/.freeze
       include ::Sequel::SQLite::DatabaseMethods
       
       set_adapter_scheme :sqlite
@@ -138,11 +147,24 @@ module Sequel
         o
       end
       
+      def prepared_statement_argument(arg)
+        case arg
+        when Date, DateTime, Time, TrueClass, FalseClass
+          literal(arg)[1...-1]
+        when SQL::Blob
+          arg.to_blob
+        else
+          arg
+        end
+      end
+
       # Execute a prepared statement on the database using the given name.
       def execute_prepared_statement(conn, type, name, opts, &block)
         ps = prepared_statements[name]
         sql = ps.prepared_sql
         args = opts[:arguments]
+        ps_args = {}
+        args.each{|k, v| ps_args[k] = prepared_statement_argument(v)}
         if cpsa = conn.prepared_statements[name]
           cps, cps_sql = cpsa
           if cps_sql != sql
@@ -155,9 +177,9 @@ module Sequel
           conn.prepared_statements[name] = [cps, sql]
         end
         if block
-          log_yield("Executing prepared statement #{name}", args){cps.execute(args, &block)}
+          log_yield("Executing prepared statement #{name}", args){cps.execute(ps_args, &block)}
         else
-          log_yield("Executing prepared statement #{name}", args){cps.execute!(args){|r|}}
+          log_yield("Executing prepared statement #{name}", args){cps.execute!(ps_args){|r|}}
           case type
           when :insert
             conn.last_insert_row_id
@@ -174,6 +196,7 @@ module Sequel
 
       # Disconnect given connections from the database.
       def disconnect_connection(c)
+        c.prepared_statements.each_value{|v| v.first.close}
         c.close
       end
     end

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

@@ -14,7 +14,7 @@ module Sequel
         
         # Log all SQL that goes through the execute method to the related
         # database object.
-        def execute(sql, *args, &block)
+        def execute(sql, *args)
           @db.log_yield(sql){super}
         rescue SwiftError => e
           @db.send(:raise_error, e)

data/lib/sequel/dataset/actions.rb

@@ -133,11 +133,11 @@ module Sequel
       get(1).nil?
     end
 
-    # Executes a select query and fetches records, passing each record to the
+    # Executes a select query and fetches records, yielding each record to the
     # supplied block.  The yielded records should be hashes with symbol keys.
     # This method should probably should not be called by user code, use +each+
     # instead.
-    def fetch_rows(sql, &block)
+    def fetch_rows(sql)
       raise NotImplemented, NOTIMPL_MSG
     end
     

data/lib/sequel/dataset/query.rb

@@ -418,10 +418,10 @@ module Sequel
         table_name = table_alias || table
       end
 
-      join = if expr.nil? and !block_given?
+      join = if expr.nil? and !block
         SQL::JoinClause.new(type, table, table_alias)
       elsif using_join
-        raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block_given?
+        raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block
         SQL::JoinUsingClause.new(expr, type, table, table_alias)
       else
         last_alias ||= @opts[:last_joined_table] || first_source_alias
@@ -432,7 +432,7 @@ module Sequel
             [k,v]
           end
         end
-        if block_given?
+        if block
           expr2 = yield(table_name, last_alias, @opts[:join] || [])
           expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
         end

data/lib/sequel/model/associations.rb

@@ -1067,6 +1067,8 @@ module Sequel
           klass = opts.associated_class
           if o.is_a?(Hash)
             o = klass.new(o)
+          elsif o.is_a?(Integer) || o.is_a?(String) || o.is_a?(Array)
+            o = klass[o]
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
           end

data/lib/sequel/model/base.rb

@@ -205,7 +205,7 @@ module Sequel
       #   Artist.server!(:server1)
       def def_dataset_method(*args, &block)
         raise(Error, "No arguments given") if args.empty?
-        if block_given?
+        if block
           raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
           meth = args.first
           @dataset_methods[meth] = block
@@ -729,7 +729,7 @@ module Sequel
         # If the column isn't in @values, we can't assume it is
         # NULL in the database, so assume it has changed.
         v = typecast_value(column, value)
-        if new? || !@values.include?(column) || v != @values[column]
+        if new? || !@values.include?(column) || v != (c = @values[column]) || v.class != c.class
           changed_columns << column unless changed_columns.include?(column)
           @values[column] = v
         end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -68,7 +68,7 @@ module Sequel
       # The class_table_inheritance plugin requires the lazy_attributes plugin
       # to handle lazily-loaded attributes for subclass instances returned
       # by superclass methods.
-      def self.apply(model, opts={}, &block)
+      def self.apply(model, opts={})
         model.plugin :lazy_attributes
       end
       
@@ -81,7 +81,7 @@ module Sequel
       # * :table_map - Hash with class name symbol keys and table name symbol
       #   values.  Necessary if the implicit table name for the model class
       #   does not match the database table name
-      def self.configure(model, opts={}, &block)
+      def self.configure(model, opts={})
         model.instance_eval do
           m = method(:constantize)
           @cti_base_model = self

data/lib/sequel/plugins/schema.rb

@@ -20,7 +20,7 @@ module Sequel
       module ClassMethods
         # Creates table, using the column information from set_schema.
         def create_table(*args, &block)
-          set_schema(*args, &block) if block_given?
+          set_schema(*args, &block) if block
           db.create_table(table_name, :generator=>@schema)
           @db_schema = get_db_schema(true)
           columns

data/lib/sequel/plugins/subclasses.rb

@@ -17,7 +17,7 @@ module Sequel
     #   c.descendents   # [sc1, ssc1, sc2]
     module Subclasses
       # Initialize the subclasses instance variable for the model.
-      def self.apply(model, &block)
+      def self.apply(model)
         model.instance_variable_set(:@subclasses, [])
       end
 

data/lib/sequel/plugins/typecast_on_load.rb

@@ -20,7 +20,7 @@ module Sequel
     # the model object, you'll get Date objects instead of strings.
     module TypecastOnLoad
       # Call add_typecast_on_load_columns on the passed column arguments.
-      def self.configure(model, *columns, &block)
+      def self.configure(model, *columns)
         model.instance_eval do
           @typecast_on_load_columns ||= []
           add_typecast_on_load_columns(*columns)

data/lib/sequel/plugins/validation_class_methods.rb

@@ -6,7 +6,9 @@ module Sequel
     # for the legacy class-level validation methods (e.g. validates_presence_of :column).
     #
     # It is recommended to use the validation_helpers plugin instead of this one,
-    # as it is less complex and more flexible.
+    # as it is less complex and more flexible.  However, this plugin provides reflection
+    # support, since it is class-level, while the instance-level validation_helpers
+    # plugin does not.
     # 
     # Usage:
     #
@@ -21,14 +23,21 @@ module Sequel
         model.class_eval do
           @validation_mutex = Mutex.new
           @validations = {}
+          @validation_reflections = {}
         end
       end
 
       module ClassMethods
-        # A hash of associations for this model class.  Keys are column symbols,
+        # A hash of validations for this model class.  Keys are column symbols,
         # values are arrays of validation procs.
         attr_reader :validations
 
+        # A hash of validation reflections for this model class.  Keys are column
+        # symbols, values are an array of two element arrays, with the first element
+        # being the validation type symbol and the second being a hash of validation
+        # options.
+        attr_reader :validation_reflections
+
         # The Generator class is used to generate validation definitions using 
         # the validates {} idiom.
         class Generator
@@ -49,12 +58,16 @@ module Sequel
           !validations.empty?
         end
 
-        # Setup the validations hash in the subclass
+        # Setup the validations and validation_reflections hash in the subclass.
         def inherited(subclass)
           super
+          vr = @validation_reflections
           subclass.class_eval do
             @validation_mutex = Mutex.new
             @validations = {}
+            h = {}
+            vr.each{|k,v| h[k] = v.dup}
+            @validation_reflections = h
           end
         end
     
@@ -115,6 +128,7 @@ module Sequel
             :accept => '1',
             :tag => :acceptance,
           }.merge!(extract_options!(atts))
+          reflect_validation(:acceptance, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             o.errors.add(a, opts[:message]) unless v == opts[:accept]
@@ -136,6 +150,7 @@ module Sequel
             :message => 'is not confirmed',
             :tag => :confirmation,
           }.merge!(extract_options!(atts))
+          reflect_validation(:confirmation, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             o.errors.add(a, opts[:message]) unless v == o.send(:"#{a}_confirmation")
@@ -205,6 +220,7 @@ module Sequel
             raise ArgumentError, "A regular expression must be supplied as the :with option of the options hash"
           end
           
+          reflect_validation(:format, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             o.errors.add(a, opts[:message]) unless v.to_s =~ opts[:with]
@@ -231,6 +247,7 @@ module Sequel
           }.merge!(extract_options!(atts))
           
           opts[:tag] ||= ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
+          reflect_validation(:length, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             if m = opts[:maximum]
@@ -261,6 +278,7 @@ module Sequel
           opts = {
             :tag => :not_string,
           }.merge!(extract_options!(atts))
+          reflect_validation(:not_string, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             if v.is_a?(String)
@@ -286,6 +304,7 @@ module Sequel
             :message => 'is not a number',
             :tag => :numericality,
           }.merge!(extract_options!(atts))
+          reflect_validation(:numericality, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             begin
@@ -310,6 +329,7 @@ module Sequel
             :message => 'is not present',
             :tag => :presence,
           }.merge!(extract_options!(atts))
+          reflect_validation(:presence, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             o.errors.add(a, opts[:message]) if v.blank? && v != false
@@ -327,6 +347,7 @@ module Sequel
             raise ArgumentError, "The :in parameter is required, and respond to include?"
           end
           opts[:message] ||= "is not in range or set: #{opts[:in].inspect}"
+          reflect_validation(:inclusion, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             o.errors.add(a, opts[:message]) unless opts[:in].include?(v)
@@ -355,6 +376,7 @@ module Sequel
             :tag => :uniqueness,
           }.merge!(extract_options!(atts))
     
+          reflect_validation(:uniqueness, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
             error_field = a
@@ -391,6 +413,13 @@ module Sequel
           array.last.is_a?(Hash) ? array.pop : {}
         end
 
+        # Add the validation reflection to the class's validations.
+        def reflect_validation(type, opts, atts)
+          atts.each do |att|
+            (validation_reflections[att] ||= []) << [type, opts]
+          end
+        end
+
         # Handle the :if option for validations
         def validation_if_proc(o, i)
           case i

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 = 18
+  MINOR = 19
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/extensions/validation_class_methods_spec.rb

@@ -9,11 +9,30 @@ describe Sequel::Model do
     end
   end
   
-  specify "should respond to validates, validations, has_validations?" do
+  specify "should respond to validations, has_validations?, and validation_reflections" do
     @c.should respond_to(:validations)
     @c.should respond_to(:has_validations?)
+    @c.should respond_to(:validation_reflections)
   end
   
+  specify "should be able to reflect on validations" do
+    @c.validation_reflections.should == {}
+    @c.validates_acceptance_of(:a)
+    @c.validation_reflections.should == {:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]]}
+    @c.validates_presence_of(:a)
+    @c.validation_reflections[:a].length.should == 2
+    @c.validation_reflections[:a].last.should == [:presence, {:tag=>:presence, :message=>"is not present"}]
+  end
+
+  specify "should handle validation reflections correctly when subclassing" do
+    @c.validates_acceptance_of(:a)
+    c = Class.new(@c)
+    c.validation_reflections.map{|k,v| k}.should == [:a]
+    c.validates_presence_of(:a)
+    @c.validation_reflections.should == {:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]]}
+    c.validation_reflections[:a].last.should == [:presence, {:tag=>:presence, :message=>"is not present"}]
+  end
+
   specify "should acccept validation definitions using validates_each" do
     @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
     o = @c.new

data/spec/integration/associations_test.rb

@@ -196,6 +196,16 @@ describe "Sequel::Model Simple Associations" do
     @album.tags_dataset.first[:name].should == 'T2'
   end
   
+  specify "should have add method accept primary key and add related records" do
+    @artist.remove_all_albums
+    @artist.add_album(@album.id)
+    @artist.albums_dataset.first[:id].should == @album.id
+
+    @album.remove_all_tags
+    @album.add_tag(@tag.id)
+    @album.tags_dataset.first[:id].should == @tag.id
+  end
+  
   specify "should have remove method accept primary key and remove related album" do
     @artist.add_album(@album)
     @artist.reload.remove_album(@album.id)
@@ -287,6 +297,16 @@ describe "Sequel::Model Composite Key Associations" do
     @album.tags_dataset.first[:name].should == 'T2'
   end
   
+  specify "should have add method accept primary key and add related records" do
+    @artist.remove_all_albums
+    @artist.add_album([@album.id1, @album.id2])
+    @artist.albums_dataset.first.pk.should == [@album.id1, @album.id2]
+    
+    @album.remove_all_tags
+    @album.add_tag([@tag.id1, @tag.id2])
+    @album.tags_dataset.first.pk.should == [@tag.id1, @tag.id2]
+  end
+  
   specify "should have remove method accept primary key and remove related album" do
     @artist.add_album(@album)
     @artist.reload.remove_album([@album.id1, @album.id2])

data/spec/integration/database_test.rb

@@ -8,6 +8,12 @@ describe Sequel::Database do
     INTEGRATION_DB.pool.size.should == 0
   end
 
+  specify "should provide disconnect functionality after preparing a connection" do
+    INTEGRATION_DB['SELECT 1'].prepare(:first, :a).call
+    INTEGRATION_DB.disconnect
+    INTEGRATION_DB.pool.size.should == 0
+  end
+
   specify "should raise Sequel::DatabaseError on invalid SQL" do
     proc{INTEGRATION_DB << "SELECT"}.should raise_error(Sequel::DatabaseError)
   end

data/spec/integration/prepared_statement_test.rb

@@ -12,7 +12,6 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.meta_def(:ba) do |sym|
       prepared_arg_placeholder == '$' ? :"#{sym}__int" : sym
     end
-    clear_sqls
   end
   after do
     INTEGRATION_DB.drop_table(:items)
@@ -211,3 +210,61 @@ describe "Prepared Statements and Bound Arguments" do
     end
   end
 end
+
+describe "Bound Argument Types" do
+  before do
+    INTEGRATION_DB.create_table!(:items) do
+      primary_key :id
+      Date :d
+      DateTime :dt
+      File :file
+      String :s
+      Time :t
+      Float :f
+      TrueClass :b
+    end
+    @ds = INTEGRATION_DB[:items]
+    @vs = {:d=>Date.civil(2010, 10, 11), :dt=>DateTime.civil(2010, 10, 12, 13, 14, 15), :f=>1.0, :s=>'str', :t=>Time.at(20101010), :file=>Sequel::SQL::Blob.new('blob'), :b=>true}
+    @ds.insert(@vs)
+    @ds.meta_def(:ba) do |sym, type|
+      prepared_arg_placeholder == '$' ? :"#{sym}__#{type}" : sym
+    end
+  end
+  after do
+    Sequel.datetime_class = Time
+    if INTEGRATION_DB.adapter_scheme == :jdbc && INTEGRATION_DB.database_type == :sqlite
+      INTEGRATION_DB.synchronize{|c| c.prepared_statements.each{|k, ps| ps[1].close}.clear}
+    end
+    INTEGRATION_DB.drop_table(:items)
+  end
+
+  cspecify "should handle date type", [:do, :sqlite], :mssql, [:jdbc, :sqlite] do 
+    @ds.filter(:d=>@ds.ba(:$x, :date)).prepare(:first, :ps_date).call(:x=>@vs[:d])[:d].should == @vs[:d]
+  end
+
+  cspecify "should handle datetime type", [:do], [:mysql2], [:swift], [:jdbc, :sqlite] do
+    Sequel.datetime_class = DateTime
+    @ds.filter(:dt=>@ds.ba(:$x, :timestamp)).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
+  end
+
+  cspecify "should handle time type", [:do], [:jdbc, :sqlite] 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
+    @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
+    @ds.filter(:f=>@ds.ba(:$x, :"double precision")).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].should == @vs[:f]
+  end
+
+  specify "should handle string type" do
+    @ds.filter(:s=>@ds.ba(:$x, :text)).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].should == @vs[:s]
+  end
+
+  cspecify "should handle boolean type", [:do, :sqlite], [:odbc, :mssql], [:jdbc, :sqlite]  do
+    @ds.filter(:b=>@ds.ba(:$x, :boolean)).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].should == @vs[:b]
+  end
+end unless INTEGRATION_DB.adapter_scheme == :swift && INTEGRATION_DB.database_type == :postgres
+

data/spec/integration/schema_test.rb

@@ -9,10 +9,10 @@ describe "Database schema parser" do
     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
+    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
   end
 
   specify "should handle a database with a identifier_output_method" do

data/spec/integration/type_test.rb

@@ -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] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift], [:jdbc, :postgres] 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}]

data/spec/model/associations_spec.rb

@@ -1077,7 +1077,11 @@ describe Sequel::Model, "one_to_many" do
     @c1 = Class.new(Sequel::Model(:attributes)) do
       def _refresh(ds); end
       unrestrict_primary_key
-      columns :id, :node_id, :y
+      columns :id, :node_id, :y, :z
+
+      def self.[](id)
+        load(id.is_a?(Array) ? {:id => id[0], :z => id[1]} : {:id => id})
+      end
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -1228,6 +1232,14 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.first.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
   end
 
+  it "should accept a primary key for the add_ method" do
+    @c2.one_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    MODEL_DB.reset
+    @c1.load(:node_id => 1234, :id => 234).should == n.add_attribute(234)
+    MODEL_DB.sqls.first.should == "UPDATE attributes SET node_id = 1234 WHERE (id = 234)"
+  end
+
   it "should raise an error in the add_ method if the passed associated object is not of the correct type" do
     @c2.one_to_many :attributes, :class => @c1
     proc{@c2.new(:id => 1234).add_attribute(@c2.new)}.should raise_error(Sequel::Error)
@@ -1286,6 +1298,16 @@ describe Sequel::Model, "one_to_many" do
     a.should == n.add_attribute(a)
     MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 2345\)/
   end
+
+  it "should have add_ method accept a composite key" do
+    @c1.set_primary_key :id, :z
+    @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
+    
+    n = @c2.load(:id => 1234, :x=>5)
+    a = @c1.load(:id => 2345, :z => 8, :node_id => 1234, :y=>5)
+    a.should == n.add_attribute([2345, 8])
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = (1234|5), (node_id|y) = (1234|5) WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\)/
+  end
   
   it "should have remove_ method respect composite keys" do
     @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
@@ -1834,9 +1856,12 @@ describe Sequel::Model, "many_to_many" do
       def self.to_s; 'Attribute'; end
       columns :id, :y
       def _refresh(ds)
-        self.id = 1
         self
       end
+      
+      def self.[](id)
+        load(id.is_a?(Array) ? {:id => id[0], :y => id[1]} : {:id => id})
+      end
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -2063,6 +2088,17 @@ describe Sequel::Model, "many_to_many" do
     ].should(include(MODEL_DB.sqls.first))
   end
 
+  it "should define an add_ method that works with a primary key" do
+    @c2.many_to_many :attributes, :class => @c1
+    
+    n = @c2.load(:id => 1234)
+    a = @c1.load(:id => 2345)
+    a.should == n.add_attribute(2345)
+    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
+     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'
+    ].should(include(MODEL_DB.sqls.first))
+  end
+
   it "should allow passing a hash to the add_ method which creates a new record" do
     @c2.many_to_many :attributes, :class => @c1
     
@@ -2148,6 +2184,14 @@ describe Sequel::Model, "many_to_many" do
       v.should == true
     end
   end
+  
+  it "should have the add_ method respect composite keys" do
+    @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
+    n = @c2.load(:id => 1234, :x=>5)
+    a = @c1.load(:id => 2345, :y=>8)
+    a.should == n.add_attribute([2345, 8])
+    MODEL_DB.sqls.first.should =~ /INSERT INTO attributes_nodes \([lr][12], [lr][12], [lr][12], [lr][12]\) VALUES \((1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8)\)/
+  end
 
   it "should have the remove_ method respect the :left_primary_key and :right_primary_key options" do
     @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx, :right_primary_key=>:yyy

data/spec/model/model_spec.rb

@@ -452,6 +452,17 @@ describe Sequel::Model, "attribute accessors" do
     o.x = '34'
     o.x.should == 34
   end
+
+  it "should typecast if the new value is the same as the existing but has a different class" do
+    @c.set_dataset(@dataset.select(:y))
+    o = @c.new
+
+    o.x = 34
+    o.x = 34.0
+    o.x.should == 34.0
+    o.x = 34
+    o.x.should == 34
+  end
 end
 
 describe Sequel::Model, ".[]" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  hash: 79
+  hash: 75
   prerelease: false
   segments: 
   - 3
-  - 18
+  - 19
   - 0
-  version: 3.18.0
+  version: 3.19.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-01 00:00:00 -08:00
+date: 2011-01-03 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -28,7 +28,7 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 - CHANGELOG
-- COPYING
+- MIT-LICENSE
 - doc/advanced_associations.rdoc
 - doc/cheat_sheet.rdoc
 - doc/dataset_filtering.rdoc
@@ -82,8 +82,9 @@ extra_rdoc_files:
 - doc/release_notes/3.16.0.txt
 - doc/release_notes/3.17.0.txt
 - doc/release_notes/3.18.0.txt
+- doc/release_notes/3.19.0.txt
 files: 
-- COPYING
+- MIT-LICENSE
 - CHANGELOG
 - README.rdoc
 - Rakefile
@@ -131,6 +132,7 @@ files:
 - doc/release_notes/3.16.0.txt
 - doc/release_notes/3.17.0.txt
 - doc/release_notes/3.18.0.txt
+- doc/release_notes/3.19.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc