sequel 4.29.0 → 4.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1baf17a3ed5aedeadf0002e4e68ac8e2e27bdc2
-  data.tar.gz: 9ceec8f5898df4025b6cf5239f461dee5595ebeb
+  metadata.gz: fe7b61c71980b22f3aa98f3815a5852d11e0880d
+  data.tar.gz: f7b80005c8ad61d472e8f011e3532eb72c40f74b
 SHA512:
-  metadata.gz: a2c9116e35e8ff8a536530cff484f2d82fac1916db18d8d4b4666359c6ce1f6a67aeb855feb173128f874a179bc75ef10a22bd326ecf48ad6c3cfbe6f3f3b8d3
-  data.tar.gz: 07d8ee3fb38aeae9caa9344756826a7e43fa19bd5786948525b427e9d64c3714ee06d452299b310bb7d30666e16ee0af64f663de7bb9a3dbd3b2fd0f2c5255dd
+  metadata.gz: fe4a59d1e06d7f5267ff9f1201b052b06717e24b8d86b99db3cdfc0187b9056cf7bee88fae1da62a15215046c6babbce17aa97382269354941f6822eba4ba87e
+  data.tar.gz: 0750aa6e4143b4a074630060cef6033852930be6ab448f6d5a330b502f92bb7cbe86c26dd4d69c10356524c4a02a299becec6982077c5260f7bba329b81bd54d

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 4.30.0 (2016-01-04)
+
+* Add Dataset#insert_conflict and #insert_ignore on SQLite for handling uniqueness violations (Sharpie) (#1121)
+
+* Make Database#row_type in pg_row extension handle different formats of schema-qualified types (jeremyevans) (#1119)
+
+* Add identifier_columns plugin for handling column names containing 2 or more consecutive underscores when saving (jeremyevans) (#1117)
+
+* Support :eager_limit and :eager_limit_strategy dataset options in model eager loaders for per-call limits and strategies (chanks) (#1115)
+
+* Allow IPv6 addresses in database URLs on ruby 1.9+ (hellvinz, jeremyevans) (#1113)
+
+* Make Database#schema :db_type entries include sizes for string types on DB2 (jeremyevans)
+
+* Make Database#schema :db_type entries include sizes for string and decimal types in the jdbc adapter's schema parsing (jeremyevans)
+
+* Recognize another disconnect error in the tinytds adapter (jeremyevans)
+
 === 4.29.0 (2015-12-01)
 
 * Add Model#json_serializer_opts method to json_serializer plugin, allowing for setting to_json defaults on per-instance basis (jeremyevans)

data/doc/advanced_associations.rdoc

@@ -287,9 +287,9 @@ the window function strategy:
     :eager_limit_strategy=>:window_function
   Artist.where(:id=>[1,2]).eager(:first_10_albums).all
   # SELECT * FROM (
-  #   SELECT *, row_number() OVER (PARTITION BY tracks.album_id ORDER BY release_date) AS x_sequel_row_number_x
-  #   FROM tracks
-  #   WHERE (tracks.album_id IN (1, 2))
+  #   SELECT *, row_number() OVER (PARTITION BY albums.artist_id ORDER BY release_date) AS x_sequel_row_number_x
+  #   FROM albums
+  #   WHERE (albums.artist_id IN (1, 2))
   # ) AS t1
   # WHERE (x_sequel_row_number_x <= 10)
   
@@ -297,6 +297,29 @@ Alternatively, you can use the :ruby strategy, which will fall back to
 retrieving all records, and then will slice the resulting array to get
 the first 10 after retrieval.
 
+=== Dynamic Eager Loading Limits
+
+If you need to eager load variable numbers of records (with limits that aren't
+known at the time of the association definition), Sequel supports an
+:eager_limit dataset option that can be defined in an eager loading callback:
+
+  Artist.one_to_many :albums
+  Artist.where(:id => [1, 2]).eager(:albums => proc{|ds| ds.order(:release_date).clone(:eager_limit => 3)}).all
+  # SELECT * FROM (
+  #   SELECT *, row_number() OVER (PARTITION BY albums.artist_id ORDER BY release_date) AS x_sequel_row_number_x
+  #   FROM albums
+  #   WHERE (albums.artist_id IN (1, 2))
+  # ) AS t1
+  # WHERE (x_sequel_row_number_x <= 3)
+
+You can also customize the :eager_limit_strategy on a case-by-case basis by passing in that option in the same way:
+
+  Artist.where(:id => [1, 2]).eager(:albums => proc{|ds| ds.order(:release_date).clone(:eager_limit => 3, :eager_limit_strategy => :ruby)}).all
+  # SELECT * FROM albums WHERE (albums.artist_id IN (1, 2)) ORDER BY release_date
+
+The :eager_limit and :eager_limit_strategy options currently only work when
+eager loading via #eager, not with #eager_graph.
+
 === Eager Loading via eager_graph_with_options
 
 When eager loading an association via eager_graph (which uses JOINs), the

data/doc/release_notes/4.30.0.txt

@@ -0,0 +1,37 @@
+= New Features
+
+* Overriding the :limit and :eager_limit_strategy association options
+  can now be done on a per-call basis when eager loading, by using an
+  eager block callback and setting the :eager_limit or
+  :eager_limit_strategy dataset options. Example:
+
+    Album.eager(:tracks=>proc{|ds| ds.clone(:eager_limit=>5)}).all
+
+* Dataset#insert_conflict and #insert_ignore have been added on
+  SQLite, adding support for the INSERT OR ... SQL syntax:
+
+    DB[:table].insert_ignore.insert(:a=>1, :b=>2)
+    # INSERT OR IGNORE INTO TABLE (a, b) VALUES (1, 2)  
+
+    DB[:table].insert_conflict(:replace).insert(:a=>1, :b=>2)
+    # INSERT OR REPLACE INTO TABLE (a, b) VALUES (1, 2)
+
+* An identifier_columns plugin has been added, which allows
+  Sequel::Model#save to work when column names contain double
+  underscores.
+
+= Other Improvements
+
+* IPv6 addresses can now be used in connection URLs when using
+  ruby 1.9.3+.
+
+* The :db_type entries in column schema hashes now include sizes
+  for string and decimal types on DB2 and when using the jdbc
+  adapter's generic schema parsing.
+
+* Database#row_type in the pg_row extension now handles different
+  formats of specifying schema qualified types.  So a row type
+  registered via :schema__type can be found using
+  Sequel.qualify(:schema, :type).
+
+* Another disconnect error is recognized in the tinytds adapter.

data/lib/sequel/adapters/jdbc.rb

@@ -597,6 +597,19 @@ module Sequel
       def setup_connection(conn)
         conn
       end
+
+      def schema_column_set_db_type(schema)
+        case schema[:type]
+        when :string
+          if schema[:db_type] =~ /\A(character( varying)?|n?(var)?char2?)\z/io && schema[:column_size] > 0
+            schema[:db_type] += "(#{schema[:column_size]})"
+          end
+        when :decimal
+          if schema[:db_type] =~ /\A(decimal|numeric)\z/io && schema[:column_size] > 0 && schema[:scale] >= 0
+            schema[:db_type] += "(#{schema[:column_size]}, #{schema[:scale]})"
+          end
+        end
+      end
       
       # Parse the table schema for the given table.
       def schema_parse_table(table, opts=OPTS)
@@ -626,6 +639,7 @@ module Sequel
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
           end
+          schema_column_set_db_type(s)
           schemas << h[:table_schem] unless schemas.include?(h[:table_schem])
           ts << [m.call(h[:column_name]), s]
         end

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

@@ -35,11 +35,14 @@ module Sequel
         im = input_identifier_meth(opts[:dataset])
         metadata_dataset.with_sql("SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = #{literal(im.call(table))} ORDER BY COLNO").
           collect do |column| 
-            column[:db_type]     = column.delete(:typename)
-            if column[:db_type]  == "DECIMAL"
+            column[:db_type] = column.delete(:typename)
+            if column[:db_type] =~ /\A(VAR)?CHAR\z/
+              column[:db_type] << "(#{column[:length]})"
+            end
+            if column[:db_type] == "DECIMAL"
               column[:db_type] << "(#{column[:longlength]},#{column[:scale]})"
             end
-            column[:allow_null]  = column.delete(:nulls) == 'Y'
+            column[:allow_null] = column.delete(:nulls) == 'Y'
             identity = column.delete(:identity) == 'Y'
             if column[:primary_key] = identity || !column[:keyseq].nil?
               column[:auto_increment] = identity

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

@@ -514,9 +514,10 @@ module Sequel
       DATE_OPEN = "date(".freeze
       DATETIME_OPEN = "datetime(".freeze
       ONLY_OFFSET = " LIMIT -1 OFFSET ".freeze
+      OR = " OR ".freeze
 
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
-      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert into columns values'], ["else", %w'insert into columns values']])
+      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values'], ["else", %w'insert conflict into columns values']])
       Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
@@ -604,7 +605,32 @@ module Sequel
           super
         end
       end
-      
+
+      # Handle uniqueness violations when inserting, by using a specified
+      # resolution algorithm. With no options, uses INSERT OR REPLACE. SQLite
+      # supports the following conflict resolution algoriths: ROLLBACK, ABORT,
+      # FAIL, IGNORE and REPLACE.
+      #
+      # Examples:
+      #
+      #   DB[:table].insert_conflict.insert(:a=>1, :b=>2)
+      #   # INSERT OR IGNORE INTO TABLE (a, b) VALUES (1, 2)
+      #
+      #   DB[:table].insert_conflict(:replace).insert(:a=>1, :b=>2)
+      #   # INSERT OR REPLACE INTO TABLE (a, b) VALUES (1, 2)
+      def insert_conflict(resolution = :ignore)
+        clone(:insert_conflict => resolution)
+      end
+
+      # Ignore uniqueness/exclusion violations when inserting, using INSERT OR IGNORE.
+      # Exists mostly for compatibility to MySQL's insert_ignore. Example:
+      #
+      #   DB[:table].insert_ignore.insert(:a=>1, :b=>2)
+      #   # INSERT OR IGNORE INTO TABLE (a, b) VALUES (1, 2)
+      def insert_ignore
+        insert_conflict(:ignore)
+      end
+
       # SQLite 3.8.3+ supports common table expressions.
       def supports_cte?(type=:select)
         db.sqlite_version >= 30803
@@ -679,6 +705,13 @@ module Sequel
         columns.map{|i| quote_identifier(i)}.join(COMMA)
       end
     
+      # Add OR clauses to SQLite INSERT statements
+      def insert_conflict_sql(sql)
+        if resolution = @opts[:insert_conflict]
+          sql << OR << resolution.to_s.upcase
+        end
+      end
+
       # SQLite uses a preceding X for hex escaping strings
       def literal_blob_append(sql, v)
         sql << BLOB_START << v.unpack(HSTAR).first << APOS

data/lib/sequel/adapters/tinytds.rb

@@ -129,7 +129,7 @@ module Sequel
         end
       end
 
-      TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client)/
+      TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out)/
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
         super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && TINYTDS_DISCONNECT_ERRORS.match(e.message)))

