sequel 3.16.0 → 3.17.0

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 3.17.0 (2010-11-05)
+
+* Ensure that the optimistic locking plugin increments the lock column when using Model#modified! (jfirebaugh)
+
+* Correctly handle nil values in the xml_serializer plugin, instead of converting them to empty strings (george.haff) (#313)
+
+* Use a default wait_timeout that's allowed on Windows for the mysql and mysql2 adapters (jeremyevans) (#314)
+
+* Add support for connecting to MySQL over SSL using the :sslca, :sslkey, and related options (jeremyevans)
+
+* Fix Database#each_server when used with jdbc or do connection strings without separate :adapter option (jeremyevans) (#312)
+
+* Much better support in the AS400 JDBC subadapter (bhauff)
+
+* Allow cloning of many_through_many associations (gucki, jeremyevans)
+
+* In the nested_attributes plugin, don't make unnecessary update calls to modify associated objects that are about to be deleted (jeremyevans, gucki)
+
+* Allow Dataset#(add|set)_graph_aliases to accept as hash values symbols and arrays with a single element (jeremyevans)
+
+* Add Databse#views and #view_exists? to the Oracle adapter (gpheruson)
+
+* Add Database#sql_log_level for changing the level at which SQL queries are logged (jeremyevans)
+
+* Remove unintended use of prepared statements in swift adapter (jeremyevans)
+
+* Fix logging in the swift PostgreSQL subadapter (jeremyevans)
+
 === 3.16.0 (2010-10-01)
 
 * Support composite foreign keys for associations in the identity_map plugin (harukizaemon, jeremyevans) (#310)

data/doc/release_notes/3.17.0.txt

@@ -0,0 +1,58 @@
+= New Features
+
+* You can now change the level at which Sequel logs SQL statements,
+  by calling Database#sql_log_level= with the method name symbol.
+  The default is still :info for backwards compatibility. Previously,
+  you had to use a proxy logger to get similar capability.
+
+* You can now specify graph aliases where the alias would be the same
+  as the table column name using just the table name symbol, instead
+  having to repeat the alias as the second element of an array.  More
+  clearly:
+
+    # < 3.17.0:
+    DB[:a].graph(:b, :a_id=>:id).
+      set_graph_aliases(:c=>[:a, :c], :d=>[:b, :d])
+    # >= 3.17.0:
+    DB[:a].graph(:b, :a_id=>:id).set_graph_aliases(:c=>:a, :d=>:b)
+    
+  Both of these now yield the SQL:
+  
+    SELECT a.c, b.d FROM a LEFT OUTER JOIN b ON (b.a_id = a.id)
+
+* You should now be able to connect to MySQL over SSL in the native
+  MySQL adapter using the :sslca, :sslkey, and related options.
+
+* Database#views and Database#view_exists? methods were added to the
+  Oracle adapter, allowing you to get a an array of view name symbols
+  and to check whether a given view exists.
+
+= Other Improvements
+
+* The nested_attributes plugin now avoids unnecessary update calls
+  when deleting associated objects, resulting in better performance.
+
+* The optimistic_locking plugin now increments the lock column if no
+  other columns were modified but the Model#modified! was called. This
+  means it now works correctly with the nested_attributes plugin when
+  no changes to the main model object are made.
+
+* The xml_serializer plugin can now round-trip nil values correctly.
+  Previously, nil values would be converted into empty strings.  This
+  is accomplished by including a nil attribute in the xml tag.
+  
+* Database#each_server now works correctly when using the jdbc and do
+  adapters and a connection string without a separate :adapter option.
+  
+* You can now clone many_through_many associations.
+
+* The default wait_timeout used by the mysql and mysql2 adapters was
+  decreased slightly so that it works correctly with MySQL database
+  servers that run on Windows.
+  
+* Many improvements were made to the AS400 jdbc subadapter.
+
+* Many improvements were made to the swift adapter and subadapters.
+
+* Dataset#ungraphed now removes any cached graph aliases set with
+  set_graph_aliases or add_graph_aliases.

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

@@ -4,6 +4,10 @@ module Sequel
     module AS400
       # Instance methods for AS400 Database objects accessed via JDBC.
       module DatabaseMethods
+        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+        
         # AS400 uses the :as400 database type.
         def database_type
           :as400
@@ -18,28 +22,67 @@ module Sequel
         def last_insert_id(conn, opts={})
           nil
         end
+
+        # AS400 supports transaction isolation levels
+        def supports_transaction_isolation_levels?
+          true
+        end
+
+        private
+
+        # Use JDBC connection's setAutoCommit to false to start transactions
+        def begin_transaction(conn, opts={})
+          set_transaction_isolation(conn, opts)
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          conn
+        end
+
+        # Use JDBC connection's commit method to commit transactions
+        def commit_transaction(conn, opts={})
+          log_yield(TRANSACTION_COMMIT){conn.commit}
+        end
+
+        # Use JDBC connection's setAutoCommit to true to enable default
+        # auto-commit mode
+        def remove_transaction(conn)
+          conn.setAutoCommit(true) if conn
+          @transactions.delete(Thread.current)
+        end
+
+        # Use JDBC connection's rollback method to rollback transactions
+        def rollback_transaction(conn, opts={})
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        end
       end
       
       # Dataset class for AS400 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         WILDCARD = Sequel::LiteralString.new('*').freeze
         
-        # AS400 needs to use a couple of subselects for all limits and offsets.
+        # AS400 needs to use a couple of subselects for queries with offsets.
         def select_sql
-          return super unless l = @opts[:limit]
-          o = @opts[:offset] || 0
+          return super unless o = @opts[:offset]
+          l = @opts[:limit]
           order = @opts[:order]
           dsa1 = dataset_alias(1)
           dsa2 = dataset_alias(2)
           rn = row_number_column
           irn = Sequel::SQL::Identifier.new(rn).qualify(dsa2)
           subselect_sql(unlimited.
-            from_self(:alias=>dsa1).
-            select_more(Sequel::SQL::QualifiedIdentifier.new(dsa1, WILDCARD),
+              from_self(:alias=>dsa1).
+              select_more(Sequel::SQL::QualifiedIdentifier.new(dsa1, WILDCARD),
               Sequel::SQL::WindowFunction.new(SQL::Function.new(:ROW_NUMBER), Sequel::SQL::Window.new(:order=>order)).as(rn)).
-            from_self(:alias=>dsa2).
-            select(Sequel::SQL::QualifiedIdentifier.new(dsa2, WILDCARD)).
-            where((irn > o) & (irn <= l + o)))
+              from_self(:alias=>dsa2).
+              select(Sequel::SQL::QualifiedIdentifier.new(dsa2, WILDCARD)).
+              where(l ? ((irn > o) & (irn <= l + o)) : (irn > o))) # Leave off limit in case of limit(nil, offset)
+        end
+
+        # Modify the sql to limit the number of rows returned
+        def select_limit_sql(sql)
+          if @opts[:limit]
+            sql << " FETCH FIRST ROW ONLY" if @opts[:limit] == 1
+            sql << " FETCH FIRST #{@opts[:limit]} ROWS ONLY" if @opts[:limit] > 1
+          end
         end
           
         def supports_window_functions?

data/lib/sequel/adapters/mysql.rb

@@ -93,6 +93,7 @@ module Sequel
         conn = Mysql.init
         conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
         conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
+        conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]
         if encoding = opts[:encoding] || opts[:charset]
           # Set encoding before connecting so that the mysql driver knows what
           # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
@@ -116,8 +117,9 @@ module Sequel
         # that feature.
         sqls << "SET NAMES #{literal(encoding.to_s)}" if encoding
 
-        # increase timeout so mysql server doesn't disconnect us
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2592000}"
+        # Increase timeout so mysql server doesn't disconnect us
+        # Value used by default is maximum allowed value on Windows.
+        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
 
         # By default, MySQL 'where id is null' selects the last inserted id
         sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]

