sequel 4.17.0 → 4.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d6fa8ec8783c8834b984323d9e1c73bef006df5
-  data.tar.gz: 40e551bc46ec90be6a411ca2eec0e4114394b03d
+  metadata.gz: 0fc29f94c84321473e3ed262bd8ac957a265e295
+  data.tar.gz: f25fc9635d509858d7275081fe1e5c67cf6db8ce
 SHA512:
-  metadata.gz: 06d6af6daccc3ae11f55e17d6b39472509c3ddd90af821e0e6e353dfab49b6b30ea4c213b4596f46f048a6ff3807bcfc9257a13d08d8ccdc9a52d18478e59e6a
-  data.tar.gz: 6c31bed38421bb9acf75235b01229fe777baeb311fef31554c4b6070454147d37b4a249650e4c6c788602d5550c0db373546af9066a398aa9d01b2882568b810
+  metadata.gz: 306ffd681a632fe5aee226016f51f62beb296e7b080d69b3c791690825e370c3e85ebea3002007ee9bc0f371f0d05026a215229364af10c9dcad0cc906f1e2bd
+  data.tar.gz: f0c9cf0fe10ce041abd556111a0f845840f2415ad6832a8ddcc2b37b0a4fcff0b538f0da3fbc95f21d7a5995df9bfb61a95bfa48a202686ba4abb4533105658d

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== 4.18.0 (2015-01-02)
+
+* Make Dataset#empty? work when the dataset is ordered by a non-column expression (pete) (#923)
+
+* Fix passing a hash value to :eager association option (jeremyevans)
+
+* Treat all PG::ConnectionBad exceptions as disconnect errors in the postgres adapter (jeremyevans)
+
+* Add :auto_increment key to schema information for primary key columns (jeremyevans) (#919)
+
+* Fix handling of schema qualified tables in many_through_many associations (jeremyevans)
+
 === 4.17.0 (2014-12-01)
 
 * Fix handling of Sequel::SQL::Blob instances in bound variables in the postgres adapter (jeremyevans) (#917)

data/doc/dataset_filtering.rdoc

@@ -1,4 +1,4 @@
-= Dataset Filtering 
+= Dataset Filtering
 
 Sequel is very flexibile when it comes to filtering records. You can specify your conditions as a custom string, as a string with parameters, as a hash of values to compare against, or as ruby code that Sequel translates into SQL expressions.
 
@@ -76,29 +76,29 @@ If you need to select multiple items from a dataset, you can supply an array:
 You can pass a block to where, which is evaluated in a special context:
 
   items.where{price * 2 < 50}.sql
-  #=> "SELECT * FROM items WHERE ((price * 2) < 50) 
+  #=> "SELECT * FROM items WHERE ((price * 2) < 50)
 
 This works for the standard inequality and arithmetic operators:
 
   items.where{price + 100 < 200}.sql
-  #=> "SELECT * FROM items WHERE ((price + 100) < 200) 
+  #=> "SELECT * FROM items WHERE ((price + 100) < 200)
 
   items.where{price - 100 > 200}.sql
-  #=> "SELECT * FROM items WHERE ((price - 100) > 200) 
+  #=> "SELECT * FROM items WHERE ((price - 100) > 200)
 
   items.where{price * 100 <= 200}.sql
-  #=> "SELECT * FROM items WHERE ((price * 100) <= 200) 
+  #=> "SELECT * FROM items WHERE ((price * 100) <= 200)
 
   items.where{price / 100 >= 200}.sql
-  #=> "SELECT * FROM items WHERE ((price / 100) >= 200) 
+  #=> "SELECT * FROM items WHERE ((price / 100) >= 200)
 
 You use the overloaded bitwise and (&) and or (|) operators to combine expressions:
 
   items.where{(price + 100 < 200) & (price * 100 <= 200)}.sql
-  #=> "SELECT * FROM items WHERE (((price + 100) < 200) AND ((price * 100) <= 200)) 
+  #=> "SELECT * FROM items WHERE (((price + 100) < 200) AND ((price * 100) <= 200))
 
   items.where{(price - 100 > 200) | (price / 100 >= 200)}.sql
-  #=> "SELECT * FROM items WHERE (((price - 100) > 200) OR ((price / 100) >= 200)) 
+  #=> "SELECT * FROM items WHERE (((price - 100) > 200) OR ((price / 100) >= 200))
 
 To filter by equality, you use the standard hash, which can be combined with other expressions using Sequel.& and Sequel.|:
 
@@ -124,7 +124,7 @@ You can use the exclude method to exclude conditions:
   #=> "SELECT * FROM items WHERE NOT active"
 
   items.exclude{price / 100 >= 200}.sql
-  #=> "SELECT * FROM items WHERE ((price / 100) < 200) 
+  #=> "SELECT * FROM items WHERE ((price / 100) < 200)
 
 === Comparing against column references
 
@@ -163,15 +163,15 @@ Like can also take more than one argument:
 
 == String concatenation
 
-You can concatenate SQL strings using Sequel.join: 
+You can concatenate SQL strings using Sequel.join:
 
-  items.where(Sequel.join([:name, :comment]).like('%acme%')).sql
-  #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Acme%' ESCAPE '\')"
+  items.where(Sequel.join([:name, :comment]).like('Jo%nice%')).sql
+  #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Jo%nice%' ESCAPE '\')"
 
 Sequel.join also takes a join argument:
 
-  items.filter(Sequel.join([:name, :comment], ' ').like('%acme%')).sql
-  #=> "SELECT * FROM items WHERE ((name || ' ' || comment) LIKE 'Acme%' ESCAPE '\')"
+  items.filter(Sequel.join([:name, :comment], ':').like('John:%nice%')).sql
+  #=> "SELECT * FROM items WHERE ((name || ':' || comment) LIKE 'John:%nice%' ESCAPE '\')"
 
 == Filtering using sub-queries
 

data/doc/release_notes/4.18.0.txt

@@ -0,0 +1,36 @@
+= New Features
+
+* An :auto_increment key has been added to the schema information for
+  primary key columns on JDBC, PostgreSQL, MySQL, MSSQL, DB2, and
+  SQLite.  This fixes issues in the schema_dumper extension where
+  non-auto-incrementing integer primary keys are no longer dumped as
+  auto-incrementing.
+
+  For adapters that don't have specific support for detecting
+  auto incrementing primary keys, Sequel now assumes a primary key
+  is auto incrementing only if it is not a composite primary key
+  and the type contains int (e.g. int, integer, bigint).
+
+= Other Improvements
+
+* Dataset#empty? now ignores any order on the dataset.  Previously,
+  calling empty? on a dataset ordered by an alias in the SELECT list
+  could raise an exception.
+
+* Schema qualified tables are now handled correctly in
+  many_through_many associations.
+
+* Using a hash as the value for the :eager association option now
+  works correctly.
+
+* All PG::ConnectionBad exceptions are now treated as disconnect
+  errors in the postgres adapter.  This should be more robust than
+  the previous method of trying to recognize disconnect errors by
+  trying to parse the exception message.
+
+* Sequel now skips a hash allocation when issuing queries through
+  datasets if sharding is not used.
+
+* Sequel no longer uses the JDBC schema parsing in the jdbc/sqlserver
+  adapter.  Instead, it uses the MSSQL schema parsing, which should
+  be more accurate than the generic JDBC schema parsing.

data/lib/sequel/adapters/jdbc.rb

@@ -604,7 +604,18 @@ module Sequel
         schemas = []
         metadata(:getColumns, nil, schema, table, nil) do |h|
           next if schema_parse_table_skip?(h, schema)
-          s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
+          s = {
+            :type=>schema_column_type(h[:type_name]),
+            :db_type=>h[:type_name],
+            :default=>(h[:column_def] == '' ? nil : h[:column_def]),
+            :allow_null=>(h[:nullable] != 0),
+            :primary_key=>pks.include?(h[:column_name]),
+            :column_size=>h[:column_size],
+            :scale=>h[:decimal_digits]
+          }
+          if s[:primary_key]
+            s[:auto_increment] = h[:is_autoincrement] == "YES"
+          end
           s[:max_length] = s[:column_size] if s[:type] == :string
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer

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

@@ -2,11 +2,6 @@ Sequel.require 'adapters/shared/mssql'
 
 module Sequel
   module JDBC
-    class Database
-      # Alias the generic JDBC version so it can be called directly later
-      alias jdbc_schema_parse_table schema_parse_table
-    end
-    
     # Database and Dataset instance methods for MSSQL specific
     # support via JDBC.
     module MSSQL
@@ -31,12 +26,6 @@ module Sequel
           end
         end
         
-        # Call the generic JDBC version instead of MSSQL version,
-        # since the JDBC version handles primary keys.
-        def schema_parse_table(table, opts=OPTS)
-          jdbc_schema_parse_table(table, opts)
-        end
-        
         # Primary key indexes appear to start with pk__ on MSSQL
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE

data/lib/sequel/adapters/oracle.rb

@@ -304,6 +304,7 @@ module Sequel
               :allow_null => column.nullable?
           }
           h[:type] = oracle_column_type(h)
+          h[:auto_increment] = h[:type] == :integer if h[:primary_key]
           h[:max_length] = h[:char_size] if h[:type] == :string
           table_schema << [m.call(column.name), h]
         end

data/lib/sequel/adapters/postgres.rb

@@ -108,13 +108,24 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
+      # The underlying exception classes to reraise as disconnect errors
+      # instead of regular database errors.
+      DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
+      if defined?(::PG::ConnectionBad)
+        DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
+      end
+      
       disconnect_errors = [
         'could not receive data from server',
         'no connection to the server',
         'connection not open',
         'terminating connection due to administrator command',
-        'PQconsumeInput() SSL SYSCALL error'
+        'PQconsumeInput() '
        ]
+
+      # Since exception class based disconnect checking may not work,
+      # also trying parsing the exception message to look for disconnect
+      # errors.
       DISCONNECT_ERROR_RE = /\A#{Regexp.union(disconnect_errors)}/
       
       self.translate_results = false if respond_to?(:translate_results=)
@@ -124,11 +135,15 @@ module Sequel
       # are SQL strings.
       attr_reader(:prepared_statements) if SEQUEL_POSTGRES_USES_PG
       
-      # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
-      # the connection status cannot be determined or it is not OK.
+      # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
+      # error classes is raised, or a PGError is raised and the connection
+      # status cannot be determined or it is not OK.
       def check_disconnect_errors
         begin
           yield
+        rescue *DISCONNECT_ERROR_CLASSES => e
+          disconnect = true
+          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
         rescue PGError => e
           disconnect = false
           begin
@@ -140,9 +155,6 @@ module Sequel
           disconnect ||= !status_ok
           disconnect ||= e.message =~ DISCONNECT_ERROR_RE
           disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
-        rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
-          disconnect = true
-          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
         ensure
           block if status_ok && !disconnect
         end

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

@@ -40,7 +40,10 @@ module Sequel
               column[:db_type] << "(#{column[:longlength]},#{column[:scale]})"
             end
             column[:allow_null]  = column.delete(:nulls) == 'Y'
-            column[:primary_key] = column.delete(:identity) == 'Y' || !column[:keyseq].nil?
+            identity = column.delete(:identity) == 'Y'
+            if column[:primary_key] = identity || !column[:keyseq].nil?
+              column[:auto_increment] = identity
+            end
             column[:type]        = schema_column_type(column[:db_type])
             column[:max_length]  = column[:longlength] if column[:type] == :string
             [ m.call(column.delete(:name)), column]

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

@@ -428,11 +428,15 @@ module Sequel
         m = output_identifier_meth(opts[:dataset])
         m2 = input_identifier_meth(opts[:dataset])
         tn = m2.call(table_name.to_s)
-        table_id = get{object_id(tn)}
+        table_id = get(Sequel.function(:object_id, tn))
         info_sch_sch = opts[:information_schema_schema]
         inf_sch_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, s) : Sequel.expr(s)}
         sys_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, Sequel.qualify(Sequel.lit(''), s)) : Sequel.expr(s)}
 
