sequel 4.2.0 → 4.3.0

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

@@ -31,6 +31,10 @@ module Sequel
 
         private
 
+        def disconnect_error?(exception, opts)
+          super || exception.message =~ /\AThe connection does not exist\./
+        end
+
         # Use JDBC connection's setAutoCommit to false to start transactions
         def begin_transaction(conn, opts=OPTS)
           set_transaction_isolation(conn, opts)

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

@@ -564,6 +564,7 @@ module Sequel
       BACKSLASH_RE = /\\/.freeze
       QUAD_BACKSLASH = "\\\\\\\\".freeze
       BLOB_START = "0x".freeze
+      EMPTY_BLOB = "''".freeze
       HSTAR = "H*".freeze
 
       include Sequel::Dataset::Replace
@@ -873,7 +874,11 @@ module Sequel
 
       # MySQL uses a preceding X for hex escaping strings
       def literal_blob_append(sql, v)
-        sql << BLOB_START << v.unpack(HSTAR).first
+        if v.empty?
+          sql << EMPTY_BLOB
+        else
+          sql << BLOB_START << v.unpack(HSTAR).first
+        end
       end
 
       # Use 0 for false on MySQL

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

@@ -966,6 +966,8 @@ module Sequel
         case db_type
         when /\Ainterval\z/io
           :interval
+        when /\Acitext\z/io
+          :string
         else
           super
         end

data/lib/sequel/ast_transformer.rb

@@ -66,6 +66,8 @@ module Sequel
         SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table), v(o.table_alias))
       when SQL::JoinClause
         SQL::JoinClause.new(o.join_type, v(o.table), v(o.table_alias))
+      when SQL::DelayedEvaluation
+        SQL::DelayedEvaluation.new(lambda{v(o.callable.call)})
       when SQL::Wrapper
         SQL::Wrapper.new(v(o.value))
       else

data/lib/sequel/extensions/error_sql.rb

@@ -0,0 +1,71 @@
+# The error_sql extension adds a DatabaseError#sql method
+# that you can use to get the sql that caused the error
+# to be raised.
+#
+#   begin
+#     DB.run "Invalid SQL"
+#   rescue => e
+#     puts e.sql # "Invalid SQL"
+#   end
+#
+# On some databases, the error message contains part or all
+# of the SQL used, but on other databases, none of the SQL
+# used is displayed in the error message, so it can be
+# difficult to track down what is causing the error without
+# using a logger.  This extension should hopefully make
+# debugging easier on databases that have bad error
+# messages.
+#
+# This extension may not work correctly in the following cases:
+#
+# * log_yield is not used when executing the query.
+# * The underlying exception is frozen or reused.
+# * The underlying exception doesn't correctly record instance
+#   variables set on it (seems to happen on JRuby when underlying
+#   exception objects are Java exceptions).
+#
+# To load the extension into the database:
+#
+#   DB.extension :error_sql
+
+module Sequel
+  class DatabaseError
+    # Get the SQL code that caused this error to be raised.
+    def sql
+      # We store the error SQL in the wrapped exception instead of the
+      # current exception, since when the error SQL is originally associated
+      # with the wrapped exception, the current exception doesn't exist.  It's
+      # possible to copy the error SQL into the current exception, but there
+      # doesn't seem to be a reason to do that.
+      wrapped_exception.instance_variable_get(:@sequel_error_sql) if wrapped_exception
+    end
+  end
+
+  module ErrorSQL
+    # Store the SQL related to the exception with the exception, so it
+    # is available for DatabaseError#sql later.
+    def log_exception(exception, message)
+      exception.instance_variable_set(:@sequel_error_sql, message)
+      super
+    end
+
+    # If there are no loggers for this database and an exception is raised
+    # store the SQL related to the exception with the exception, so it
+    # is available for DatabaseError#sql later.
+    def log_yield(sql, args=nil)
+      if @loggers.empty?
+        begin
+          yield
+        rescue => e
+          sql = "#{sql}; #{args.inspect}" if args
+          e.instance_variable_set(:@sequel_error_sql, sql)
+          raise
+        end
+      else
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:error_sql, ErrorSQL)
+end

data/lib/sequel/extensions/migration.rb

@@ -404,7 +404,6 @@ module Sequel
         self
       end
     end
-    private_class_method :migrator_class
     
     # The column to use to hold the migration version number for integer migrations or
     # filename for timestamp migrations (defaults to :version for integer migrations and

data/lib/sequel/extensions/pagination.rb

