sequel 4.48.0 → 4.49.0

data/lib/sequel/adapters/mysql2.rb

@@ -260,7 +260,7 @@ module Sequel
 
       # Use streaming to implement paging if Mysql2 supports it.
       def paged_each(opts=OPTS, &block)
-        if STREAMING_SUPPORTED
+        if STREAMING_SUPPORTED && opts[:stream] != false
           stream.each(&block)
         else
           super

data/lib/sequel/adapters/postgres.rb

@@ -218,7 +218,8 @@ module Sequel
             :user => opts[:user],
             :password => opts[:password],
             :connect_timeout => opts[:connect_timeout] || 20,
-            :sslmode => opts[:sslmode]
+            :sslmode => opts[:sslmode],
+            :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
           conn = Adapter.connect(connection_params)

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

@@ -841,7 +841,10 @@ module Sequel
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
       def join_table(type, table, expr=nil, opts=OPTS, &block)
-        type = :inner if (type == :cross) && !expr.nil?
+        if (type == :cross) && !expr.nil?
+           Sequel::Deprecation.deprecate(":cross join type with conditions being converted to INNER JOIN on MySQL", "Use :inner join type instead")
+          type = :inner
+        end
         raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN or NATURAL FULL JOIN") if type == :full_outer || type == :natural_full
         super(type, table, expr, opts, &block)
       end

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

@@ -348,7 +348,7 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :SKIP_LOCKED)
 
       include(Module.new do
-        Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order lock')
+        Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order limit lock')
       end)
 
       def complex_expression_sql_append(sql, op, args)
@@ -421,7 +421,10 @@ module Sequel
       # Handle LIMIT by using a unlimited subselect filtered with ROWNUM.
       def select_sql
         return super if @opts[:sql]
-        if o = @opts[:offset]
+        return super if supports_fetch_next_rows?
+
+        o = @opts[:offset]
+        if o && o != 0
           columns = clone(:append_sql=>String.new, :placeholder_literal_null=>true).columns
           dsa1 = dataset_alias(1)
           rn = row_number_column
@@ -437,7 +440,7 @@ module Sequel
           subselect_sql_append(sql, ds)
           sql
         elsif limit = @opts[:limit]
-          ds = clone(:limit=>nil)
+          ds = unlimited
           # Lock doesn't work in subselects, so don't use a subselect when locking.
           # Don't use a subselect if custom SQL is used, as it breaks somethings.
           ds = ds.from_self unless @opts[:lock]
@@ -449,6 +452,21 @@ module Sequel
         end
       end
 
+      def select_limit_sql(sql)
+        return unless supports_fetch_next_rows?
+
+        if offset = @opts[:offset]
+          sql << " OFFSET "
+          literal_append(sql, offset)
+          sql << " ROWS"
+        end
+
+        if limit = @opts[:limit]
+          sql << " FETCH NEXT "
+          literal_append(sql, limit)
+          sql << " ROWS ONLY"
+        end
+      end
       # Oracle requires recursive CTEs to have column aliases.
       def recursive_cte_requires_column_aliases?
         true
@@ -463,6 +481,11 @@ module Sequel
         false
       end
 
+      # Oracle supports FETCH NEXT ROWS since 12c
+      def supports_fetch_next_rows?
+        server_version >= 12000000 && !(@opts[:lock] || @opts[:skip_locked])
+      end
+
       # Oracle supports GROUP BY CUBE
       def supports_group_cube?
         true

data/lib/sequel/connection_pool.rb

@@ -29,12 +29,15 @@ class Sequel::ConnectionPool
 
   # The default server to use
   DEFAULT_SERVER = :default
+  Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SERVER)
   
   # A map of [single threaded, sharded] values to symbols or ConnectionPool subclasses.
   CONNECTION_POOL_MAP = {[true, false] => :single, 
     [true, true] => :sharded_single,
     [false, false] => :threaded,
     [false, true] => :sharded_threaded}
+  CONNECTION_POOL__MAP = CONNECTION_POOL_MAP
+  Sequel::Deprecation.deprecate_constant(self, :CONNECTION_POOL_MAP)
   
   # Class methods used to return an appropriate pool subclass, separated
   # into a module for easier overridding by extensions.
@@ -57,7 +60,10 @@ class Sequel::ConnectionPool
     
     # Return a connection pool class based on the given options.
     def connection_pool_class(opts)
-      CONNECTION_POOL_MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
+      if opts[:pool_class] && !opts[:pool_class].is_a?(Class) && ![:threaded, :single, :sharded_threaded, :sharded_single].include?(opts[:pool_class])
+        Sequel::Deprecation.deprecate("Using an unrecognized :pool_class option", "Use a class for the :pool_class option to select a custom pool class, or one of the following symbols for one of the default pool classes: :threaded, :single, :sharded_threaded, :sharded_single")
+      end
+      CONNECTION_POOL__MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL__MAP[[!!opts[:single_threaded], !!opts[:servers]]]
     end
   end
   extend ClassMethods
@@ -89,12 +95,13 @@ class Sequel::ConnectionPool
   
   # Alias for +size+, not aliased directly for ease of subclass implementation
   def created_count(*args)
+    Sequel::Deprecation.deprecate("Sequel::ConnectionPool#created_count", "Use #size instead")
     size(*args)
   end
   
   # An array of symbols for all shards/servers, which is a single <tt>:default</tt> by default.
   def servers
-    [DEFAULT_SERVER]
+    [:default]
   end
   
   private

data/lib/sequel/connection_pool/sharded_single.rb

@@ -111,5 +111,5 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     servers.each{|s| hold(s){}}
   end
   
-  CONNECTION_POOL_MAP[[true, true]] = self
+  CONNECTION_POOL__MAP[[true, true]] = self
 end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -353,5 +353,5 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     disconnect_connection(conn)
   end
   
-  CONNECTION_POOL_MAP[[false, true]] = self
+  CONNECTION_POOL__MAP[[false, true]] = self
 end

data/lib/sequel/connection_pool/single.rb

@@ -26,7 +26,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   def hold(server=nil)
     begin
       unless c = @conn.first
-        @conn.replace([c = make_new(DEFAULT_SERVER)])
+        @conn.replace([c = make_new(:default)])
       end
       yield c
     rescue Sequel::DatabaseDisconnectError, *@error_classes => e
@@ -57,5 +57,5 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
     hold{}
   end
 
-  CONNECTION_POOL_MAP[[true, false]] = self
+  CONNECTION_POOL__MAP[[true, false]] = self
 end

data/lib/sequel/connection_pool/threaded.rb

@@ -198,7 +198,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # available, tries to create a new connection. The calling code should already
   # have the mutex before calling this.
   def available
-    next_available || make_new(DEFAULT_SERVER)
+    next_available || make_new(:default)
   end
 
   # Return a connection to the pool of available connections, returns the connection.
@@ -282,5 +282,5 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @mutex.synchronize{yield}
   end
   
-  CONNECTION_POOL_MAP[[false, false]] = self
+  CONNECTION_POOL__MAP[[false, false]] = self
 end

data/lib/sequel/database/connecting.rb

@@ -220,14 +220,14 @@ module Sequel
     
     # Disconnects all available connections from the connection pool.  Any
     # connections currently in use will not be disconnected. Options:
-    # :servers :: Should be a symbol specifing the server to disconnect from,
+    # :server :: Should be a symbol specifing the server to disconnect from,
     #             or an array of symbols to specify multiple servers.
     #
     # Example:
     #
     #   DB.disconnect # All servers
-    #   DB.disconnect(:servers=>:server1) # Single server
-    #   DB.disconnect(:servers=>[:server1, :server2]) # Multiple servers
+    #   DB.disconnect(:server=>:server1) # Single server
+    #   DB.disconnect(:server=>[:server1, :server2]) # Multiple servers
     def disconnect(opts = OPTS)
       pool.disconnect(opts)
     end

data/lib/sequel/database/dataset_defaults.rb

@@ -69,6 +69,9 @@ module Sequel
     # This allows you to override any of the dataset methods even if they are
     # defined directly on the dataset class that this Database object uses.
     #
+    # If a block is given, a Dataset::DatasetModule instance is created, allowing
+    # for the easy creation of named dataset methods that will do caching.
+    #
     # Examples:
     #
     #   # Introspec columns for all of DB's datasets
@@ -82,9 +85,19 @@ module Sequel
     #       super
     #     end
     #   end
+    #
+    #   # Add some named dataset methods
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
-      mod = Module.new(&block) if block
+      mod = Dataset::DatasetModule.new(&block) if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]
        @dataset_class = Class.new(@dataset_class)

data/lib/sequel/dataset.rb

@@ -42,5 +42,5 @@ module Sequel
     include SQL::StringMethods
   end
   
-  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer", 'dataset')
+  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer dataset_module", 'dataset')
 end

data/lib/sequel/dataset/actions.rb

@@ -15,6 +15,7 @@ module Sequel
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
+      where_all where_each where_single_value
     METHS
     # SEQUEL5: Remove interval, range
 
@@ -917,6 +918,52 @@ module Sequel
       end
     end
 