data/lib/sequel/adapters/mysql2.rb

@@ -46,8 +46,9 @@ module Sequel
           sqls << "SET NAMES #{conn.escape(encoding.to_s)}"
         end
 
-        # increase timeout so mysql server doesn't disconnect us
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2592000}"
+        # Increase timeout so mysql server doesn't disconnect us.
+        # Value used by default is maximum allowed value on Windows.
+        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
 
         # By default, MySQL 'where id is null' selects the last inserted id
         sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]

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

@@ -30,6 +30,15 @@ module Sequel
         from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
       end
 
+      def views(opts={}) 
+        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW') 
+        ds.map{|r| ds.send(:output_identifier, r[:tname])} 
+      end 
+ 
+      def view_exists?(name) 
+        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'VIEW').count > 0 
+      end 
+
       private
 
       def auto_increment_sql

data/lib/sequel/adapters/swift.rb

@@ -64,7 +64,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             res = nil
-            log_yield(sql){res = conn.prepare(sql).execute}
+            log_yield(sql){conn.execute(sql); res = conn.results}
             yield res if block_given?
             nil
           rescue SwiftError => e
@@ -92,9 +92,12 @@ module Sequel
       def execute_insert(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.prepare(sql).execute.insert_id}
+            res = nil
+            log_yield(sql){conn.execute(sql); (res = conn.results).insert_id}
           rescue SwiftError => e
             raise_error(e)