data/lib/sequel/database/misc.rb

@@ -78,11 +78,13 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
-      { :user => uri.user,
+      {
+        :user => uri.user,
         :password => uri.password,
-        :host => uri.host,
         :port => uri.port,
-        :database => (m = /\/(.*)/.match(uri.path)) && (m[1]) }
+        :host => RUBY_VERSION < '1.9.3' ? uri.host : uri.hostname,
+        :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
+      }
     end
     private_class_method :uri_to_options
 

data/lib/sequel/dataset/actions.rb

@@ -298,7 +298,7 @@ module Sequel
     #
     # +insert+ handles a number of different argument formats:
     # no arguments or single empty hash :: Uses DEFAULT VALUES
-    # single hash :: Most common format, treats keys as columns an values as values
+    # single hash :: Most common format, treats keys as columns and values as values
     # single array :: Treats entries as values, with no columns
     # two arrays :: Treats first array as columns, second array as values
     # single Dataset :: Treats as an insert based on a selection from the dataset given,

data/lib/sequel/extensions/pg_row.rb

@@ -488,7 +488,7 @@ module Sequel
             PGArray.register(array_type_name, :oid=>array_oid, :converter=>parser, :type_procs=>@conversion_procs, :scalar_typecast=>schema_type_symbol)
           end
 
