sequel 3.21.0 → 3.28.0

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -0,0 +1,82 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_safe plugin modifies the model to reduce the number of
+    # prepared statements that can be created, by setting as many columns as possible
+    # before creating, and by changing +save_changes+ to save all columns instead of
+    # just the changed ones.
+    #
+    # This plugin depends on the +prepared_statements+ plugin.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses more safe when using prepared statements (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_safe
+    #
+    #   # Make the Album class more safe when using prepared statements
+    #   Album.plugin :prepared_statements_safe
+    module PreparedStatementsSafe
+      # Depend on the prepared_statements plugin
+      def self.apply(model)
+        model.plugin(:prepared_statements)
+      end
+
+      # Set the column defaults to use when creating on the model.
+      def self.configure(model)
+        model.send(:set_prepared_statements_column_defaults)
+      end
+
+      module ClassMethods
+        # A hash with column symbol keys and default values.  Instance's
+        # values are merged into this hash before creating to reduce the
+        # number of free columns (columns that may or may not be present
+        # in the INSERT statement), as the number of prepared statements
+        # that can be created is 2^N (where N is the number of free columns).
+        attr_reader :prepared_statements_column_defaults
+        
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@prepared_statements_column_defaults, @prepared_statements_column_defaults) if @prepared_statements_column_defaults && !subclass.prepared_statements_column_defaults
+        end
+
+        # Set the column defaults to use when creating on the subclass.
+        def set_dataset(*)
+          x = super
+          set_prepared_statements_column_defaults
+          x
+        end
+
+        private
+
+        # Set the column defaults based on the database schema.  All columns
+        # are set to a default value unless they are a primary key column or
+        # they don't have a parseable default.
+        def set_prepared_statements_column_defaults
+          if db_schema
+            h = {}
+            db_schema.each do |k, v|
+              h[k] = v[:ruby_default] if (v[:ruby_default] || !v[:default]) && !v[:primary_key]
+            end
+            @prepared_statements_column_defaults = h
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Merge the current values into the default values to reduce the number
+        # of free columns.
+        def before_create
+          if v = model.prepared_statements_column_defaults
+            set_values(v.merge(values))
+          end
+          super
+        end
+
+        # Always do a full save of all columns to reduce the number of prepared
+        # statements that can be used.
+        def save_changes(opts={})
+          save(opts) || false if modified?
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -0,0 +1,59 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_with_pk plugin allows Dataset#with_pk for model datasets
+    # to use prepared statements by extract the values of previously bound variables
+    # using <tt>Dataset#unbind</tt>, and attempting to use a prepared statement if the
+    # variables can be unbound correctly. See  +Unbinder+ for details about what types of
+    # dataset filters can be unbound correctly.
+    #
+    # This plugin depends on the +prepared_statements+ plugin and should be considered unsafe.
+    # Unbinding dataset values cannot be done correctly in all cases, and use of this plugin
+    # in cases where not there are variables that are not unbound can lead to an denial of
+    # service attack by allocating an arbitrary number of prepared statements.  You have been
+    # warned.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use prepared statements for Dataset#with_pk (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_with_pk
+    #
+    #   # Make the Album class use prepared statements for Dataset#with_pk
+    #   Album.plugin :prepared_statements_with_pk
+    module PreparedStatementsWithPk
+      # Depend on the prepared_statements plugin
+      def self.apply(model)
+        model.plugin(:prepared_statements)
+      end
+
+      module ClassMethods
+        private
+
+        # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
+        # the primary key.
+        def prepared_lookup_dataset(ds)
+          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)
+        end
+      end
+
+      module DatasetMethods
+        # Use a prepared statement to find a row with the matching primary key
+        # inside this dataset.
+        def with_pk(pk)
+          begin
+            ds, bv = unbind
+          rescue UnbindDuplicate
+            super
+          else
+            begin
+              bv = bv.merge!(model.primary_key_hash(pk)){|k, v1, v2| ((v1 == v2) ? v1 : raise(UnbindDuplicate))}
+            rescue UnbindDuplicate
+              super
+            else
+              model.send(:prepared_lookup_dataset, ds).call(bv)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -0,0 +1,51 @@
+module Sequel
+  module Plugins
+    # Sequel's built in Serialization plugin doesn't check for modification
+    # of the serialized objects, because it requires an extra deserialization of a potentially
+    # very large object.  This plugin can detect changes in serialized values by
+    # checking whether the current deserialized value is the same as the original
+    # deserialized value.  This does require deserializing the value twice, but the
+    # original deserialized value is cached.
+    #
+    # == Example
+    #
+    #   require 'sequel'
+    #   require 'json'
+    #   class User < Sequel::Model
+    #     plugin :serialization, :json, :permissions
+    #     plugin :serialization_modification_detection
+    #   end
+    #   user = User.create(:permissions => {})
+    #   user.permissions[:global] = 'read-only'
+    #   user.save_changes
+    module SerializationModificationDetection
+      # Load the serialization plugin automatically.
+      def self.apply(model)
+        model.plugin :serialization
+      end
+      
+      module InstanceMethods
+        # Detect which serialized columns have changed.
+        def changed_columns
+          cc = super
+          deserialized_values.each{|c, v| cc << c if !cc.include?(c) && original_deserialized_value(c) != v} 
+          cc
+        end
+
+        private
+
+        # Clear the cache of original deserialized values after saving so that it doesn't
+        # show the column is modified after saving.
+        def after_save
+          super
+          @original_deserialized_values.clear if @original_deserialized_values
+        end
+
+        # Return the original deserialized value of the column, caching it to improve performance.
+        def original_deserialized_value(column)
+          (@original_deserialized_values ||= {})[column] ||= deserialize_value(column, self[column])
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/sharding.rb