+          ensure
+            res.finish if res
           end
         end
       end

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

@@ -46,6 +46,21 @@ module Sequel
           Sequel::Swift::Postgres::Dataset.new(self, opts)
         end
         
+        # Run the SELECT SQL on the database and yield the rows
+        def execute(sql, opts={})
+          synchronize(opts[:server]) do |conn|
+            begin
+              conn.execute(sql)
+              res = conn.results
+              yield res if block_given?
+            rescue SwiftError => e
+              raise_error(e)
+            ensure
+              res.finish if res
+            end
+          end
+        end
+        
         # Run the DELETE/UPDATE SQL on the database and return the number
         # of matched rows.
         def execute_dui(sql, opts={})
@@ -62,8 +77,12 @@ module Sequel
         # for the record.
         def execute_insert(sql, opts={})
           synchronize(opts[:server]) do |conn|
-            conn.execute(sql)
-            insert_result(conn, opts[:table], opts[:values])
+            begin
+              conn.execute(sql)
+              insert_result(conn, opts[:table], opts[:values])
+            rescue SwiftError => e
+              raise_error(e)
+            end
           end
         end
         

data/lib/sequel/database/connecting.rb

@@ -15,6 +15,8 @@ module Sequel
     # Raises Sequel::AdapterNotFound if the adapter
     # could not be loaded.
     def self.adapter_class(scheme)
+      return scheme if scheme.is_a?(Class)
+
       scheme = scheme.to_s.gsub('-', '_').to_sym
       
       unless klass = ADAPTER_MAP[scheme]
@@ -58,7 +60,7 @@ module Sequel
         end
       when Hash
         opts = conn_string.merge(opts)
-        c = adapter_class(opts[:adapter] || opts['adapter'])
+        c = adapter_class(opts[:adapter_class] || opts[:adapter] || opts['adapter'])
       else
         raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
       end

data/lib/sequel/database/logging.rb

@@ -12,6 +12,11 @@ module Sequel
     # Array of SQL loggers to use for this database.
     attr_accessor :loggers
     
+    # Log level at which to log SQL queries.  This is actually the method
+    # sent to the logger, so it should be the method name symbol. The default
+    # is :info, it can be set to :debug to log at DEBUG level.
+    attr_accessor :sql_log_level
+
     # Log a message at level info to all loggers.
     def log_info(message, args=nil)
       log_each(:info, args ? "#{message}; #{args.inspect}" : message)
@@ -51,7 +56,7 @@ module Sequel
     # Log message with message prefixed by duration at info level, or
     # warn level if duration is greater than log_warn_duration.
     def log_duration(duration, message)