+        identity_cols = metadata_dataset.from(:sys__columns).
+          where(:object_id=>table_id, :is_identity=>true).
+          select_map(:name)
+
         pk_index_id = metadata_dataset.from(sys_qual.call(:sysindexes)).
           where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
           get(:indid)
@@ -440,16 +444,21 @@ module Sequel
           join(sys_qual.call(:syscolumns).as(:sc), :id=>:id, :colid=>:colid).
           where(:sik__id=>table_id, :sik__indid=>pk_index_id).
           select_order_map(:sc__name)
+
         ds = metadata_dataset.from(inf_sch_qual.call(:information_schema__tables).as(:t)).
          join(inf_sch_qual.call(:information_schema__columns).as(:c), :table_catalog=>:table_catalog,
               :table_schema => :table_schema, :table_name => :table_name).
          select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
          filter(:c__table_name=>tn)
+
         if schema = opts[:schema]
           ds.filter!(:c__table_schema=>schema)
         end
+
         ds.map do |row|
-          row[:primary_key] = pk_cols.include?(row[:column])
+          if row[:primary_key] = pk_cols.include?(row[:column])
+            row[:auto_increment] = identity_cols.include?(row[:column])
+          end
           row[:allow_null] = row[:allow_null] == 'YES' ? true : false
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE && row[:scale] == 0

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