@@ -40,6 +40,18 @@ module Sequel
         def new_using_server(s, values={}, &block)
           new(values, &block).set_server(s)
         end
+
+        private
+
+        # Set the server for each graphed dataset to the current server
+        # unless the graphed dataset already has a server set.
+        def eager_graph_dataset(opts, eager_options)
+          ds = super
+          if s = eager_options[:self].opts[:server]
+            ds = ds.server(s) unless ds.opts[:server]
+          end
+          ds
+        end
       end
 
       module InstanceMethods
@@ -109,26 +121,6 @@ module Sequel
           end
           ds
         end
-
-        private
-
-        # Set the shard of all retrieved objects to the shard of
-        # the table's dataset, or the current shard if the table's
-        # dataset does not have a shard.
-        def graph_each
-          ta = @opts[:graph][:table_aliases]
-          s = @opts[:server]
-          super do |r|
-            r.each do |k, v|
-              if ds = ta[k]
-                dss = ds.opts[:server]
-              end
-              vs = dss || s
-              v.set_server(vs) if vs && v.respond_to?(:set_server)
-            end
-            yield r
-          end
-        end
       end
     end
   end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -108,8 +108,10 @@ module Sequel
           key = skm[subclass] 
           sti_subclass_added(key)
           ska = [key]
+          rp = dataset.row_proc
           subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>ska), :inherited=>true)
           subclass.instance_eval do
+            dataset.row_proc = rp
             @sti_key = sk
             @sti_key_array = ska
             @sti_dataset = sd

data/lib/sequel/plugins/update_primary_key.rb

@@ -1,6 +1,6 @@
 module Sequel
   module Plugins
-    # The update_primary_key plugin allows you to modify an objects
+    # The update_primary_key plugin allows you to modify an object's
     # primary key and then save the record.  Sequel does not work
     # correctly with primary key modifications by default.  Sequel
     # is designed to work with surrogate primary keys that never need to be

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[:nil] ? nil : node.children.first.to_s
+              self[k.to_sym] = node.key?('nil') ? nil : node.children.first.to_s
             elsif meths.include?("#{k}=")
-              send("#{k}=", node[:nil] ? nil : node.children.first.to_s)
+              send("#{k}=", node.key?('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
@@ -266,7 +266,7 @@ module Sequel
 
           name_proc = model.xml_serialize_name_proc(opts)
           x = model.xml_builder(opts)
-          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name)).to_s]) do |x1|
+          x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name).gsub('/', '__')).to_s]) do |x1|
             cols.each do |c|
               attrs = {}
               if types

data/lib/sequel/sql.rb

@@ -38,6 +38,16 @@ module Sequel
   class LiteralString < ::String
   end
 
+  # Time subclass that gets literalized with only the time value, so it operates
+  # like a standard SQL time type.
+  class SQLTime < ::Time
+    # Create a new SQLTime instance given an hour, minute, and second.
+    def self.create(hour, minute, second, usec = 0)
+      t = now
+      local(t.year, t.month, t.day, hour, minute, second, usec)
+    end
+  end
+
   # The SQL module holds classes whose instances represent SQL fragments.
   # It also holds modules that are included in core ruby classes that
   # make Sequel a friendly DSL.
@@ -144,14 +154,17 @@ module Sequel
       # Operator symbols that take exactly two arguments
       TWO_ARITY_OPERATORS = [:'=', :'!=', :LIKE, :'NOT LIKE', \
         :~, :'!~', :'~*', :'!~*', :ILIKE, :'NOT ILIKE'] + \
-        INEQUALITY_OPERATORS + BITWISE_OPERATORS + IS_OPERATORS + IN_OPERATORS
+        INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS
 
       # Operator symbols that take one or more arguments
-      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
+      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS
 
       # Operator symbols that take only a single argument
       ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
 
+      # Custom expressions that may have different syntax on different databases
+      CUSTOM_EXPRESSIONS = [:extract]
+
       # An array of args for this object
       attr_reader :args
 
@@ -180,6 +193,8 @@ module Sequel
           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
         when *ONE_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
+        when *CUSTOM_EXPRESSIONS
+          # nothing
         else
           raise(Error, "Invalid operator #{op}")
         end
@@ -219,14 +234,7 @@ module Sequel
     #   ~:a.sql_number # ~"a"
     module BitwiseMethods
       ComplexExpression::BITWISE_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
 
       # Do the bitwise compliment of the self
@@ -244,16 +252,24 @@ module Sequel
     #   :a & :b # "a" AND "b"
     #   :a | :b # "a" OR "b"
     #   ~:a # NOT "a"
+    #
+    # One exception to this is when a NumericExpression or Integer is the argument
+    # to & or |, in which case a bitwise method will be used:
+    #
+    #   :a & 1 # "a" & 1 
+    #   :a | (:b + 1) # "a" | ("b" + 1)
     module BooleanMethods
       ComplexExpression::BOOLEAN_OPERATOR_METHODS.each do |m, o|
-        define_method(m) do |ce|
-          case ce
-          when NumericExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
+        module_eval(<<-END, __FILE__, __LINE__+1)
+          def #{m}(o)
+            case o
+            when NumericExpression, Integer
+              NumericExpression.new(#{m.inspect}, self, o)
+            else  
+              BooleanExpression.new(#{o.inspect}, self, o)
+            end
           end
-        end
+        END
       end
       
       # Create a new BooleanExpression with NOT, representing the inversion of whatever self represents.
@@ -321,7 +337,7 @@ module Sequel
       # doesn't use the standard function calling convention, and it
       # doesn't work on all databases.
       def extract(datetime_part)
-        Function.new(:extract, PlaceholderLiteralString.new("#{datetime_part} FROM ?", [self])).sql_number
+        NumericExpression.new(:extract, datetime_part, self)
       end
 
       # Return a BooleanExpression representation of +self+.
@@ -367,34 +383,12 @@ module Sequel
     #   'a'.lit <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{o} to a boolean expression")
-          else  
-            BooleanExpression.new(o, self, ce)
-          end
-        end
+        module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
       end
     end
 
-    # This module augments the default initalize method for the 
-    # +ComplexExpression+ subclass it is included in, so that
-    # attempting to use boolean input when initializing a +NumericExpression+
-    # or +StringExpression+ results in an error.  It is not expected to be
-    # used directly.
+    # Only exists for backwards compatibility, ignore it.
     module NoBooleanInputMethods
-      # Raise an +Error+ if one of the args would be boolean in an SQL
-      # context, otherwise call super.
-      def initialize(op, *args)
-        args.each do |a|
-          case a
-          when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, ::Array
-            raise(Error, "cannot apply #{op} to a boolean expression")
-          end
-        end
-        super
-      end
     end
 
     # This module includes the standard mathematical methods (+, -, *, and /)
@@ -405,15 +399,26 @@ module Sequel
     #   :a - :b # "a" - "b"
     #   :a * :b # "a" * "b"
     #   :a / :b # "a" / "b"
+    #
+    # One exception to this is if + is called with a +String+ or +StringExpression+,
+    # in which case the || operator is used instead of the + operator:
+    #
+    #   :a + 'b' # "a" || 'b'
     module NumericMethods
       ComplexExpression::MATHEMATICAL_OPERATORS.each do |o|
-        define_method(o) do |ce|
-          case ce
-          when BooleanExpression, StringExpression
-            raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
-          else  
-            NumericExpression.new(o, self, ce)
-          end
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__) unless o == :+
+      end
+
+      # Use || as the operator when called with StringExpression and String instances,
+      # and the + operator for LiteralStrings and all other types.
+      def +(ce)
+        case ce
+        when LiteralString
+          NumericExpression.new(:+, self, ce)
+        when StringExpression, String
+          StringExpression.new(:'||', self, ce)
+        else
+          NumericExpression.new(:+, self, ce)
         end
       end
     end
@@ -595,10 +600,27 @@ module Sequel
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")
+        when Constant
+          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
         else
           BooleanExpression.new(:NOT, ce)
         end
       end
+
+      # Always use an AND operator for & on BooleanExpressions
+      def &(ce)
+        BooleanExpression.new(:AND, self, ce)
+      end
+
+      # Always use an OR operator for | on BooleanExpressions
+      def |(ce)
+        BooleanExpression.new(:OR, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_boolean
+        self
+      end
     end
 
     # Represents an SQL CASE expression, used for conditional branching in SQL.
@@ -666,6 +688,21 @@ module Sequel
       include CastMethods
       include OrderMethods
       include SubscriptMethods
+
+      # Return a BooleanExpression with the same op and args.
+      def sql_boolean
+        BooleanExpression.new(self.op, *self.args)
+      end
+
+      # Return a NumericExpression with the same op and args.
+      def sql_number
+        NumericExpression.new(self.op, *self.args)
+      end
+
+      # Return a StringExpression with the same op and args.
+      def sql_string
+        StringExpression.new(self.op, *self.args)
+      end
     end
 
     # Represents constants or psuedo-constants (e.g. +CURRENT_DATE+) in SQL.
@@ -706,6 +743,12 @@ module Sequel
       NOTNULL = NegativeBooleanConstant.new(nil)
     end
 
+    class ComplexExpression
+      # A hash of the opposite for each constant, used for inverting constants.
+      CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE,
+                             Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}
+    end
+
     # Represents an SQL function call.
     class Function < GenericExpression
       # The array of arguments to pass to the function (may be blank)
@@ -834,7 +877,16 @@ module Sequel
       include BitwiseMethods 
       include NumericMethods
       include InequalityMethods
-      include NoBooleanInputMethods
+
+      # Always use + for + operator for NumericExpressions.
+      def +(ce)
+        NumericExpression.new(:+, self, ce)
+      end
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_number
+        self
+      end
     end
 
     # Represents a column/expression to order the result set by.
@@ -900,7 +952,6 @@ module Sequel
       include StringMethods
       include StringConcatenationMethods
       include InequalityMethods
-      include NoBooleanInputMethods
 
       # Map of [regexp, case_insenstive] to +ComplexExpression+ operator symbol
       LIKE_MAP = {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}
@@ -949,6 +1000,11 @@ module Sequel
         end
       end
       private_class_method :like_element
+
+      # Return self instead of creating a new object to save on memory.
+      def sql_string
+        self
+      end
     end
 
     # Represents an SQL array access, with multiple possible arguments.

data/lib/sequel/timezones.rb

@@ -109,6 +109,8 @@ module Sequel
         else
           Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s)
         end
+      when Hash
+        convert_input_timestamp([:year, :month, :day, :hour, :minute, :second].map{|x| (v[x] || v[x.to_s]).to_i}, input_timezone)
       when Time
         if datetime_class == DateTime
           v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
@@ -121,8 +123,6 @@ module Sequel
         else
           v.respond_to?(:to_time) ? v.to_time : string_to_datetime(v.to_s)
         end
-      when Date
-        convert_input_timestamp(v.to_s, input_timezone)
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
       end
@@ -160,7 +160,16 @@ module Sequel
     # +convert_output_timestamp+.
     def convert_timestamp(v, input_timezone)
       begin
-        convert_output_timestamp(convert_input_timestamp(v, input_timezone), Sequel.application_timezone)
+        if v.is_a?(Date) && !v.is_a?(DateTime)
+          # Dates handled specially as they are assumed to already be in the application_timezone
+          if datetime_class == DateTime
+            DateTime.civil(v.year, v.month, v.day, 0, 0, 0, application_timezone == :local ? (defined?(Rational) ? Rational(Time.local(v.year, v.month, v.day).utc_offset, 86400) : Time.local(v.year, v.month, v.day).utc_offset/86400.0) : 0)
+          else
+            Time.send(application_timezone == :utc ? :utc : :local, v.year, v.month, v.day)
+          end
+        else
+          convert_output_timestamp(convert_input_timestamp(v, input_timezone), application_timezone)
+        end
       rescue InvalidValue
         raise
       rescue => e

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