-      log_each((lwd = log_warn_duration and duration >= lwd) ? :warn : :info, "(#{sprintf('%0.6fs', duration)}) #{message}")
+      log_each((lwd = log_warn_duration and duration >= lwd) ? :warn : sql_log_level, "(#{sprintf('%0.6fs', duration)}) #{message}")
     end
 
     # Log message at level (which should be :error, :warn, or :info)

data/lib/sequel/database/misc.rb

@@ -32,6 +32,7 @@ module Sequel
     # :quote_identifiers :: Whether to quote identifiers
     # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol 
     # :single_threaded :: Whether to use a single-threaded connection pool
+    # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
     # All options given are also passed to the connection pool.  If a block
     # is given, it is used as the connection_proc for the ConnectionPool.
@@ -43,6 +44,7 @@ module Sequel
       @opts[:disconnection_proc] ||= proc{|conn| disconnect_connection(conn)}
       block ||= proc{|server| connect(server)}
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
+      @opts[:adapter_class] = self.class
       
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, @@single_threaded))
       @schemas = {}
@@ -52,6 +54,7 @@ module Sequel
       @identifier_input_method = nil
       @identifier_output_method = nil
       @quote_identifiers = nil
+      self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(@opts, &block)
 
       ::Sequel::DATABASES.push(self)

data/lib/sequel/dataset/graph.rb

@@ -15,7 +15,8 @@ module Sequel
     #   # SELECT ..., table.column AS some_alias
     #   # => {:table=>{:column=>some_alias_value, ...}, ...}
     def add_graph_aliases(graph_aliases)
-      ds = select_more(*graph_alias_columns(graph_aliases))
+      columns, graph_aliases = graph_alias_columns(graph_aliases)
+      ds = select_more(*columns)
       ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || (ds.opts[:graph][:column_aliases] rescue {}) || {}).merge(graph_aliases)
       ds
     end
@@ -183,20 +184,25 @@ module Sequel
     # graphing is used.
     #
     # graph_aliases :: Should be a hash with keys being symbols of
-    #                  column aliases, and values being arrays with two or three elements.
-    #                  The first element of the array should be the table alias symbol,
-    #                  and the second should be the actual column name symbol. If the array
+    #                  column aliases, and values being either symbols or arrays with one to three elements.
+    #                  If the value is a symbol, it is assumed to be the same as a one element
+    #                  array containing that symbol.
+    #                  The first element of the array should be the table alias symbol.
+    #                  The second should be the actual column name symbol.  If the array only
+    #                  has a single element the column name symbol will be assumed to be the
+    #                  same as the corresponding hash key. If the array
     #                  has a third element, it is used as the value returned, instead of
     #                  table_alias.column_name.
     #
     #   DB[:artists].graph(:albums, :artist_id=>:id).
-    #     set_graph_aliases(:artist_name=>[:artists, :name],
+    #     set_graph_aliases(:name=>:artists,
     #                       :album_name=>[:albums, :name],
     #                       :forty_two=>[:albums, :fourtwo, 42]).first
-    #   # SELECT artists.name AS artist_name, albums.name AS album_name, 42 AS forty_two FROM table
+    #   # SELECT artists.name, albums.name AS album_name, 42 AS forty_two ...
     #   # => {:artists=>{:name=>artists.name}, :albums=>{:name=>albums.name, :fourtwo=>42}}
     def set_graph_aliases(graph_aliases)
-      ds = select(*graph_alias_columns(graph_aliases))
+      columns, graph_aliases = graph_alias_columns(graph_aliases)
+      ds = select(*columns)
       ds.opts[:graph_aliases] = graph_aliases
       ds
     end
@@ -204,18 +210,25 @@ module Sequel
     # Remove the splitting of results into subhashes, and all metadata
     # related to the current graph (if any).
     def ungraphed
-      clone(:graph=>nil)
+      clone(:graph=>nil, :graph_aliases=>nil)
     end
 
     private
 
-    # Transform the hash of graph aliases to an array of columns
+    # Transform the hash of graph aliases and return a two element array
+    # where the first element is an array of identifiers suitable to pass to
+    # a select method, and the second is a new hash of preprocessed graph aliases.
     def graph_alias_columns(graph_aliases)