@@ -460,10 +460,12 @@ module Sequel
         table = SQL::Identifier.new(im.call(table_name))
         table = SQL::QualifiedIdentifier.new(im.call(opts[:schema]), table) if opts[:schema]
         metadata_dataset.with_sql("DESCRIBE ?", table).map do |row|
-          row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
+          extra = row.delete(:Extra)
+          if row[:primary_key] = row.delete(:Key) == 'PRI'
+            row[:auto_increment] = !!(extra.to_s =~ /auto_increment/io)
+          end
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
-          row[:primary_key] = row.delete(:Key) == 'PRI'
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
           [m.call(row.delete(:Field)), row]

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

@@ -1035,12 +1035,6 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end
 
-      # PostgreSQL's autoincrementing primary keys are of type integer or bigint
-      # using a nextval function call as a default.
-      def schema_autoincrementing_primary_key?(schema)
-        super && schema[:default] =~ /\Anextval/io
-      end
-
       # Recognize PostgreSQL interval type.
       def schema_column_type(db_type)
         case db_type
@@ -1086,6 +1080,9 @@ module Sequel
             row.delete(:db_base_type)
           end
           row[:type] = schema_column_type(row[:db_type])
+          if row[:primary_key]
+            row[:auto_increment] = !!(row[:default] =~ /\Anextval/io)
+          end
           [m.call(row.delete(:name)), row]
         end
       end

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