@@ -28,9 +28,11 @@ module Sequel
     end
       
     # Yields a paginated dataset for each page and returns the receiver. Does
-    # a count to find the total number of records for this dataset.
+    # a count to find the total number of records for this dataset. Returns
+    # an enumerator if no block is given.
     def each_page(page_size)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      return to_enum(:each_page, page_size) unless block_given?
       record_count = count
       total_pages = (record_count / page_size.to_f).ceil
       (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
@@ -47,7 +49,8 @@ module Sequel
       attr_accessor :page_size
 
       # The number of pages in the dataset before pagination, of which
-      # this paginated dataset is one.
+      # this paginated dataset is one.  Empty datasets are considered
+      # to have a single page.
       attr_accessor :page_count
 
       # The current page of the dataset, starting at 1 and not 0.
@@ -107,6 +110,7 @@ module Sequel
         @page_size = page_size
         @pagination_record_count = record_count
         @page_count = (record_count / page_size.to_f).ceil
+        @page_count = 1 if @page_count == 0
         self
       end
     end

data/lib/sequel/extensions/pg_array.rb

@@ -38,8 +38,9 @@
 #
 # If you are not using the native postgres adapter and are using array
 # types as model column values you probably should use the
-# pg_typecast_on_load plugin in the model, and set it to typecast the
-# array column(s) on load.
+# typecast_on_load plugin if the column values are returned as a
+# regular array, and the pg_typecast_on_load plugin if the column
+# values are returned as a string.
 #
 # This extension by default includes handlers for array types for
 # all scalar types that the native postgres adapter handles. It
@@ -109,6 +110,7 @@ module Sequel
 
       ARRAY = "ARRAY".freeze
       DOUBLE_COLON = '::'.freeze
+      EMPTY_ARRAY = "'{}'".freeze
       EMPTY_BRACKET = '[]'.freeze
       OPEN_BRACKET = '['.freeze
       CLOSE_BRACKET = ']'.freeze
@@ -517,9 +519,14 @@ module Sequel
       # If the receiver has a type, add a cast to the
       # database array type.
       def sql_literal_append(ds, sql)
-        sql << ARRAY
-        _literal_append(sql, ds, to_a)
-        if at = array_type
+        at = array_type
+        if empty? && at
+          sql << EMPTY_ARRAY
+        else
+          sql << ARRAY
+          _literal_append(sql, ds, to_a)
+        end
+        if at
           sql << DOUBLE_COLON << at.to_s << EMPTY_BRACKET
         end
       end

data/lib/sequel/extensions/pg_hstore.rb

@@ -75,9 +75,11 @@
 #
 #   DB.extension :pg_hstore
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the hstore column(s) on load.
+# If you are not using the native postgres adapter and are using hstore
+# types as model column values you probably should use the
+# typecast_on_load plugin if the column values are returned as a
+# hash, and the pg_typecast_on_load plugin if the column
+# values are returned as a string.
 #
 # This extension requires the delegate and strscan libraries.
 

data/lib/sequel/extensions/pg_inet.rb

@@ -10,9 +10,9 @@
 #
 #   DB.extension :pg_inet
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the inet/cidr column(s) on load.
+# If you are not using the native postgres adapter and are using inet/cidr
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use the inet[] or cidr[] types, load the pg_array extension before

data/lib/sequel/extensions/pg_interval.rb

@@ -15,9 +15,9 @@
 #
 #   DB.extension :pg_interval
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the interval type column(s) on load.
+# If you are not using the native postgres adapter and are using interval
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of interval types, load the pg_array extension before the

data/lib/sequel/extensions/pg_json.rb

@@ -42,9 +42,9 @@
 #
 #   DB.extension :pg_json
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the json column(s) on load.
+# If you are not using the native postgres adapter and are using json
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use the json[] type, load the pg_array extension before the

data/lib/sequel/extensions/pg_range.rb

@@ -45,9 +45,9 @@
 #
 #   DB.extension :pg_range
 #
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the range type column(s) on load.
+# If you are not using the native postgres adapter and are using range
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of range types, load the pg_array extension before the

data/lib/sequel/extensions/pg_row.rb

@@ -74,9 +74,9 @@
 #   DB.conversion_procs.select{|k,v| v.is_a?(Sequel::Postgres::PGRow::Parser) && \
 #     v.converter && (v.converter.name.nil? || v.converter.name == '') }.map{|k,v| v}
 # 
-# If you are not using the native postgres adapter, you probably
-# also want to use the pg_typecast_on_load plugin in the model, and
-# set it to typecast the composite type column(s) on load.
+# If you are not using the native postgres adapter and are using composite types
+# types as model column values you probably should use the
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension requires both the strscan and delegate libraries.
 

data/lib/sequel/extensions/server_block.rb

@@ -25,9 +25,17 @@
 #   end
 #   DB[:a].all # Uses default
 # 
-# Note this this extension assumes the following shard names should use the
-# server/shard passed to with_server: :default, nil, :read_only.  All other
-# shard names will cause the standard behavior to be used.
+# Note that if you pass the nil, :default, or :read_only server/shard
+# names to Dataset#server inside a with_server block, they will be
+# ignored and the server/shard given to with_server will be used:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB[:a].server(:shard2).all # Uses shard2
+#     DB[:a].server(nil).all # Uses shard1
+#     DB[:a].server(:default).all # Uses shard1
+#     DB[:a].server(:read_only).all # Uses shard1
+#   end
 
 module Sequel
   module ServerBlock

data/lib/sequel/plugins/rcte_tree.rb

@@ -102,13 +102,8 @@ module Sequel
         
         key = opts[:key] ||= :parent_id
         prkey = opts[:primary_key] ||= model.primary_key
-        
-        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
-        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
-        
         ka = opts[:key_alias] ||= :x_root_x
         t = opts[:cte_name] ||= :t
-        opts[:reciprocal] = nil
         c_all = if model.dataset.recursive_cte_requires_column_aliases?
           # Work around Oracle/ruby-oci8 bug that returns integers as BigDecimals in recursive queries.
           conv_bd = model.db.database_type == :oracle
@@ -119,13 +114,42 @@ module Sequel
           [SQL::ColumnAll.new(model.table_name)]
         end
         
+        bd_conv = lambda{|v| conv_bd && v.is_a?(BigDecimal) ? v.to_i : v}
+
+        key_array = Array(key)
+        prkey_array = Array(prkey)
+        if key.is_a?(Array)
+          key_conv = lambda{|m| key_array.map{|k| m[k]}}
+          key_present = lambda{|m| key_conv[m].all?}
+          prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
+          key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
+          ka_conv = lambda{|m| key_aliases.map{|k| m[k]}}
+          ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
+          descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
+          recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
+          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.values.delete(ka_)]}}
+        else
+          key_present = key_conv = lambda{|m| m[key]}
+          prkey_conv = lambda{|m| m[prkey]}
+          key_aliases = [ka]
+          ka_conv = lambda{|m| m[ka]}
+          ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
+          descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
+          recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
+          extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
+        end
+        
+        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
+        
+        opts[:reciprocal] = nil
         a = opts.merge(opts.fetch(:ancestors, {}))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