-      graph_aliases.collect do |col_alias, tc| 
-        identifier = tc[2] || SQL::QualifiedIdentifier.new(tc[0], tc[1])
-        identifier = SQL::AliasedExpression.new(identifier, col_alias) if tc[2] or tc[1] != col_alias
+      gas = {}
+      identifiers = graph_aliases.collect do |col_alias, tc| 
+        table, column, value = Array(tc)
+        column ||= col_alias
+        gas[col_alias] = [table, column]
+        identifier = value || SQL::QualifiedIdentifier.new(table, column)
+        identifier = SQL::AliasedExpression.new(identifier, col_alias) if value or column != col_alias
         identifier
       end
+      [identifiers, gas]
     end
 
     # Fetch the rows, split them into component table parts,

data/lib/sequel/model/associations.rb

@@ -97,7 +97,7 @@ module Sequel
         def need_associated_primary_key?
           false
         end
-    
+        
         # Returns the reciprocal association variable, if one exists. The reciprocal
         # association is the association in the associated class that is the opposite
         # of the current association.  For example, Album.many_to_one :artist and
@@ -128,6 +128,12 @@ module Sequel
           :"remove_all_#{self[:name]}"
         end
       
+        # Whether associated objects need to be removed from the association before
+        # being destroyed in order to preserve referential integrity.
+        def remove_before_destroy?
+          true
+        end
+    
         # Name symbol for the remove_ association method
         def remove_method
           :"remove_#{singularize(self[:name])}"
@@ -144,7 +150,7 @@ module Sequel
           true
         end
     
-        # The columns to select when loading the association, nil by default.
+        # The columns to select when loading the association.
         def select
           self[:select]
         end
@@ -259,22 +265,27 @@ module Sequel
          self[:primary_key] ||= self[:model].primary_key
         end
       
-        # One to many associations set the reciprocal to self when loading associated records.
-        def set_reciprocal_to_self?
-          true
-        end
-    
         # Whether the reciprocal of this association returns an array of objects instead of a single object,
         # false for a one_to_many association.
         def reciprocal_array?
           false
         end
     
+        # Destroying one_to_many associated objects automatically deletes the foreign key.
+        def remove_before_destroy?
+          false
+        end
+    
         # The one_to_many association needs to check that an object to be removed already is associated.
         def remove_should_check_existing?
           true
         end
 
+        # One to many associations set the reciprocal to self when loading associated records.
+        def set_reciprocal_to_self?
+          true
+        end
+    
         private
     
         # The reciprocal type of a one_to_many association is a many_to_one association.

data/lib/sequel/model/base.rb

@@ -1236,7 +1236,7 @@ module Sequel
             @columns_updated = @values.reject{|k, v| !columns.include?(k)}
             changed_columns.reject!{|c| columns.include?(c)}
           end
-          _update(@columns_updated) unless @columns_updated.empty?
+          _update_columns(@columns_updated)
           @this = nil
           after_update
           after_save
@@ -1264,7 +1264,14 @@ module Sequel
         Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
         v
       end
-      
+
+      # Call _update with the given columns, if any are present.
+      # Plugins can override this method in order to update with
+      # additional columns, even when the column hash is initially empty.
+      def _update_columns(columns)
+        _update(columns) unless columns.empty?
+      end
+
       # Update this instance's dataset with the supplied column hash.
       def _update(columns)
         n = _update_dataset.update(columns)

data/lib/sequel/plugins/identity_map.rb

@@ -24,7 +24,8 @@ module Sequel
     #
     # The identity_map plugin is not compatible with the standard eager loading of
     # many_to_many and many_through_many associations.  If you want to use the identity_map plugin,
-    # you should use +eager_graph+ instead of +eager+ for those associations.
+    # you should use +eager_graph+ instead of +eager+ for those associations. It is also
+    # not compatible with the eager loading in the +rcte_tree+ plugin.
     #
     # Usage:
     #

data/lib/sequel/plugins/many_through_many.rb