@@ -282,6 +282,11 @@ module Sequel
         end
       end
 
+      # SQLite does not need to specify AUTOINCREMENT, integer primary keys are automatically auto incrementing.
+      def auto_increment_sql
+        ''
+      end
+
       def begin_new_transaction(conn, opts)
         mode = opts[:mode] || @transaction_mode
         sql = TRANSACTION_MODE[mode] or raise Error, "transaction :mode must be one of: :deferred, :immediate, :exclusive, nil"
@@ -457,19 +462,16 @@ module Sequel
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
-          row[:primary_key] = row.delete(:pk).to_i > 0
           row[:default] = nil if blank_object?(row[:default]) || row[:default] == 'NULL'
           row[:db_type] = row.delete(:type)
+          if row[:primary_key] = row.delete(:pk).to_i > 0
+            row[:auto_increment] = row[:db_type].downcase == 'integer'
+          end
           row[:type] = schema_column_type(row[:db_type])
           row
         end
       end
       
-      # SQLite treats integer primary keys as autoincrementing (alias of rowid).
-      def schema_autoincrementing_primary_key?(schema)
-        super && schema[:db_type].downcase == 'integer'
-      end
-
       # SQLite supports schema parsing using the table_info PRAGMA, so
       # parse the output of that into the format Sequel expects.
       def schema_parse_table(table_name, opts)

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -1,5 +1,13 @@
 module Sequel
   module EmulateOffsetWithRowNumber