-          @row_types[db_type] = opts.merge(:parser=>parser)
+          @row_types[literal(db_type)] = opts.merge(:parser=>parser, :type=>db_type)
           @row_schema_types[schema_type_string] = schema_type_symbol 
           @schema_type_classes[schema_type_symbol] = ROW_TYPE_CLASSES
           @row_type_method_module.class_eval do
@@ -508,8 +508,8 @@ module Sequel
         def reset_conversion_procs
           procs = super
 
-          row_types.each do |db_type, opts|
-            register_row_type(db_type, opts)
+          row_types.values.each do |opts|
+            register_row_type(opts[:type], opts)
           end
 
           procs
@@ -519,7 +519,7 @@ module Sequel
         # In general, the given database type should already be registered,
         # but if obj is an array, this will handled unregistered types.
         def row_type(db_type, obj)
-          (type_hash = @row_types[db_type]) &&
+          (type_hash = @row_types[literal(db_type)]) &&
             (parser = type_hash[:parser])
 
           case obj

data/lib/sequel/model/associations.rb

@@ -105,12 +105,12 @@ module Sequel
 
         # Apply an eager limit strategy to the dataset, or return the dataset
         # unmodified if it doesn't need an eager limit strategy.
-        def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy)
+        def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy, limit_and_offset=limit_and_offset())
           case strategy
           when :distinct_on
             apply_distinct_on_eager_limit_strategy(ds)
           when :window_function