@@ -141,8 +141,8 @@ module Sequel
         #     array of symbols for a composite key association.
         #   * :uniq - Adds a after_load callback that makes the array of objects unique.
         def many_through_many(name, through, opts={}, &block)
-          associate(:many_through_many, name, opts.merge(:through=>through), &block)
-        end 
+          associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
+        end
 
         private
 

data/lib/sequel/plugins/nested_attributes.rb

@@ -123,15 +123,18 @@ module Sequel
         end
         
         # Remove the matching associated object from the current object.
-        # If the :destroy option is given, destroy the object after disassociating it.
+        # If the :destroy option is given, destroy the object after disassociating it
+        # (unless destroying the object would automatically disassociate it).
         # Returns the object removed, if it exists.
         def nested_attributes_remove(reflection, pk, opts={})
           if obj = nested_attributes_find(reflection, pk)
-            before_save_hook do
-              if reflection.returns_array?
-                send(reflection.remove_method, obj)
-              else
-                send(reflection.setter_method, nil)
+            if !opts[:destroy] || reflection.remove_before_destroy?
+              before_save_hook do
+                if reflection.returns_array?
+                  send(reflection.remove_method, obj)
+                else
+                  send(reflection.setter_method, nil)
+                end
               end
             end
             after_save_hook{obj.destroy} if opts[:destroy]

data/lib/sequel/plugins/optimistic_locking.rb

@@ -68,7 +68,7 @@ module Sequel
         
         # Only update the row if it has the same lock version, and increment the
         # lock version.
-        def _update(columns)
+        def _update_columns(columns)
           lc = model.lock_column
           lcv = send(lc)
           columns[lc] = lcv + 1

data/lib/sequel/plugins/xml_serializer.rb

@@ -205,9 +205,9 @@ module Sequel
                 klass.from_xml_node(node)
               end
             elsif cols.include?(k)
-              self[k.to_sym] = node.children.first.to_s
+              self[k.to_sym] = node[:nil] ? nil : node.children.first.to_s
             elsif meths.include?("#{k}=")
-              send("#{k}=", node.children.first.to_s)
+              send("#{k}=", node[:nil] ? nil : node.children.first.to_s)
             else
               raise Error, "Entry in XML not an association or column and no setter method exists: #{k}"
             end
@@ -268,7 +268,15 @@ module Sequel
           x = model.xml_builder(opts)
           x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name)).to_s]) do |x1|
             cols.each do |c|
-              x1.send(name_proc[c.to_s], vals[c], types ? {:type=>db_schema.fetch(c, {})[:type]} : {})
+              attrs = {}
+              if types
+                attrs[:type] = db_schema.fetch(c, {})[:type]
+              end
+              v = vals[c]
+              if v.nil?
+                attrs[:nil] = ''
+              end
+              x1.send(name_proc[c.to_s], v, attrs)
             end
             if inc.is_a?(Hash)
               inc.each{|k, v| to_xml_include(x1, k, v)}

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

data/spec/core/database_spec.rb

@@ -23,6 +23,11 @@ context "A new Database" do
     Sequel::Database.new(1 => 2, :logger => [4], :loggers => [3]).loggers.should == [4,3]
   end
   
+  specify "should set the sql_log_level from opts[:sql_log_level]" do
+    db = Sequel::Database.new(1 => 2, :sql_log_level=>:debug).sql_log_level.should == :debug
+    db = Sequel::Database.new(1 => 2, :sql_log_level=>'debug').sql_log_level.should == :debug
+  end
+  
   specify "should create a connection pool" do
     @db.pool.should be_a_kind_of(Sequel::ConnectionPool)
     @db.pool.max_size.should == 4
@@ -262,6 +267,15 @@ context "Database#log_yield" do
     @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
   end
 
+  specify "should respect sql_log_level setting" do
+    @db.sql_log_level = :debug
+    @db.log_yield('blah'){}
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :debug
+    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
+  end
+
   specify "should log message with duration at warn level if duration greater than log_warn_duration" do
     @db.log_warn_duration = 0
     @db.log_yield('blah'){}