+    # If the offset must be emulated with ROW_NUMBER, don't remove any ordering,
+    # because it can cause invalid queries to be issued if an offset is required
+    # when ordering.
+    def empty?
+      return super unless emulate_offset_with_row_number?
+      get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
+    end
+
     # Emulate OFFSET support with the ROW_NUMBER window function
     # 
     # The implementation is ugly, cloning the current dataset and modifying

data/lib/sequel/database/query.rb

@@ -157,8 +157,20 @@ module Sequel
 
       cols = schema_parse_table(table_name, opts)
       raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+
+      primary_keys = 0
+      auto_increment_set = false
+      cols.all? do |_,c|
+        auto_increment_set = true if c.has_key?(:auto_increment)
+        primary_keys += 1 if c[:primary_key]
+      end
+
       cols.each do |_,c|
         c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])
+        if c[:primary_key] && !auto_increment_set
+          # If adapter didn't set it, assume that integer primary keys are auto incrementing
+          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/io)
+        end
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end

data/lib/sequel/database/schema_generator.rb

@@ -323,7 +323,7 @@ module Sequel
       #
       #   add_constraint(:valid_name, Sequel.like(:name, 'A%'))
       #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%' ESCAPE '\')
-      #   add_constraint({:name=>:valid_name, :deferrable=>true}, :num=>1..5)
+      #   add_constraint({:name=>:valid_name, :deferrable=>true}, Sequel.like(:name, 'A%'))
       #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%' ESCAPE '\') DEFERRABLE INITIALLY DEFERRED
       def add_constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}

data/lib/sequel/database/schema_methods.rb

@@ -837,7 +837,7 @@ module Sequel
 
     # Return true if the given column schema represents an autoincrementing primary key.
     def schema_autoincrementing_primary_key?(schema)
-      !!(schema[:primary_key] && schema[:db_type] =~ /int/io)
+      !!(schema[:primary_key] && schema[:auto_increment])
     end
 
     # The dataset to use for proxying certain schema methods.

data/lib/sequel/dataset/actions.rb

@@ -146,7 +146,8 @@ module Sequel
     #   DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
     #   # => false
     def empty?
-      get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
+      ds = @opts[:order] ? unordered : self
+      ds.get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
     end
 
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
@@ -763,7 +764,7 @@ module Sequel
     #   DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
     #   # => 10
     #
-    #   DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
+    #   DB[:table].update(:x=>Sequel.expr(:x)+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
     def update(values=OPTS, &block)
       sql = update_sql(values)
@@ -897,13 +898,14 @@ module Sequel
 
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
-      {:server=>@opts[:server] || :default}.merge(opts)
+      @db.sharded? ? {:server=>@opts[:server] || :default}.merge(opts) : opts
     end
 
     # Execute the given select SQL on the database using execute. Use the
     # :read_only server unless a specific server is set.
     def execute(sql, opts=OPTS, &block)
-      @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)
+      db = @db
+      db.execute(sql, db.sharded? ? {:server=>@opts[:server] || :read_only}.merge(opts) : opts, &block)
     end
     
     # Execute the given SQL on the database using execute_ddl.

data/lib/sequel/model/associations.rb

@@ -75,7 +75,7 @@ module Sequel
           ds = ds.order(*self[:order]) if self[:order]
           ds = ds.limit(*self[:limit]) if self[:limit]
           ds = ds.limit(1) if limit_to_single_row?
-          ds = ds.eager(*self[:eager]) if self[:eager]
+          ds = ds.eager(self[:eager]) if self[:eager]
           ds = ds.distinct if self[:distinct]
           ds
         end

data/lib/sequel/model/base.rb

@@ -1144,12 +1144,10 @@ module Sequel
       alias to_hash values
 
       # Creates new instance and passes the given values to set.
-      # If a block is given, yield the instance to the block unless
-      # from_db is true.
+      # If a block is given, yield the instance to the block.
       #
       # Arguments:
       # values :: should be a hash to pass to set. 
