sequel 4.35.0 → 4.36.0

data/lib/sequel/connection_pool/single.rb

@@ -12,7 +12,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   # Disconnect the connection from the database.
   def disconnect(opts=nil)
     return unless @conn
-    db.disconnect_connection(@conn)
+    disconnect_connection(@conn)
     @conn = nil
   end
   

data/lib/sequel/connection_pool/threaded.rb

@@ -75,10 +75,12 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database.
   def disconnect(opts=OPTS)
+    conns = nil
     sync do
-      @available_connections.each{|conn| db.disconnect_connection(conn)}
+      conns = @available_connections.dup
       @available_connections.clear
     end
+    conns.each{|conn| disconnect_connection(conn)}
   end
   
   # Chooses the first available connection, or if none are
@@ -106,7 +108,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     rescue Sequel::DatabaseDisconnectError
       oconn = conn
       conn = nil
-      db.disconnect_connection(oconn) if oconn
+      disconnect_connection(oconn) if oconn
       @allocated.delete(t)
       raise
     ensure
@@ -266,7 +268,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     conn = @allocated.delete(thread)
 
     if @connection_handling == :disconnect
-      db.disconnect_connection(conn)
+      disconnect_connection(conn)
     else
       checkin_connection(conn)
     end

data/lib/sequel/database/schema_methods.rb

@@ -888,7 +888,7 @@ module Sequel
       when Class
         type_literal_generic(column)
       when :Bignum
-        type_literal_generic_bignum(column)
+        type_literal_generic_bignum_symbol(column)
       else
         type_literal_specific(column)
       end
@@ -912,6 +912,12 @@ module Sequel
 
     # Sequel uses the bigint type by default for Bignums.
     def type_literal_generic_bignum(column)
+      Sequel::Deprecation.deprecate("Using the Bignum class as a generic type is deprecated and will be removed in Sequel 4.41.0, as the behavior will change in ruby 2.4. Switch to using the :Bignum symbol.")
+      type_literal_generic_bignum_symbol(column)
+    end
+
+    # Sequel uses the bigint type by default for :Bignum symbol.
+    def type_literal_generic_bignum_symbol(column)
       :bigint
     end
 

data/lib/sequel/dataset/sql.rb

@@ -570,6 +570,10 @@ module Sequel
       else
         sql << FUNCTION_DISTINCT if opts[:distinct]
         expression_list_append(sql, f.args)
+        if order = opts[:order]
+          sql << ORDER_BY
+          expression_list_append(sql, order)
+        end
       end
       sql << PAREN_CLOSE
 

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -102,7 +102,7 @@ module Sequel
         a = @allocated[thread]
         a.delete(server)
         @allocated.delete(thread) if a.empty?
-        db.disconnect_connection(conn)
+        disconnect_connection(conn)
       else  
         super
       end

data/lib/sequel/extensions/connection_expiration.rb

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+#
+# The connection_expiration extension modifies a database's
+# connection pool to validate that connections checked out
+# from the pool are not expired, before yielding them for
+# use.  If it detects an expired connection, it removes it
+# from the pool and tries the next available connection,
+# creating a new connection if no available connection is
+# unexpired.  Example of use:
+#
+#   DB.extension(:connection_expiration)
+#
+# Note that this extension only affects the default threaded
+# and the sharded threaded connection pool.  The single
+# threaded and sharded single threaded connection pools are
+# not affected.  As the only reason to use the single threaded
+# pools is for speed, and this extension makes the connection
+# pool slower, there's not much point in modifying this
+# extension to work with the single threaded pools.  The
+# threaded pools work fine even in single threaded code, so if
+# you are currently using a single threaded pool and want to
+# use this extension, switch to using a threaded pool.
+#
+# Related module: Sequel::ConnectionExpiration
+
+#
+module Sequel
+  module ConnectionExpiration
+    class Retry < Error; end
+
+    # The number of seconds that need to pass since
+    # connection creation before expiring a connection.
+    # Defaults to 14400 seconds (4 hours).
+    attr_accessor :connection_expiration_timeout
+
+    # Initialize the data structures used by this extension.
+    def self.extended(pool)
+      pool.instance_eval do
+        sync do
+          @connection_expiration_timestamps ||= {}
+          @connection_expiration_timeout ||= 14400
+        end
+      end
+    end
+
+    private
+
+    # Clean up expiration timestamps during disconnect.
+    def disconnect_connection(conn)
+      sync{@connection_expiration_timestamps.delete(conn)}
+      super
+    end
+
+    # Record the time the connection was created.
+    def make_new(*)
+      conn = super
+      @connection_expiration_timestamps[conn] = Time.now
+      conn
+    end
+
+    # When acquiring a connection, check if the connection is expired.
+    # If it is expired, disconnect the connection, and retry with a new
+    # connection.
+    def acquire(*a)
+      begin
+        if (conn = super) &&
+           (t = sync{@connection_expiration_timestamps[conn]}) &&
+           Time.now - t > @connection_expiration_timeout
+
+          if pool_type == :sharded_threaded
+            sync{allocated(a.last).delete(Thread.current)}
+          else
+            sync{@allocated.delete(Thread.current)}
+          end
+
+          disconnect_connection(conn)
+          raise Retry
+        end
+      rescue Retry
+        retry
+      end
+
+      conn
+    end
+  end
+
+  Database.register_extension(:connection_expiration){|db| db.pool.extend(ConnectionExpiration)}
+end
+