-            apply_window_function_eager_limit_strategy(ds)
+            apply_window_function_eager_limit_strategy(ds, limit_and_offset)
           else
             ds
           end
@@ -123,7 +123,7 @@ module Sequel
         end
 
         # Use a window function to limit the results of the eager loading dataset.
-        def apply_window_function_eager_limit_strategy(ds)
+        def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
           rn = ds.row_number_column 
           limit, offset = limit_and_offset
           ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
@@ -143,13 +143,13 @@ module Sequel
 
         # If the ruby eager limit strategy is being used, slice the array using the slice
         # range to return the object(s) at the correct offset/limit.
-        def apply_ruby_eager_limit_strategy(rows)
+        def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
           name = self[:name]
           if returns_array?
-            range = slice_range
+            range = slice_range(limit_and_offset)
             rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-          elsif slice_range
-            offset = slice_range.begin
+          elsif sr = slice_range(limit_and_offset)
+            offset = sr.begin
             rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
@@ -245,12 +245,29 @@ module Sequel
           end
           strategy = eager_limit_strategy
           cascade = eo[:associations]
+          eager_limit = nil
 
           if eo[:eager_block] || eo[:loader] == false
+            ds = eager_loading_dataset(eo)
+
+            strategy = ds.opts[:eager_limit_strategy] || strategy
+
+            eager_limit =
+              if el = ds.opts[:eager_limit]
+                strategy ||= true_eager_graph_limit_strategy
+                if el.is_a?(Array)
+                  el
+                else
+                  [el, nil]
+                end
+              else
+                limit_and_offset
+              end
+
             strategy = true_eager_graph_limit_strategy if strategy == :union
             # Correlated subqueries are not supported for regular eager loading
             strategy = :ruby if strategy == :correlated_subquery
-            objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
+            objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
           elsif strategy == :union
             objects = []
             ds = associated_dataset
@@ -269,7 +286,7 @@ module Sequel
 
           objects.each(&block)
           if strategy == :ruby
-            apply_ruby_eager_limit_strategy(rows)
+            apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
           end
         end
 
@@ -461,7 +478,7 @@ module Sequel
         end
         
         # The range used for slicing when using the :ruby eager limit strategy.
-        def slice_range
+        def slice_range(limit_and_offset = limit_and_offset())
           limit, offset = limit_and_offset
           if limit || offset
             (offset||0)..(limit ? (offset||0)+limit-1 : -1)

data/lib/sequel/model/base.rb

@@ -1856,13 +1856,16 @@ module Sequel
   
       # Insert into the given dataset and return the primary key created (if any).
       def _insert_raw(ds)
-        ds.insert(@values)
+        ds.insert(_insert_values)
       end
 
       # Insert into the given dataset and return the hash of column values.
       def _insert_select_raw(ds)
-        ds.insert_select(@values)
+        ds.insert_select(_insert_values)
       end
+
+      # The values hash to use when inserting a new record.
+      alias _insert_values values
       
       # Refresh using a particular dataset, used inside save to make sure the same server
       # is used for reading newly inserted values from the database

data/lib/sequel/plugins/identifier_columns.rb

@@ -0,0 +1,45 @@
+module Sequel
+  module Plugins
+    # The identifier_columns plugin makes Sequel automatically
+    # handle column names containing 2 or more consecutive
+    # underscores when creating or updating model objects.
+    # By default, this doesn't work correctly in Sequel, as it
+    # handles such symbols specially.
+    #
+    # This behavior isn't the default as it hurts performance,
+    # and is rarely necessary.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses handle column names
+    #   # with two or more underscores when saving
+    #   Sequel::Model.plugin :identifier_columns
+    #
+    #   # Make the Album class handle column names
+    #   # with two or more underscores when saving
+    #   Album.plugin :identifier_columns
+    module IdentifierColumns
+      module InstanceMethods
+        private
+
+        # Use identifiers for value hash keys when inserting.
+        def _insert_values
+          identifier_hash(super)
+        end
+
+        # Use identifiers for value hash keys when updating.
+        def _update_without_checking(columns)
+          super(identifier_hash(columns))
+        end
+
+        # Convert the given columns hash from symbol
+        # keys to Sequel::SQL::Identifier keys.
+        def identifier_hash(columns)
+          h = {}
+          columns.each{|k,v| h[Sequel.identifier(k)] = v}
+          h
+        end
+      end
+    end
+  end
+end

data/lib/sequel/version.rb

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

data/spec/adapters/postgres_spec.rb

@@ -3406,6 +3406,9 @@ describe 'PostgreSQL row-valued/composite types' do
       end
       @db.register_row_type(:domain_check)
       @db.get(@db.row_type(:domain_check, [1])).must_equal(:id=>1)
+      @db.register_row_type(:public__domain_check)
+      @db.get(@db.row_type(:public__domain_check, [1])).must_equal(:id=>1)
+      @db.get(@db.row_type(Sequel.qualify(:public, :domain_check), [1])).must_equal(:id=>1)
     ensure
       @db.drop_table(:domain_check)
       @db << "DROP DOMAIN positive_integer"

data/spec/adapters/sqlite_spec.rb

@@ -371,6 +371,41 @@ describe "SQLite::Dataset#update" do
   end
 end
 
+describe "SQLite::Dataset#insert_conflict" do
+  before(:all) do
+    DB.create_table! :ic_test do
+      primary_key :id
+      String :name
+    end
+  end
+
+  after(:each) do
+    DB[:ic_test].delete
+  end
+
+  after(:all) do
+    DB.drop_table?(:ic_test)
+  end
+
+  it "Dataset#insert_ignore and insert_constraint should ignore uniqueness violations" do
+    DB[:ic_test].insert(:id => 1, :name => "one")
+    proc {DB[:ic_test].insert(:id => 1, :name => "one")}.must_raise Sequel::ConstraintViolation
+
+    DB[:ic_test].insert_ignore.insert(:id => 1, :name => "one")
+    DB[:ic_test].all.must_equal([{:id => 1, :name => "one"}])
+
+    DB[:ic_test].insert_conflict(:ignore).insert(:id => 1, :name => "one")
+    DB[:ic_test].all.must_equal([{:id => 1, :name => "one"}])
+  end
+
+  it "Dataset#insert_constraint should handle replacement" do
+    DB[:ic_test].insert(:id => 1, :name => "one")
+
+    DB[:ic_test].insert_conflict(:replace).insert(:id => 1, :name => "two")
+    DB[:ic_test].all.must_equal([{:id => 1, :name => "two"}])
+  end
+end
+
 describe "SQLite dataset" do
   before do
     DB.create_table! :test do

data/spec/core/database_spec.rb

@@ -222,6 +222,10 @@ describe "A new Database" do
     db = Sequel.connect('mock:///?keep_reference=f')
     Sequel::DATABASES.wont_include(db)
   end
+
+  it 'should strip square brackets for ipv6 hosts' do
+    Sequel.connect('mock://[::1]').opts[:host].must_equal "::1"
+  end if RUBY_VERSION >= '1.9.3'
 end
 
 describe "Database#disconnect" do

data/spec/extensions/identifier_columns_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "identifier_columns plugin" do
+  before do
+    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :a__b=>2}, :autoid=>1)
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @ds = @c.dataset
+    @c.columns :id, :a__b
+    @c.plugin :identifier_columns
+    @db.sqls
+  end
+
+  it "should not use qualification when updating or inserting values" do
+    @c.create(:a__b=>2).save
+    @db.sqls.must_equal ["INSERT INTO test (a__b) VALUES (2)", "SELECT * FROM test WHERE (id = 1) LIMIT 1", "UPDATE test SET a__b = 2 WHERE (id = 1)"]
+  end
+end

data/spec/integration/associations_test.rb

@@ -1914,6 +1914,29 @@ describe "Sequel::Model Simple Associations" do
     artists.each{|a| a.first_two_albums.length.must_equal 1}
   end
 
+  it "should handle the :eager_limit option in eager-loading callbacks" do
+    @db[:artists].import([:name], (1..4).map{|i| ['test']})
+    artist_ids = @db[:artists].where(:name => 'test').select_map([:id])
+    @db[:albums].import([:artist_id], artist_ids * 3)
+    ads = Artist.where(:id => artist_ids)
+
+    artists = ads.eager(:albums => proc{|ds| ds.clone(:eager_limit => 1)}).all
+    artists.length.must_equal 4
+    artists.each{|a| a.albums.length.must_equal 1}
+
+    artists = ads.eager(:albums => proc{|ds| ds.clone(:eager_limit => 2)}).all
+    artists.length.must_equal 4
+    artists.each{|a| a.albums.length.must_equal 2}
+
+    artists = ads.eager(:albums => proc{|ds| ds.clone(:eager_limit => 3)}).all
+    artists.length.must_equal 4
+    artists.each{|a| a.albums.length.must_equal 3}
+
+    artists = ads.eager(:albums => proc{|ds| ds.clone(:eager_limit => 4)}).all
+    artists.length.must_equal 4
+    artists.each{|a| a.albums.length.must_equal 3}
+  end
+
   it "should handle many_to_one associations with same name as :key" do
     Album.def_column_alias(:artist_id_id, :artist_id)
     Album.many_to_one :artist_id, :key_column =>:artist_id, :class=>Artist

data/spec/integration/schema_test.rb

@@ -159,6 +159,18 @@ describe "Database schema parser" do
     DB.schema(:items).first.last[:type].must_equal :boolean
   end
 
+  it "should round trip database types from the schema properly" do
+    DB.create_table!(:items){String :number, :size=>50}
+    db_type = DB.schema(:items).first.last[:db_type]
+    DB.create_table!(:items){column :number, db_type}
+    DB.schema(:items).first.last[:db_type].must_equal db_type
+
+    DB.create_table!(:items){Numeric :number, :size=>[11,3]}
+    db_type = DB.schema(:items).first.last[:db_type]
+    DB.create_table!(:items){column :number, db_type}
+    DB.schema(:items).first.last[:db_type].must_equal db_type
+  end
+
   it "should parse maximum length for string columns" do
     DB.create_table!(:items){String :a, :size=>4}
     DB.schema(:items).first.last[:max_length].must_equal 4