-      # from_db :: only for backwards compatibility, forget it exists.
       #
       #   Artist.new(:name=>'Bob')
       #

data/lib/sequel/plugins/many_through_many.rb

@@ -114,9 +114,14 @@ module Sequel
 
         def _associated_dataset
           ds = associated_class
-          reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
-          ft = final_reverse_edge
-          ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep)
+          (reverse_edges + [final_reverse_edge]).each do |t|
+            h = {:qualify=>:deep}
+            if t[:alias] != t[:table]
+              h[:table_alias] = t[:alias]
+            end
+            ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
+          end
+          ds
         end
 
         # Make sure to use unique table aliases when lazy loading or eager loading

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 = 17
+  MINOR = 18
   # 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

@@ -71,11 +71,11 @@ describe "MySQL", '#create_table' do
 
   specify "should include an :auto_increment schema attribute if auto incrementing" do
     @db.create_table(:dolls) do
+      primary_key :n4
       Integer :n2
       String :n3
-      Integer :n4, :auto_increment=>true, :unique=>true
     end
-    @db.schema(:dolls).map{|k, v| v[:auto_increment]}.should == [nil, nil, true]
+    @db.schema(:dolls).map{|k, v| v[:auto_increment]}.should == [true, nil, nil]
   end
 
   specify "should support collate with various other column options" do
@@ -105,9 +105,9 @@ if [:mysql, :mysql2].include?(DB.adapter_scheme)
     end
 
     specify "should consider tinyint(1) datatypes as boolean if set, but not larger tinyints" do
-      @db.schema(:booltest, :reload=>true).should == [[:b, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(1)"}, ], [:i, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}, ]]
+      @db.schema(:booltest, :reload=>true).map{|_, s| s[:type]}.should == [:boolean, :integer]
       @db.convert_tinyint_to_bool = false
-      @db.schema(:booltest, :reload=>true).should == [[:b, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(1)"}, ], [:i, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}, ]]
+      @db.schema(:booltest, :reload=>true).map{|_, s| s[:type]}.should == [:integer, :integer]
     end
 
     specify "should return tinyint(1)s as bools and tinyint(4)s as integers when set" do

data/spec/adapters/postgres_spec.rb

@@ -252,9 +252,7 @@ describe "A PostgreSQL database" do
   end
 
   specify "should correctly parse the schema" do
-    @db.schema(:public__testfk, :reload=>true).should == [
-      [:id, {:type=>:integer, :ruby_default=>nil, :db_type=>"integer", :default=>"nextval('testfk_id_seq'::regclass)", :oid=>23, :primary_key=>true, :allow_null=>false}],
-      [:i, {:type=>:integer, :ruby_default=>nil, :db_type=>"integer", :default=>nil, :oid=>23, :primary_key=>false, :allow_null=>true}]]
+    @db.schema(:public__testfk, :reload=>true).map{|c,s| [c, s[:oid]]}.should == [[:id, 23], [:i, 23]]
   end
 
   specify "should parse foreign keys for tables in a schema" do
@@ -300,7 +298,7 @@ describe "A PostgreSQL database with domain types" do
   specify "should correctly parse the schema" do
     sch = @db.schema(:testfk, :reload=>true)
     sch.first.last.delete(:domain_oid).should be_a_kind_of(Integer)
-    sch.should == [[:id, {:type=>:decimal, :ruby_default=>nil, :db_type=>"numeric(10,2)", :default=>nil, :oid=>1700, :primary_key=>true, :allow_null=>false, :db_domain_type=>'positive_number'}]]
+    sch.first.last[:db_domain_type].should == 'positive_number'
   end
 end
 

data/spec/core/database_spec.rb

@@ -2104,9 +2104,9 @@ end
 describe "Database#schema_autoincrementing_primary_key?" do
   specify "should indicate whether the parsed schema row indicates a primary key" do
     m = Sequel::Database.new.method(:schema_autoincrementing_primary_key?)
-    m.call(:primary_key=>true, :db_type=>'integer').should == true
-    m.call(:primary_key=>true, :db_type=>'varchar(255)').should == false
-    m.call(:primary_key=>false, :db_type=>'integer').should == false
+    m.call(:primary_key=>true, :auto_increment=>true).should == true
+    m.call(:primary_key=>true, :auto_increment=>false).should == false
+    m.call(:primary_key=>false).should == false
   end
 end
 

data/spec/core/dataset_spec.rb

@@ -1952,6 +1952,15 @@ describe "Dataset#empty?" do
     db.from(:test).filter(false).should be_empty
     db.sqls.should == ["SELECT 1 AS one FROM test WHERE 'f' LIMIT 1"]
   end
+
+  specify "should ignore order" do
+    db = Sequel.mock(:fetch=>proc{|sql| {1=>1}})
+    db.from(:test).should_not be_empty
+    without_order = db.sqls
+    db.from(:test).order(:the_order_column).should_not be_empty
+    with_order = db.sqls
+    without_order.should == with_order
+  end
 end
 
 describe "Dataset#first_source_alias" do

data/spec/core/schema_spec.rb

@@ -1544,6 +1544,27 @@ describe "Schema Parser" do
     @sqls.should == ['x', 'x']
   end
 
+  specify "should set :auto_increment to true by default if unset and a single integer primary key is used" do
+    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.schema(:x).first.last[:auto_increment].should == true
+  end
+
+  specify "should not set :auto_increment if already set" do
+    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer', :auto_increment=>false}]]}
+    @db.schema(:x).first.last[:auto_increment].should == false
+  end
+
+  specify "should set :auto_increment to false by default if unset and a single nonintegery primary key is used" do
+    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'varchar'}]]}
+    @db.schema(:x).first.last[:auto_increment].should == false
+  end
+
+  specify "should set :auto_increment to false by default if unset and a composite primary key" do
+    meta_def(@db, :schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}], [:b, {:primary_key=>true, :db_type=>'integer'}]]}
+    @db.schema(:x).first.last[:auto_increment].should == false
+    @db.schema(:x).last.last[:auto_increment].should == false
+  end
+
   specify "should convert various types of table name arguments" do
     meta_def(@db, :schema_parse_table) do |t, opts|
       [[t, opts]]