@@ -954,19 +968,19 @@ context "A Database adapter with a scheme" do
     c = Sequel.ccc('mydb')
     p = proc{c.opts.delete_if{|k,v| k == :disconnection_proc || k == :single_threaded}}
     c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :adapter_class=>CCC}
     
     c = Sequel.ccc('mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>CCC}
     
     c = Sequel.ccc
     c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc}
+    p.call.should == {:adapter=>:ccc, :adapter_class=>CCC}
     
     c = Sequel.ccc(:database => 'mydb', :host => 'localhost')
     c.should be_a_kind_of(CCC)
-    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost'}
+    p.call.should == {:adapter=>:ccc, :database => 'mydb', :host => 'localhost', :adapter_class=>CCC}
   end
   
   specify "should be accessible through Sequel.connect with options" do
@@ -1484,6 +1498,31 @@ context "Database#remove_servers" do
   end
 end
 
+context "Database#each_server with do/jdbc adapter connection string without :adapter option" do
+  before do
+    klass = Class.new(Sequel::Database)
+    klass.should_receive(:adapter_class).once.with(:jdbc).and_return(MockDatabase)
+    @db = klass.connect('jdbc:blah:', :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
+    def @db.connect(server)
+      server_opts(server)
+    end
+    def @db.disconnect_connection(c)
+    end
+  end
+
+  specify "should yield a separate database object for each server" do
+    hosts = []
+    @db.each_server do |db|
+      db.should be_a_kind_of(Sequel::Database)
+      db.should_not == @db
+      db.opts[:adapter_class].should == MockDatabase
+      db.opts[:database].should == 2
+      hosts << db.opts[:host]
+    end
+    hosts.sort.should == [1, 3]
+  end
+end
+
 context "Database#each_server" do
   before do
     @db = Sequel.connect(:adapter=>:mock, :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})

data/spec/core/object_graph_spec.rb

@@ -160,6 +160,20 @@ describe Sequel::Dataset, " graphing" do
     ].should(include(ds.sql))
   end
 
+  it "#set_graph_aliases should allow a single array entry to specify a table, assuming the same column as the key" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines])
+    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
+    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
+  it "#set_graph_aliases should allow hash values to be symbols specifying table, assuming the same column as the key" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines)
+    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
+    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
   it "#set_graph_aliases should only alias columns if necessary" do
     ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
     ['SELECT points.x, lines.y FROM points',
@@ -282,6 +296,26 @@ describe Sequel::Dataset, " graphing" do
     results.first.should == {:points=>{:z1=>2}, :lines=>{:z2=>3}}
   end
 
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines])
+    def ds.fetch_rows(sql, &block)
+      yield({:x=>2,:y=>3})
+    end
+    results = ds.all
+    results.length.should == 1
+    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
+  end
+
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines)
+    def ds.fetch_rows(sql, &block)
+      yield({:x=>2,:y=>3})
+    end
+    results = ds.all
+    results.length.should == 1
+    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
+  end
+
   it "#graph_each should run the row_proc for graphed datasets" do
     @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
     @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}

data/spec/extensions/inflector_spec.rb

@@ -1,5 +1,8 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
+if defined?(ActiveSupport::Inflector)
+  skip_warn "inflector extension: active_support inflector loaded"
+else
 describe String do
   it "#camelize and #camelcase should transform the word to CamelCase" do
     "egg_and_hams".camelize.should == "EggAndHams"
@@ -179,3 +182,4 @@ describe 'Default inflections' do
     end
   end
 end
+end

data/spec/extensions/many_through_many_spec.rb

@@ -42,6 +42,25 @@ describe Sequel::Model, "many_through_many" do
     proc{@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], :album_tags]}.should raise_error(Sequel::Error)
   end
 
+  it "should allow only two arguments with the :through option" do
+    @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    n = @c1.load(:id => 1234)
+    a = n.tags_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags.should == [@c2.load(:id=>1)]
+  end
+
+  it "should be clonable" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.many_through_many :other_tags, :clone=>:tags
+    n = @c1.load(:id => 1234)
+    a = n.other_tags_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags.should == [@c2.load(:id=>1)]
+  end
+
   it "should use join tables given" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)