+    # Return an array of all rows matching the given filter condition, also
+    # yielding each row to the given block.  Basically the same as where(cond).all(&block),
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].where_all(:id=>[1,2,3])
+    #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
+    def where_all(cond, &block)
+      if loader = _where_loader
+        loader.all(filter_expr(cond), &block)
+      else
+        where(cond).all(&block)
+      end
+    end
+
+    # Iterate over all rows matching the given filter condition, 
+    # yielding each row to the given block.  Basically the same as where(cond).each(&block),
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].where_each(:id=>[1,2,3]){|row| p row}
+    #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
+    def where_each(cond, &block)
+      if loader = _where_loader
+        loader.each(filter_expr(cond), &block)
+      else
+        where(cond).each(&block)
+      end
+    end
+
+    # Filter the datasets using the given filter condition, then return a single value.
+    # This assumes that the dataset has already been setup to limit the selection to
+    # a single column.  Basically the same as where(cond).single_value,
+    # except it can be optimized to not create an intermediate dataset.
+    #
+    #   DB[:table].select(:name).where_single_value(:id=>1)
+    #   # SELECT name FROM table WHERE (id = 1) LIMIT 1
+    def where_single_value(cond)
+      if loader = cached_placeholder_literalizer(:_where_single_value_loader) do |pl|
+          single_value_ds.where(pl.arg)
+        end
+
+        loader.get(filter_expr(cond))
+      else
+        where(cond).single_value
+      end
+    end
+
     # Run the given SQL and return an array of all rows.  If a block is given,
     # each row is yielded to the block after all rows are loaded. See with_sql_each.
     def with_sql_all(sql, &block)
@@ -1044,6 +1091,13 @@ module Sequel
       cached_dataset(:_single_record_ds){clone(:limit=>1)}
     end
 
+    # Loader used for where_all and where_each.
+    def _where_loader
+      cached_placeholder_literalizer(:_where_loader) do |pl|
+        where(pl.arg)
+      end
+    end
+
     # Automatically alias the given expression if it does not have an identifiable alias.
     def auto_alias_expression(v)
       case v

data/lib/sequel/dataset/dataset_module.rb

@@ -0,0 +1,58 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This Module subclass is used by Database#extend_datasets
+    # and Dataset#with_extend to add dataset methods to classes.
+    # It adds some helper methods inside the module that can define
+    # named methods on the dataset instances which do specific actions.
+    # For example:
+    #
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
+    class DatasetModule < ::Module
+      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
+        define_method(meth) do |name, *args, &block|
+          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
+            define_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths = (<<-METHS).split.map(&:to_sym)
+        distinct grep group group_and_count group_append 
+        limit offset order order_append order_prepend 
+        select select_all select_append select_group server
+      METHS
+
+      # Define a method in the module
+      def self.def_dataset_caching_method(mod, meth)
+        mod.send(:define_method, meth) do |name, *args, &block|
+          if block
+            define_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths.each do |meth|
+        def_dataset_caching_method(self, meth)
+      end
+    end
+  end
+end

data/lib/sequel/dataset/query.rb

@@ -1087,12 +1087,12 @@ module Sequel
       # Return a clone of the dataset extended with the given modules.
       # Note that like Object#extend, when multiple modules are provided
       # as arguments the cloned dataset is extended with the modules in reverse
-      # order.  If a block is provided, a module is created using the block and
+      # order.  If a block is provided, a DatasetModule is created using the block and
       # the clone is extended with that module after any modules given as arguments.
       def with_extend(*mods, &block)
         c = _clone(:freeze=>false)
         c.extend(*mods) unless mods.empty?
-        c.extend(Module.new(&block)) if block
+        c.extend(DatasetModule.new(&block)) if block
         c.freeze if frozen? # SEQUEL5: Remove if frozen?
         c
       end
@@ -1101,7 +1101,7 @@ module Sequel
       def with_extend(*mods, &block) # :nodoc:
         c = clone
         c.extend(*mods) unless mods.empty?
-        c.extend(Module.new(&block)) if block
+        c.extend(DatasetModule.new(&block)) if block
         c
       end
       # :nocov:

data/lib/sequel/exceptions.rb

@@ -7,6 +7,14 @@ module Sequel
     # If this exception wraps an underlying exception, the underlying
     # exception is held here.
     attr_accessor :wrapped_exception
+
+    if RUBY_VERSION >= '2.1'
+      # Returned the wrapped exception if one exists, otherwise use
+      # ruby's default behavior.
+      def cause
+        wrapped_exception || super
+      end
+    end
   end  
     
   (

data/lib/sequel/extensions/_model_pg_row.rb

@@ -5,14 +5,17 @@ module Sequel
     module PgRow
       module DatabaseMethods
         ESCAPE_RE = /("|\\)/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
         ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
         COMMA = ','
+        Sequel::Deprecation.deprecate_constant(self, :COMMA)
 
         # Handle Sequel::Model instances in bound variables.
         def bound_variable_arg(arg, conn)
           case arg
           when Sequel::Model
-            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',')})"
           else
             super
           end
@@ -34,7 +37,7 @@ module Sequel
         def bound_variable_array(arg)
           case arg
           when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
           else
             super
           end

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -32,7 +32,7 @@ module Sequel
       # Return an instance of Sequel.datetime_class that will be literalized
       # as CURRENT_TIMESTAMP.
       def current_datetime
-        MAP.fetch(Sequel.datetime_class).now
+        (Sequel.datetime_class == ::Time ? Time : DateTime).now
       end
 
       private
@@ -56,6 +56,7 @@ module Sequel
 
     # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
     MAP = {::Time=>Time, ::DateTime=>DateTime}
+    Sequel::Deprecation.deprecate_constant(self, :MAP)
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)