data/spec/extensions/many_through_many_spec.rb

@@ -70,6 +70,19 @@ describe Sequel::Model, "many_through_many" do
     a.first.tags.should == [@c2.load(:id=>4)]
   end
   
+  it "should handle schema qualified tables" do
+    @c1.many_through_many :tags, :through=>[[:myschema__albums_artists, :artist_id, :album_id], [:myschema__albums, :id, :id], [:myschema__albums_tags, :album_id, :tag_id]]
+    @c1.load(:id=>1).tags_dataset.sql.should == "SELECT tags.* FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id = 1)"
+
+    @c1.dataset._fetch = {:id=>1}
+    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>1}
+    a = @c1.eager(:tags).all
+    a.should == [@c1.load(:id => 1)]
+    DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, myschema.albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id IN (1))"]
+
+    @c1.eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id, tags.h1, tags.h2 FROM artists LEFT OUTER JOIN myschema.albums_artists AS albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN myschema.albums AS albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN myschema.albums_tags AS albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)'
+  end
+  
   it "should default to associating to other models in the same scope" do
     begin
       class ::AssociationModuleTest

data/spec/extensions/schema_dumper_spec.rb

@@ -68,7 +68,7 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:schema) do |t, *o|
       case t
       when :t1, 't__t1', Sequel.identifier(:t__t1)
-        [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
+        [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true, :allow_null=>false}],
          [:c2, {:db_type=>'varchar(20)', :allow_null=>true}]]
       when :t2
         [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>false}],
@@ -92,7 +92,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should dump non-Integer primary key columns with explicit :type" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
     @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
   end
 
@@ -104,7 +104,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should handle primary keys that are also foreign keys" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
     s = @d.dump_table_schema(:t6)
@@ -126,7 +126,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should handle foreign key options in the primary key" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
     s = @d.dump_table_schema(:t6)
@@ -151,7 +151,7 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should omit foreign key options that are the same as defaults in the primary key" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
     s = @d.dump_table_schema(:t6)