data/lib/sequel/extensions/connection_validator.rb

@@ -61,8 +61,10 @@ module Sequel
     # Initialize the data structures used by this extension.
     def self.extended(pool)
       pool.instance_eval do
-        @connection_timestamps ||= {}
-        @connection_validation_timeout = 3600
+        sync do
+          @connection_timestamps ||= {}
+          @connection_validation_timeout ||= 3600
+        end
       end
 
       # Make sure the valid connection SQL query is precached,
@@ -81,6 +83,12 @@ module Sequel
       conn
     end
 
+    # Clean up timestamps during disconnect.
+    def disconnect_connection(conn)
+      sync{@connection_timestamps.delete(conn)}
+      super
+    end
+
     # When acquiring a connection, if it has been
     # idle for longer than the connection validation timeout,
     # test the connection for validity.  If it is not valid,
@@ -98,7 +106,7 @@ module Sequel
             sync{@allocated.delete(Thread.current)}
           end
 
-          db.disconnect_connection(conn)
+          disconnect_connection(conn)
           raise Retry
         end
       rescue Retry

data/lib/sequel/extensions/constraint_validations.rb

@@ -78,6 +78,10 @@
 # includes [1, 2] :: CHECK column IN (1, 2)
 # includes 3..5 :: CHECK column >= 3 AND column <= 5
 # includes 3...5 :: CHECK column >= 3 AND column < 5
+# operator :>, 1 :: CHECK column > 1
+# operator :>=, 2 :: CHECK column >= 2
+# operator :<, "M" :: CHECK column < 'M'
+# operator :<=, 'K' :: CHECK column <= 'K'
 # unique :: UNIQUE (column)
 #
 # There are some additional API differences:
@@ -94,6 +98,8 @@
 #   patters are very simple, so many regexp patterns cannot be expressed by
 #   them, but only a couple databases (PostgreSQL and MySQL) support regexp
 #   patterns.
+# * The operator validation only supports >, >=, <, and <= operators, and the
+#   argument must be a string or an integer.
 # * When using the unique validation, column names cannot have embedded commas.
 #   For similar reasons, when using an includes validation with an array of
 #   strings, none of the strings in the array can have embedded commas.
@@ -131,6 +137,9 @@ module Sequel
   module ConstraintValidations
     # The default table name used for the validation metadata.
     DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
+    OPERATORS = {:< => :lt, :<= => :lte, :> => :gt, :>= => :gte}.freeze
+    REVERSE_OPERATOR_MAP = {:str_lt => :<, :str_lte => :<=, :str_gt => :>, :str_gte => :>=,
+                            :int_lt => :<, :int_lte => :<=, :int_gt => :>, :int_gte => :>=}.freeze
 
     # Set the default validation metadata table name if it has not already
     # been set.
@@ -164,6 +173,23 @@ module Sequel
         END
       end
 
+      # Create operator validation.  The op should be either +:>+, +:>=+, +:<+, or +:<=+, and
+      # the arg should be either a string or an integer.
+      def operator(op, arg, columns, opts=OPTS)
+        raise Error, "invalid operator (#{op}) used when creating operator validation" unless suffix = OPERATORS[op]
+
+        prefix = case arg
+        when String
+          "str"
+        when Integer
+          "int"
+        else
+          raise Error, "invalid argument (#{arg.inspect}) used when creating operator validation"
+        end
+
+        @generator.validation({:type=>:"#{prefix}_#{suffix}", :columns=>Array(columns), :arg=>arg}.merge!(opts))
+      end
+
       # Given the name of a constraint, drop that constraint from the database,
       # and remove the related validation metadata.
       def drop(constraint)
@@ -349,6 +375,8 @@ module Sequel
           generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) >= arg}))
         when :max_length
           generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) <= arg}))
+        when *REVERSE_OPERATOR_MAP.keys
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.identifier(c).send(REVERSE_OPERATOR_MAP[validation_type], arg)}))
         when :length_range
           op = arg.exclude_end? ? :< : :<=
           generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).send(op, arg.end)}))

data/lib/sequel/extensions/string_agg.rb

@@ -0,0 +1,178 @@
+# frozen-string-literal: true
+#
+# The string_agg extension adds the ability to perform database-independent
+# aggregate string concatentation.  For example, with a table like:
+#
+#   c1 | c2
+#   ---+---
+#   a  | 1
+#   a  | 2
+#   a  | 3
+#   b  | 4
+#
+# You can return a result set like:
+#
+#   c1 | c2s
+#   ---+---
+#   a  | 1,2,3
+#   b  | 4
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :string_agg
+#
+# Then you can use the Sequel.string_agg method to return a Sequel
+# expression:
+#
+#   sa = Sequel.string_agg(:column_name)
+#   # or:
+#   sa = Sequel.string_agg(:column_name, '-') # custom separator
+#
+# You can specify the order in which the concatention happens by
+# calling +order+ on the expression:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column)
+#
+# Additionally, if you want to have the concatenation only operate
+# on distinct values, you can call distinct:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column).distinct
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].
+#     select_group(:c1).
+#     select_append(Sequel.string_agg(:c2))
+#
+# This extension currenly supports the following databases:
+#
+# * PostgreSQL 9+
+# * SQLAnywhere 12+
+# * Oracle 11g+ (except distinct)
+# * DB2 9.7+ (except distinct)
+# * MySQL
+# * HSQLDB
+# * CUBRID
+# * H2
+#
+# Related module: Sequel::SQL::StringAgg
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a StringAgg expression for an aggregate string concatentation.
+      def string_agg(*a)
+        StringAgg.new(*a)
+      end
+    end
+
+    # The StringAgg class represents an aggregate string concatentation.
+    class StringAgg < GenericExpression
+      include StringMethods
+      include StringConcatenationMethods
+      include InequalityMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+      include PatternMatchMethods
+      include SubscriptMethods
+
+      # These methods are added to datasets using the string_agg
+      # extension, for the purposes of correctly literalizing StringAgg
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the StringAgg expression to the SQL query.
+        def string_agg_sql_append(sql, sa)
+          if defined?(super)
+            return super
+          end
+
+          expr = sa.expr
+          separator = sa.separator || ","
+          order = sa.order_expr
+          distinct = sa.is_distinct?
+
+          case db_type = db.database_type
+          when :postgres, :sqlanywhere
+            f = Function.new(db_type == :postgres ? :string_agg : :list, expr, separator)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
+          when :mysql, :hsqldb, :cubrid, :h2
+            sql << "GROUP_CONCAT("
+            if distinct
+              sql << "DISTINCT "
+            end
+            literal_append(sql, expr)
+            if order
+              sql << " ORDER BY "
+              expression_list_append(sql, order)
+            end
+            sql << " SEPARATOR "
+            literal_append(sql, separator)
+            sql << ")"
+          when :oracle, :db2
+            if distinct
+              raise Error, "string_agg with distinct is not implemented on #{db.database_type}"
+            end
+            literal_append(sql, Function.new(:listagg, expr, separator))
+            if order
+              sql << " WITHIN GROUP (ORDER BY "
+              expression_list_append(sql, order)
+              sql << ")"
+            else
+              sql << " WITHIN GROUP (ORDER BY 1)"
+            end
+          else
+            raise Error, "string_agg is not implemented on #{db.database_type}"
+          end
+        end
+      end
+
+      # The string expression for each row that will concatenated to the output.
+      attr_reader :expr
+
+      # The separator between each string expression.
+      attr_reader :separator
+
+      # The expression that the aggregation is ordered by.
+      attr_reader :order_expr
+
+      # Set the expression and separator
+      def initialize(expr, separator=nil)
+        @expr = expr
+        @separator = separator
+      end
+
+      # Whether the current expression uses distinct expressions 
+      def is_distinct?
+        @distinct == true
+      end
+
+      # Return a modified StringAgg that uses distinct expressions
+      def distinct
+        sa = dup
+        sa.instance_variable_set(:@distinct, true)
+        sa
+      end
+
+      # Return a modified StringAgg with the given order
+      def order(*o)
+        sa = dup
+        sa.instance_variable_set(:@order_expr, o.empty? ? nil : o)
+        sa
+      end
+
+      to_s_method :string_agg_sql
+    end
+  end
+
+  Dataset.register_extension(:string_agg, SQL::StringAgg::DatasetMethods)
+end
+