-          base_ds = model.filter(prkey=>send(key))
-          recursive_ds = model.join(t, key=>prkey)
+          base_ds = model.filter(prkey_array.zip(key_array.map{|k| send(k)}))
+          recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
@@ -140,14 +164,14 @@ module Sequel
         aal = Array(a[:after_load])
         aal << proc do |m, ancs|
           unless m.associations.has_key?(parent)
-            parent_map = {m[prkey]=>m}
+            parent_map = {prkey_conv[m]=>m}
             child_map = {}
-            child_map[m[key]] = m if m[key]
+            child_map[key_conv[m]] = m if key_present[m]
             m.associations[parent] = nil
             ancs.each do |obj|
               obj.associations[parent] = nil
-              parent_map[obj[prkey]] = obj
-              if ok = obj[key]
+              parent_map[prkey_conv[obj]] = obj
+              if ok = key_conv[obj]
                 child_map[ok] = obj
               end
             end
@@ -164,16 +188,16 @@ module Sequel
           parent_map = {}
           children_map = {}
           eo[:rows].each do |obj|
-            parent_map[obj[prkey]] = obj
-            (children_map[obj[key]] ||= []) << obj
+            parent_map[prkey_conv[obj]] = obj
+            (children_map[key_conv[obj]] ||= []) << obj
             obj.associations[ancestors] = []
             obj.associations[parent] = nil
           end
           r = model.association_reflection(ancestors)
           base_case = model.filter(prkey=>id_map.keys).
-           select(SQL::AliasedExpression.new(prkey, ka), *c_all)
-          recursive_case = model.join(t, key=>prkey).
-           select(SQL::QualifiedIdentifier.new(t, ka), *c_all)
+           select(*ancestor_base_case_columns)
+          recursive_case = model.join(t, key_array.zip(prkey_array)).
+           select(*recursive_case_columns)
           if c = r[:conditions]
             (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
@@ -184,26 +208,24 @@ module Sequel
            model.from(SQL::AliasedExpression.new(t, table_alias)).
             with_recursive(t, base_case,
              recursive_case,
-             :args=>(([ka] + col_aliases) if col_aliases)),
+             :args=>((key_aliases + col_aliases) if col_aliases)),
            r.select,
            eo[:associations], eo)
           elds = elds.select_append(ka) unless elds.opts[:select] == nil
           elds.all do |obj|
-            opk = obj[prkey]
+            opk = prkey_conv[obj]
             if parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
-                idm_obj.values[ka] = obj.values[ka]
+                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
                 obj = idm_obj
               end
             else
               obj.associations[parent] = nil
               parent_map[opk] = obj
-              (children_map[obj[key]] ||= []) << obj
+              (children_map[key_conv[obj]] ||= []) << obj
             end
             
-            kv = obj.values.delete(ka)
-            kv = kv.to_i if conv_bd && kv.is_a?(BigDecimal)
-            if roots = id_map[kv]
+            if roots = id_map[extract_key_alias[obj]]
               roots.each do |root|
                 root.associations[ancestors] << obj
               end
@@ -224,8 +246,8 @@ module Sequel
         d[:read_only] = true unless d.has_key?(:read_only)
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
-          base_ds = model.filter(key=>send(prkey))
-          recursive_ds = model.join(t, prkey=>key)
+          base_ds = model.filter(key_array.zip(prkey_array.map{|k| send(k)}))
+          recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
@@ -240,15 +262,15 @@ module Sequel
         dal = Array(d[:after_load])
         dal << proc do |m, descs|
           unless m.associations.has_key?(childrena)
-            parent_map = {m[prkey]=>m}
+            parent_map = {prkey_conv[m]=>m}
             children_map = {}
             m.associations[childrena] = []
             descs.each do |obj|
               obj.associations[childrena] = []
-              if opk = obj[prkey]
+              if opk = prkey_conv[obj]
                 parent_map[opk] = obj
               end
-              if ok = obj[key]
+              if ok = key_conv[obj]
                 (children_map[ok] ||= []) << obj
               end
             end
@@ -264,15 +286,15 @@ module Sequel
           parent_map = {}
           children_map = {}
           eo[:rows].each do |obj|
-            parent_map[obj[prkey]] = obj
+            parent_map[prkey_conv[obj]] = obj
             obj.associations[descendants] = []
             obj.associations[childrena] = []
           end
           r = model.association_reflection(descendants)
           base_case = model.filter(key=>id_map.keys).
-           select(SQL::AliasedExpression.new(key, ka), *c_all)
-          recursive_case = model.join(t, prkey=>key).
-           select(SQL::QualifiedIdentifier.new(t, ka), *c_all)
+           select(*descendant_base_case_columns)
+          recursive_case = model.join(t, prkey_array.zip(key_array)).
+           select(*recursive_case_columns)
           if c = r[:conditions]
             (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
@@ -288,7 +310,7 @@ module Sequel
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           elds = model.eager_loading_dataset(r,
            model.from(SQL::AliasedExpression.new(t, table_alias)).with_recursive(t, base_case, recursive_case,
-            :args=>(([ka] + col_aliases + (level ? [la] : [])) if col_aliases)),
+            :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases)),
            r.select,
            associations, eo)
           elds = elds.select_append(ka) unless elds.opts[:select] == nil
@@ -297,10 +319,10 @@ module Sequel
               no_cache = no_cache_level == obj.values.delete(la)
             end
             
-            opk = obj[prkey]
+            opk = prkey_conv[obj]
             if parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
-                idm_obj.values[ka] = obj.values[ka]
+                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
                 obj = idm_obj
               end
             else
@@ -308,13 +330,11 @@ module Sequel
               parent_map[opk] = obj
             end
             
-            kv = obj.values.delete(ka)
-            kv = kv.to_i if conv_bd && kv.is_a?(BigDecimal)
-            if root = id_map[kv].first
+            if root = id_map[extract_key_alias[obj]].first
               root.associations[descendants] << obj
             end
             
-            (children_map[obj[key]] ||= []) << obj
+            (children_map[key_conv[obj]] ||= []) << obj
           end
           children_map.each do |parent_id, objs|
             parent_map[parent_id].associations[childrena] = objs.uniq