@@ -232,7 +232,7 @@ END_MIG
   it "should sort table names topologically when dumping a migration with foreign keys" do
     @d.meta_def(:tables){|o| [:t1, :t2]}
     @d.meta_def(:schema) do |t|
-      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
     end
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
@@ -284,7 +284,7 @@ END_MIG
   it "should sort topologically even if the database raises an error when trying to parse foreign keys for a non-existent table" do
     @d.meta_def(:tables){|o| [:t1, :t2]}
     @d.meta_def(:schema) do |t|
-      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true}]]
+      t == :t1 ? [[:c2, {:db_type=>'integer'}]] : [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]
     end
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list) do |t|
@@ -763,13 +763,13 @@ END_MIG
   end
 
   it "should use separate primary_key call with non autoincrementable types" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true, :auto_increment=>false}]]}
     @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"
     @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"varchar(8)\"\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use explicit type for non integer foreign_key types" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :primary_key=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :primary_key=>true, :auto_increment=>false}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>Date, :key=>[:c1]\n  \n  primary_key [:c1]\nend",
@@ -779,7 +779,7 @@ END_MIG
   end
 
   it "should correctly handing autoincrementing primary keys that are also foreign keys" do
-    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true}]]}
+    @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :primary_key=>true, :auto_increment=>true}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",

data/spec/integration/schema_test.rb

@@ -88,6 +88,15 @@ describe "Database schema parser" do
     DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
   end
 
+  cspecify "should parse autoincrementing primary keys from the schema properly", :sqlite, :oracle, :fdbsql do
+    DB.create_table!(:items){Integer :number}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key] && v[:auto_increment]}.compact.should == []
+    DB.create_table!(:items){primary_key :number}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key] && v[:auto_increment]}.compact.should == [:number]
+    DB.create_table!(:items){Integer :number, :primary_key=>true}
+    DB.schema(:items).collect{|k,v| k if v[:primary_key] && v[:auto_increment]}.compact.should == []
+  end
+
   specify "should parse NULL/NOT NULL from the schema properly" do
     DB.create_table!(:items){Integer :number, :null=>true}
     DB.schema(:items).first.last[:allow_null].should == true

data/spec/model/eager_loading_spec.rb

@@ -538,6 +538,21 @@ describe Sequel::Model, "#eager" do
     DB.sqls.should == []
   end
   
+  it "should respect :eager with cascaded hash when lazily loading an association" do
+    EagerBand.one_to_many :albums, :eager=>{:tracks=>:album}, :clone=>:albums
+    a = EagerBand.all
+    a.should == [EagerBand.load(:id=>2)]
+    DB.sqls.should == ['SELECT * FROM bands']
+    a = a.first.albums
+    DB.sqls.should == ['SELECT * FROM albums WHERE (albums.band_id = 2)',
+      'SELECT * FROM tracks WHERE (tracks.album_id IN (1))',
+      'SELECT * FROM albums WHERE (albums.id IN (1))']
+    a.should == [EagerAlbum.load(:id => 1, :band_id => 2)]
+    a.first.tracks.should == [EagerTrack.load(:id => 3, :album_id => 1)]
+    a.first.tracks.first.album.should == a.first
+    DB.sqls.should == []
+  end
+  
   it "should cascade eagerly loading when the :eager_graph association option is used" do
     EagerAlbum.dataset._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
     a = EagerBand.eager(:graph_albums).all

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.17.0
+  version: 4.18.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-01 00:00:00.000000000 Z
-dependencies: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The Database Toolkit for Ruby
 email: code@jeremyevans.net
 executables:
@@ -134,6 +190,7 @@ extra_rdoc_files:
 - doc/release_notes/4.15.0.txt
 - doc/release_notes/4.16.0.txt
 - doc/release_notes/4.17.0.txt
+- doc/release_notes/4.18.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -238,6 +295,7 @@ files:
 - doc/release_notes/4.15.0.txt
 - doc/release_notes/4.16.0.txt
 - doc/release_notes/4.17.0.txt
+- doc/release_notes/4.18.0.txt
 - doc/release_notes/4.2.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt
@@ -736,7 +794,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby