sequel 3.42.0 → 3.43.0

data/lib/sequel/extensions/date_arithmetic.rb

@@ -0,0 +1,194 @@
+# The date_arithmetic extension adds the ability to perform database-independent
+# addition/substraction of intervals to/from dates and timestamps.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :date_arithmetic
+#
+# Then you can use the Sequel.date_add and Sequel.date_sub methods
+# to return Sequel expressions:
+#
+#   add = Sequel.date_add(:date_column, :years=>1, :months=>2, :days=>3)
+#   sub = Sequel.date_sub(:date_column, :hours=>1, :minutes=>2, :seconds=>3)
+#
+# In addition to specifying the interval as a hash, there is also
+# support for specifying the interval as an ActiveSupport::Duration
+# object:
+#
+#   require 'active_support/all'
+#   add = Sequel.date_add(:date_column, 1.years + 2.months + 3.days)
+#   sub = Sequel.date_sub(:date_column, 1.hours + 2.minutes + 3.seconds)
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
+
+module Sequel
+  module SQL
+    module Builders
+      # Return a DateAdd expression, adding an interval to the date/timestamp expr.
+      def date_add(expr, interval)
+        DateAdd.new(expr, interval)
+      end
+
+      # Return a DateAdd expression, adding the negative of the interval to
+      # the date/timestamp expr.
+      def date_sub(expr, interval)
+        interval = if interval.is_a?(Hash)
+          h = {}
+          interval.each{|k,v| h[k] = -v unless v.nil?}
+          h
+        else
+          -interval
+        end
+        DateAdd.new(expr, interval)
+      end
+    end
+
+    # The DateAdd class represents the addition of an interval to a
+    # date/timestamp expression.
+    class DateAdd < GenericExpression
+      # These methods are added to datasets using the date_arithmetic
+      # extension, for the purposes of correctly literalizing DateAdd
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
+        DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
+        MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
+        H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
+        DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
+        ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map{|s| s.freeze}).freeze
+        DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
+
+        # Return an SQL fragment for the literalized version of the
+        # DateAdd expression.
+        def date_add_sql(da)
+          sql = ''
+          date_arith_sql_append(sql, da)
+          sql
+        end
+
+        # Append the SQL fragment for the DateAdd expression to the SQL query.
+        def date_add_sql_append(sql, da)
+          h = da.interval
+          expr = da.expr
+          cast = case db_type = db.database_type
+          when :postgres
+            interval = ""
+            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+              interval << "#{value} #{sql_unit} "
+            end
+            if interval.empty?
+              return literal_append(sql, Sequel.cast(expr, Time))
+            else
+              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, Time), Sequel.cast(interval, :interval)])
+            end
+          when :sqlite
+            args = [expr]
+            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+              args << "#{value} #{sql_unit}"
+            end
+            return _function_sql_append(sql, :datetime, args)
+          when :mysql, :hsqldb, :cubrid
+            if db_type == :hsqldb
+              # HSQLDB requires 2.2.9+ for the DATE_ADD function
+              expr = Sequel.cast(expr, Time)
+            end
+            each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.function(:DATE_ADD, expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
+            end
+          when :mssql, :h2, :access
+            units = case db_type
+            when :mssql
+              MSSQL_DURATION_UNITS
+            when :h2
+              H2_DURATION_UNITS
+            when :access
+              ACCESS_DURATION_UNITS
+            end
+            each_valid_interval_unit(h, units) do |value, sql_unit|
+              expr = Sequel.function(:DATEADD, sql_unit, value, expr)
+            end
+          when :derby
+            if expr.is_a?(Date) && !expr.is_a?(DateTime)
+              # Work around for https://issues.apache.org/jira/browse/DERBY-896
+              expr = Sequel.cast_string(expr) + ' 00:00:00'
+            end
+            each_valid_interval_unit(h, DERBY_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.lit(["{fn timestampadd(#{sql_unit}, ", ", timestamp(", "))}"], value, expr)
+            end
+          when :oracle
+            each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.+(expr, Sequel.lit(["INTERVAL ", " "], value.to_s, sql_unit))
+            end
+          when :db2
+            expr = Sequel.cast(expr, Time)
+            each_valid_interval_unit(h, DB2_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.+(expr, Sequel.lit(["", " "], value, sql_unit))
+            end
+            false
+          else
+            raise NotImplemented, "date arithmetic is not implemented on #{db.database_type}"
+          end
+
+          if cast
+            expr = Sequel.cast(expr, Time)
+          end
+
+          literal_append(sql, expr)
+        end
+
+        private
+
+        # Yield the value in the interval for each of the units
+        # present in the interval, along with the SQL fragment
+        # representing the unit name.  Returns false if any
+        # values were yielded, true otherwise
+        def each_valid_interval_unit(interval, units)
+          cast = true
+          units.each do |unit, sql_unit|
+            if (value = interval[unit]) && value != 0
+              cast = false
+              yield value, sql_unit
+            end
+          end
+          cast
+        end
+      end
+
+      # The expression that the interval is being added to.
+      attr_reader :expr
+
+      # The interval added to the expression, as a hash with
+      # symbol keys.
+      attr_reader :interval
+
+      # Supports two types of intervals:
+      # Hash :: Used directly, but values cannot be plain strings.
+      # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
+      def initialize(expr, interval)
+        @expr = expr
+        @interval = if interval.is_a?(Hash)
+          interval.each_value do |v|
+             # Attempt to prevent SQL injection by users who pass untrusted strings
+             # as interval values. 
+             if v.is_a?(String) && !v.is_a?(LiteralString)
+               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
+             end
+          end
+          interval
+        else
+          h = Hash.new(0)
+          interval.parts.each{|unit, value| h[unit] += value}
+          {}.merge(h)
+        end
+      end
+
+      to_s_method :date_add_sql
+    end
+  end
+
+  Dataset.register_extension(:date_arithmetic, SQL::DateAdd::DatasetMethods)
+end

data/lib/sequel/extensions/meta_def.rb

@@ -0,0 +1,30 @@
+# The meta_def extension is designed for backwards compatibility
+# with older Sequel code that uses the meta_def method on
+# Database, Dataset, and Model classes and/or instances.  It is
+# not recommended for usage in new code.  To load this extension:
+#
+#   Sequel.extension :meta_def
+
+module Sequel
+  # Contains meta_def method for adding methods to objects via blocks.
+  # Only recommended for backwards compatibility with existing code.
+  module Metaprogramming
+    # Define a method with the given name and block body on the receiver.
+    #
+    #   ds = DB[:items]
+    #   ds.meta_def(:x){42}
+    #   ds.x # => 42
+    def meta_def(name, &block)
+      (class << self; self end).send(:define_method, name, &block)
+    end
+  end
+
+  Database.extend Metaprogramming
+  Database.send(:include, Metaprogramming)
+  Dataset.extend Metaprogramming
+  Dataset.send(:include, Metaprogramming)
+  if defined?(Model)
+    Model.extend Metaprogramming
+    Model.send(:include, Metaprogramming)
+  end
+end

data/lib/sequel/extensions/migration.rb

@@ -61,6 +61,11 @@ module Sequel
       @db.send(method_sym, *args, &block)
     end
 
+    # This object responds to all methods the database responds to.
+    def respond_to_missing?(meth, include_private)
+      @db.respond_to?(meth, include_private)
+    end
+
     # The default up action does nothing
     def up
     end

data/lib/sequel/extensions/null_dataset.rb

@@ -24,6 +24,8 @@
 # dataset and the dataset doesn't have an already cached
 # version of the columns, it will create a new dataset with
 # the same options to get the columns.
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
 
 module Sequel
   class Dataset

data/lib/sequel/extensions/pagination.rb

@@ -5,6 +5,8 @@
 # To load the extension:
 #
 #   Sequel.extension :pagination
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
 
 module Sequel
   class Dataset

data/lib/sequel/extensions/pg_array.rb

@@ -18,7 +18,8 @@
 #   Sequel.pg_array(array)
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also use Array#pg_array:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Array#pg_array:
 #
 #   array.pg_array
 #
@@ -537,3 +538,13 @@ if Sequel.core_extensions?
     end
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Array do
+      def pg_array(type=nil)
+        Sequel::Postgres::PGArray.new(self, type)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/pg_array_ops.rb

@@ -20,7 +20,8 @@
 #   ia = Sequel.expr(:int_array_column).pg_array
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also call Symbol#pg_array:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Symbol#pg_array:
 #
 #   ia = :int_array_column.pg_array
 #
@@ -261,3 +262,11 @@ if Sequel.core_extensions?
     include Sequel::Postgres::ArrayOpMethods
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::ArrayOpMethods
+    end
+  end
+end

data/lib/sequel/extensions/pg_hstore.rb

@@ -20,7 +20,8 @@
 #   Sequel.hstore(hash)
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also use Hash#hstore:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Hash#hstore:
 # 
 #   hash.hstore
 #
@@ -332,3 +333,13 @@ if Sequel.core_extensions?
     end
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Hash do
+      def hstore
+        Sequel::Postgres::HStore.new(self)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -21,7 +21,8 @@
 #   h = Sequel.expr(:hstore_column).hstore
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also call Symbol#hstore:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Symbol#hstore:
 #
 #   h = :hstore_column.hstore
 #
@@ -291,3 +292,11 @@ if Sequel.core_extensions?
     include Sequel::Postgres::HStoreOpMethods
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::HStoreOpMethods
+    end
+  end
+end

data/lib/sequel/extensions/pg_json.rb

@@ -24,7 +24,8 @@
 #   Sequel.pg_json(hash)
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also use Array#pg_json and Hash#pg_json:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Array#pg_json and Hash#pg_json:
 #
 #   array.pg_json
 #   hash.pg_json
@@ -210,3 +211,19 @@ if Sequel.core_extensions?
     end
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Array do
+      def pg_json
+        Sequel::Postgres::JSONArray.new(self)
+      end
+    end
+
+    refine Hash do
+      def pg_json
+        Sequel::Postgres::JSONHash.new(self)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/pg_range.rb

@@ -25,7 +25,8 @@
 #   Sequel.pg_range(range)
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also use Range#pg_range:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Range#pg_range:
 #
 #   range.pg_range 
 #
@@ -511,3 +512,13 @@ if Sequel.core_extensions?
     end
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Range do
+      def pg_range(db_type=nil)
+        Sequel::Postgres::PGRange.from_range(self, db_type)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/pg_range_ops.rb

@@ -20,7 +20,8 @@
 #   r = Sequel.expr(:range).pg_range
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also call Symbol#pg_range:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Symbol#pg_range:
 #
 #   r = :range.pg_range
 #
@@ -148,3 +149,11 @@ if Sequel.core_extensions?
     include Sequel::Postgres::RangeOpMethods
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::RangeOpMethods
+    end
+  end
+end

data/lib/sequel/extensions/pg_row.rb

@@ -28,7 +28,8 @@
 #   Sequel.pg_row(array)
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also use Array#pg_row:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Array#pg_row:
 #
 #   array.pg_row
 #
@@ -460,7 +461,12 @@ module Sequel
           @conversion_procs[parser.oid] = parser
 
           if defined?(PGArray) && PGArray.respond_to?(:register) && array_oid && array_oid > 0
-            PGArray.register(db_type, :oid=>array_oid, :converter=>parser, :type_procs=>@conversion_procs, :scalar_typecast=>schema_type_symbol)
+            array_type_name = if type_schema
+              "#{type_schema}.#{type_name}"
+            else
+              type_name
+            end
+            PGArray.register(array_type_name, :oid=>array_oid, :converter=>parser, :type_procs=>@conversion_procs, :scalar_typecast=>schema_type_symbol)
           end
 
           @row_types[db_type] = opts.merge(:parser=>parser)
@@ -574,3 +580,13 @@ if Sequel.core_extensions?
     end
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Array do
+      def pg_row
+        Sequel::Postgres::PGRow::ArrayRow.new(self)
+      end
+    end
+  end
+end