sequel 3.26.0 → 3.27.0

data/lib/sequel/adapters/tinytds.rb

@@ -32,9 +32,32 @@ module Sequel
           begin
             m = opts[:return]
             r = nil
-            log_yield(sql) do
-              r = c.execute(sql)
-              return r.send(m) if m
+            if (args = opts[:arguments]) && !args.empty?
+              types = []
+              values = []
+              args.each_with_index do |(k, v), i|
+                v, type = ps_arg_type(v)
+                types << "@#{k} #{type}"
+                values << "@#{k} = #{v}"
+              end
+              case m
+              when :do
+                sql = "#{sql}; SELECT @@ROWCOUNT AS AffectedRows"
+                single_value = true
+              when :insert
+                sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                single_value = true
+              end
+              sql = "EXEC sp_executesql N'#{c.escape(sql)}', N'#{c.escape(types.join(', '))}', #{values.join(', ')}"
+              log_yield(sql) do
+                r = c.execute(sql)
+                r.each{|row| return row.values.first} if single_value
+              end
+            else
+              log_yield(sql) do
+                r = c.execute(sql)
+                return r.send(m) if m
+              end
             end
             yield(r) if block_given?
           rescue TinyTds::Error => e
@@ -84,14 +107,98 @@ module Sequel
         c.close
       end
 
+      # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
         super || (opts[:conn] && !opts[:conn].active?)
       end
+
+      # Return a 2 element array with the literal value and type to use
+      # in the prepared statement call for the given value and connection.
+      def ps_arg_type(v)
+        case v
+        when Fixnum
+          [v, 'int']
+        when Bignum
+          [v, 'bigint']
+        when Float
+          [v, 'double precision']
+        when Numeric
+          [v, 'numeric']
+        when SQLTime
+          [literal(v), 'time']
+        when DateTime, Time
+          [literal(v), 'datetime']
+        when Date
+          [literal(v), 'date']
+        when nil
+          ['NULL', 'nvarchar(max)']
+        when true
+          ['1', 'int']
+        when false
+          ['0', 'int']
+        when SQL::Blob
+          [literal(v), 'varbinary(max)']
+        else
+          [literal(v), 'nvarchar(max)']
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
       
+      # SQLite already supports named bind arguments, so use directly.
+      module ArgumentMapper
+        include Sequel::Dataset::ArgumentMapper
+        
+        protected
+        
+        # Return a hash with the same values as the given hash,
+        # but with the keys converted to strings.
+        def map_to_prepared_args(hash)
+          args = {}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
+          args
+        end
+        
+        private
+        
+        # SQLite uses a : before the name of the argument for named
+        # arguments.
+        def prepared_arg(k)
+          LiteralString.new("@#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
+        end
+      end
+      
+      # SQLite prepared statement uses a new prepared statement each time
+      # it is called, but it does use the bind arguments.
+      module PreparedStatementMethods
+        include ArgumentMapper
+        
+        private
+        
+        # Run execute_select on the database with the given SQL and the stored
+        # bind arguments.
+        def execute(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_insert(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
+      
       # Yield hashes with symbol keys, attempting to optimize for
       # various cases.
       def fetch_rows(sql)
@@ -123,6 +230,18 @@ module Sequel
         self
       end
       
+      # Create a named prepared statement that is stored in the
+      # database (and connection) for reuse.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
       private
       
       # Properly escape the given string +v+.

data/lib/sequel/core.rb

@@ -228,12 +228,13 @@ module Sequel
     end
   end
 
-  # Converts the given +string+ into a +Time+ object.
+  # Converts the given +string+ into a <tt>Sequel::SQLTime</tt> object.
   #
-  #   Sequel.string_to_time('10:20:30') # Time.parse('10:20:30')
+  #   v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
+  #   DB.literal(v) # => '10:20:30'
   def self.string_to_time(string)
     begin
-      Time.parse(string)
+      SQLTime.parse(string)
     rescue => e
       raise convert_exception_class(e, InvalidValue)
     end

data/lib/sequel/database/misc.rb

@@ -215,10 +215,10 @@ module Sequel
     # Typecast the value to a Date
     def typecast_value_date(value)
       case value
-      when Date
-        value
       when DateTime, Time
         Date.new(value.year, value.month, value.day)
+      when Date
+        value
       when String
         Sequel.string_to_date(value)
       when Hash
@@ -230,12 +230,7 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      klass = Sequel.datetime_class
-      if value.is_a?(Hash)
-        klass.send(klass == Time ? :mktime : :new, *[:year, :month, :day, :hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
-      else
-        Sequel.typecast_to_application_timestamp(value)
-      end
+      Sequel.typecast_to_application_timestamp(value)
     end
 
     # Typecast the value to a BigDecimal
@@ -280,13 +275,15 @@ module Sequel
     # Typecast the value to a Time
     def typecast_value_time(value)
       case value
-      when Time
+      when SQLTime
         value
+      when Time
+        SQLTime.local(value.year, value.month, value.day, value.hour, value.min, value.sec, value.respond_to?(:nsec) ? value.nsec : value.usec)
       when String
         Sequel.string_to_time(value)
       when Hash
         t = Time.now
-        Time.mktime(t.year, t.month, t.day, *[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.local(t.year, t.month, t.day, *[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/dataset/misc.rb

@@ -107,7 +107,7 @@ module Sequel
     # Define a hash value such that datasets with the same DB, opts, and SQL
     # will have the same hash value
     def hash
-      [db, opts.sort_by{|k| k.to_s}, sql].hash
+      [db, opts.sort_by{|k, v| k.to_s}, sql].hash
     end
     
     # The String instance method to call on identifiers before sending them to

data/lib/sequel/dataset/sql.rb

@@ -100,6 +100,8 @@ module Sequel
         literal_false
       when Array
         literal_array(v)
+      when SQLTime
+        literal_sqltime(v)
       when Time
         literal_time(v)
       when DateTime
@@ -723,6 +725,11 @@ module Sequel
       end
     end
 
+    # SQL fragment for Sequel::SQLTime, containing just the time part
+    def literal_sqltime(v)
+      v.strftime("'%H:%M:%S#{format_timestamp_usec(v.usec) if supports_timestamp_usecs?}'")
+    end
+
     # SQL fragment for String.  Doubles \ and ' by default.
     def literal_string(v)
       "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"

data/lib/sequel/model/associations.rb

@@ -1037,8 +1037,8 @@ module Sequel
           @associations ||= {}
         end
       
-        # Used internally by the associations code, like pk but doesn't raise
-        # an Error if the model has no primary key.
+        # Formally used internally by the associations code, like pk but doesn't raise
+        # an Error if the model has no primary key.  Not used any longer, deprecated.
         def pk_or_nil
           key = primary_key
           key.is_a?(Array) ? key.map{|k| @values[k]} : @values[key]

data/lib/sequel/model/base.rb

@@ -148,6 +148,26 @@ module Sequel
       def dataset=(ds)
         set_dataset(ds)
       end
+
+      # Extend the dataset with an anonymous module, similar to adding
+      # a plugin with the methods defined in DatasetMethods.  If a block
+      # is given, it is module_evaled.
+      #
+      #   Artist.dataset_module do
+      #     def foo
+      #       :bar
+      #     end
+      #   end
+      #   Artist.dataset.foo
+      #   # => :bar
+      #   Artist.foo
+      #   # => :bar
+      def dataset_module
+        @dataset_module ||= Module.new
+        @dataset_module.module_eval(&Proc.new) if block_given?
+        dataset_extend(@dataset_module)
+        @dataset_module
+      end
     
       # Returns the database associated with the Model class.
       # If this model doesn't have a database associated with it,
@@ -248,6 +268,13 @@ module Sequel
         find(cond) || create(cond, &block)
       end
     
+      # Clear the setter_methods cache when a module is included, as it
+      # may contain setter methods.
+      def include(mod)
+        clear_setter_methods_cache
+        super
+      end
+  
       # If possible, set the dataset for the model subclass as soon as it
       # is created.  Also, make sure the inherited class instance variables
       # are copied into the subclass.
@@ -328,12 +355,7 @@ module Sequel
           m.apply(self, *args, &blk) if m.respond_to?(:apply)
           include(m::InstanceMethods) if plugin_module_defined?(m, :InstanceMethods)
           extend(m::ClassMethods)if plugin_module_defined?(m, :ClassMethods)
-          if plugin_module_defined?(m, :DatasetMethods)
-            dataset.extend(m::DatasetMethods) if @dataset
-            dataset_method_modules << m::DatasetMethods
-            meths = m::DatasetMethods.public_instance_methods.reject{|x| NORMAL_METHOD_NAME_REGEXP !~ x.to_s}
-            def_dataset_method(*meths) unless meths.empty?
-          end
+          dataset_extend(m::DatasetMethods) if plugin_module_defined?(m, :DatasetMethods)
         end
         m.configure(self, *args, &blk) if m.respond_to?(:configure)
       end
@@ -553,6 +575,16 @@ module Sequel
         end
       end
 
+      # Add the module to the class's dataset_method_modules.  Extend the dataset with the
+      # module if the model has a dataset.  Add dataset methods to the class for all
+      # public dataset methods.
+      def dataset_extend(mod)
+        dataset.extend(mod) if @dataset
+        dataset_method_modules << mod
+        meths = mod.public_instance_methods.reject{|x| NORMAL_METHOD_NAME_REGEXP !~ x.to_s}
+        def_dataset_method(*meths) unless meths.empty?
+      end
+
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
       def def_bad_column_accessor(column)
         overridable_methods_module.module_eval do
@@ -705,7 +737,7 @@ module Sequel
     #   a model object, Sequel will call +around_destory+, which will call +before_destroy+, do
     #   the destroy, and then call +after_destroy+.
     # * The following instance_methods all call the class method of the same
-    #   name: columns, dataset, db, primary_key, db_schema.
+    #   name: columns, db, primary_key, db_schema.
     # * All of the methods in +BOOLEAN_SETTINGS+ create attr_writers allowing you
     #   to set values for the attribute.  It also creates instnace getters returning
     #   the value of the setting.  If the value has not yet been set, it
@@ -889,14 +921,25 @@ module Sequel
 
       # Returns true when current instance exists, false otherwise.
       # Generally an object that isn't new will exist unless it has
-      # been deleted.  Uses a database query to check for existence.
+      # been deleted.  Uses a database query to check for existence,
+      # unless the model object is new, in which case this is always
+      # false.
       #
       #   Artist[1].exists? # SELECT 1 FROM artists WHERE (id = 1)
       #   # => true
+      #   Artist.new.exists?
+      #   # => false
       def exists?
-        !this.get(1).nil?
+        new? ? false : !this.get(1).nil?
       end
       
+      # Ignore the model's setter method cache when this instances extends a module, as the
+      # module may contain setter methods.
+      def extend(mod)
+        @singleton_setter_added = true
+        super
+      end
+  
       # Value that should be unique for objects with the same class and pk (if pk is not nil), or
       # the same class and values (if pk is nil).
       #
@@ -905,7 +948,14 @@ module Sequel
       #   Artist.new.hash == Artist.new.hash # true
       #   Artist.new(:name=>'Bob').hash == Artist.new.hash # false
       def hash
-        [model, pk.nil? ? @values.sort_by{|k,v| k.to_s} : pk].hash
+        case primary_key
+        when Array
+          [model, !pk.all? ? @values.sort_by{|k,v| k.to_s} : pk].hash
+        when Symbol
+          [model, pk.nil? ? @values.sort_by{|k,v| k.to_s} : pk].hash
+        else
+          [model, @values.sort_by{|k,v| k.to_s}].hash
+        end
       end
   
       # Returns value for the :id attribute, even if the primary key is

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -33,10 +33,16 @@ module Sequel
         # that can be created is 2^N (where N is the number of free columns).
         attr_reader :prepared_statements_column_defaults
         
-        # Set the column defaults to use when creating on the subclass.
         def inherited(subclass)
           super
-          subclass.send(:set_prepared_statements_column_defaults)
+          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
@@ -45,11 +51,13 @@ module Sequel
         # 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
-          h = {}
-          db_schema.each do |k, v|
-            h[k] = v[:ruby_default] if (v[:ruby_default] || !v[:default]) && !v[:primary_key]
+          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
-          @prepared_statements_column_defaults = h
         end
       end
 
@@ -57,7 +65,9 @@ module Sequel
         # Merge the current values into the default values to reduce the number
         # of free columns.
         def before_create
-          set_values(model.prepared_statements_column_defaults.merge(values))
+          if v = model.prepared_statements_column_defaults
+            set_values(v.merge(values))
+          end
           super
         end
 

data/lib/sequel/sql.rb

@@ -38,6 +38,11 @@ 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
+  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.

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