data/spec/model/eager_loading_spec.rb

@@ -1113,6 +1113,50 @@ describe Sequel::Model, "#eager" do
     EagerBand.eager(:good_albums => proc {|ds| ds.select(:name)}).all
     DB.sqls.must_equal ['SELECT * FROM bands', "SELECT name FROM albums WHERE ((name = 'good') AND (albums.band_id IN (2)))"]
   end
+
+  it "should respect an :eager_limit option passed in a custom callback" do
+    # Should default to a window function on its own.
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    a = EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>5)}).all
+    a.must_equal [EagerAlbum.load(:id => 1, :band_id=> 2)]
+    sqls = DB.sqls
+    sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 5)']
+    a = a.first
+    a.tracks.must_equal [EagerTrack.load(:id => 3, :album_id => 1)]
+    DB.sqls.must_equal []
+  end
+
+  it "should respect an :eager_limit option that includes an offset" do
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>[5, 5])}).all
+    DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE ((x_sequel_row_number_x >= 6) AND (x_sequel_row_number_x < 11))']
+  end
+
+  it "should have an :eager_limit option passed in a custom callback override a :limit defined in the association" do
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2
+    EagerAlbum.eager(:first_two_tracks=> proc{|ds| ds.clone(:eager_limit=>5)}).all
+    DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 5)']
+  end
+
+  it "should respect an :eager_limit_strategy option passed in a custom callback" do
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset._fetch = (1..4).map{|i| {:album_id=>1, :id=>i}}
+    a = EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>2, :eager_limit_strategy=>:ruby)}).all
+    a.must_equal [EagerAlbum.load(:id => 1, :band_id=> 2)]
+    sqls = DB.sqls
+    sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    a = a.first
+    a.tracks.must_equal [EagerTrack.load(:id => 1, :album_id => 1), EagerTrack.load(:id => 2, :album_id => 1)]
+    DB.sqls.must_equal []
+  end
+
+  it "should have an :eager_limit_strategy option passed in a custom callback override a :eager_limit_strategy defined in the association" do
+    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2, :eager_limit_strategy=>:ruby
+    EagerAlbum.eager(:first_two_tracks=> proc{|ds| ds.clone(:eager_limit_strategy=>:window_function)}).all
+    DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
+  end
 end
 
 describe Sequel::Model, "#eager_graph" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.29.0
+  version: 4.30.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-01 00:00:00.000000000 Z
+date: 2016-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -230,6 +230,7 @@ extra_rdoc_files:
 - doc/release_notes/4.27.0.txt
 - doc/release_notes/4.28.0.txt
 - doc/release_notes/4.29.0.txt
+- doc/release_notes/4.30.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -348,6 +349,7 @@ files:
 - doc/release_notes/4.28.0.txt
 - doc/release_notes/4.29.0.txt
 - doc/release_notes/4.3.0.txt
+- doc/release_notes/4.30.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt
@@ -555,6 +557,7 @@ files:
 - lib/sequel/plugins/error_splitter.rb
 - lib/sequel/plugins/force_encoding.rb
 - lib/sequel/plugins/hook_class_methods.rb
+- lib/sequel/plugins/identifier_columns.rb
 - lib/sequel/plugins/input_transformer.rb
 - lib/sequel/plugins/insert_returning_select.rb
 - lib/sequel/plugins/instance_filters.rb
@@ -674,6 +677,7 @@ files:
 - spec/extensions/graph_each_spec.rb
 - spec/extensions/hash_aliases_spec.rb
 - spec/extensions/hook_class_methods_spec.rb
+- spec/extensions/identifier_columns_spec.rb
 - spec/extensions/inflector_spec.rb
 - spec/extensions/input_transformer_spec.rb
 - spec/extensions/insert_returning_select_spec.rb