data/spec/extensions/nested_attributes_spec.rb

@@ -186,7 +186,7 @@ describe "NestedAttributes plugin" do
     ar.set(:first_album_attributes=>{:id=>10, :_delete=>'t'})
     @mods.should == []
     ar.save
-    @mods.should == [[:u, :albums, {:artist_id=>nil}, "(artist_id = 20)"], [:u, :artists, {:name=>"Ar"}, "(id = 20)"], [:d, :albums, "(id = 10)"]]
+    @mods.should == [[:u, :artists, {:name=>"Ar"}, "(id = 20)"], [:d, :albums, "(id = 10)"]]
   end
   
   it "should support destroying one_to_many objects" do
@@ -196,7 +196,7 @@ describe "NestedAttributes plugin" do
     ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
     @mods.should == []
     ar.save
-    @mods.should == [[:u, :albums, {:name=>"Al", :artist_id=>nil}, '(id = 10)'], [:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:d, :albums, '(id = 10)']]
+    @mods.should == [[:u, :artists, {:name=>"Ar"}, '(id = 20)'], [:d, :albums, '(id = 10)']]
   end
   
   it "should support destroying many_to_many objects" do

data/spec/extensions/optimistic_locking_spec.rb

@@ -20,6 +20,14 @@ describe "optimistic_locking plugin" do
         else
           0
         end
+      when /UPDATE people SET #{lv} = (\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
+        m = h[$2.to_i]
+        if m && m[:lock_version] == $3.to_i
+          m.merge!(:lock_version=>$1.to_i)
+          1
+        else
+          0
+        end
       else
         puts update_sql(opts)
       end
@@ -96,5 +104,22 @@ describe "optimistic_locking plugin" do
     p2 = c[1]
     p1.update(:name=>'Jim')
     proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
-  end 
+  end
+
+  specify "should increment the lock column when #modified! even if no columns are changed" do
+    p1 = @c[1]
+    p1.modified!
+    lv = p1.lock_version
+    p1.save_changes
+    p1.lock_version.should == lv + 1
+  end
+
+  specify "should not increment the lock column when the update fails" do
+    @c.dataset.meta_def(:update) { raise Exception }
+    p1 = @c[1]
+    p1.modified!
+    lv = p1.lock_version
+    proc{p1.save_changes}.should raise_error(Exception)
+    p1.lock_version.should == lv
+  end
 end

data/spec/extensions/xml_serializer_spec.rb

@@ -36,6 +36,16 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.from_xml(@album.to_xml).should == @album
   end
 
+  it "should round trip successfully with empty strings" do
+    artist = Artist.load(:id=>2, :name=>'')
+    Artist.from_xml(artist.to_xml).should == artist
+  end
+
+  it "should round trip successfully with nil values" do
+    artist = Artist.load(:id=>2, :name=>nil)
+    Artist.from_xml(artist.to_xml).should == artist
+  end
+
   it "should handle the :only option" do
     Artist.from_xml(@artist.to_xml(:only=>:name)).should == Artist.load(:name=>@artist.name)
     Album.from_xml(@album.to_xml(:only=>[:id, :name])).should == Album.load(:id=>@album.id, :name=>@album.name)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  hash: 71
+  hash: 67
   prerelease: false
   segments: 
   - 3
-  - 16
+  - 17
   - 0
-  version: 3.16.0
+  version: 3.17.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-01 00:00:00 -07:00
+date: 2010-11-05 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -80,6 +80,7 @@ extra_rdoc_files:
 - doc/release_notes/3.14.0.txt
 - doc/release_notes/3.15.0.txt
 - doc/release_notes/3.16.0.txt
+- doc/release_notes/3.17.0.txt
 files: 
 - COPYING
 - CHANGELOG
@@ -127,6 +128,7 @@ files:
 - doc/release_notes/3.14.0.txt
 - doc/release_notes/3.15.0.txt
 - doc/release_notes/3.16.0.txt
+- doc/release_notes/3.17.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc