sequel 3.20.0 → 3.21.0

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

@@ -101,9 +101,9 @@ module Sequel
         "DROP SEQUENCE #{quote_identifier(name)}"
       end
     end
-    
+
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order limit')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order limit lock')
 
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, opts={})

data/lib/sequel/adapters/tinytds.rb

@@ -0,0 +1,125 @@
+require 'tiny_tds'
+Sequel.require 'adapters/shared/mssql'
+
+module Sequel
+  module TinyTDS
+    class Database < Sequel::Database
+      include Sequel::MSSQL::DatabaseMethods
+      set_adapter_scheme :tinytds
+      
+      # Transfer the :host and :user options to the
+      # :dataserver and :username options.
+      def connect(server)
+        opts = server_opts(server)
+        opts[:dataserver] = opts[:host]
+        opts[:username] = opts[:user]
+        TinyTds::Client.new(opts)
+      end
+      
+      # Return instance of Sequel::TinyTDS::Dataset with the given options.
+      def dataset(opts = nil)
+        TinyTDS::Dataset.new(self, opts)
+      end
+    
+      # Execute the given +sql+ on the server.  If the :return option
+      # is present, its value should be a method symbol that is called
+      # on the TinyTds::Result object returned from executing the
+      # +sql+.  The value of such a method is returned to the caller.
+      # Otherwise, if a block is given, it is yielded the result object.
+      # If no block is given and a :return is not present, +nil+ is returned.
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |c|
+          begin
+            m = opts[:return]
+            r = nil
+            log_yield(sql) do
+              r = c.execute(sql)
+              return r.send(m) if m
+            end
+            yield(r) if block_given?
+          rescue TinyTds::Error => e
+            raise_error(e)
+          ensure
+           r.cancel if r && c.sqlsent?
+          end
+        end
+      end
+
+      # Return the number of rows modified by the given +sql+.
+      def execute_dui(sql, opts={})
+        execute(sql, opts.merge(:return=>:do))
+      end
+
+      # Return the value of the autogenerated primary key (if any)
+      # for the row inserted by the given +sql+.
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:return=>:insert))
+      end
+
+      # Execute the DDL +sql+ on the database and return nil.
+      def execute_ddl(sql, opts={})
+        execute(sql, opts.merge(:return=>:each))
+        nil
+      end
+
+      private
+
+      # For some reason, unless you specify a column can be
+      # NULL, it assumes NOT NULL, so turn NULL on by default unless
+      # the column is a primary key column.
+      def column_list_sql(g)
+        pks = []
+        g.constraints.each{|c| pks = c[:columns] if c[:type] == :primary_key} 
+        g.columns.each{|c| c[:null] = true if !pks.include?(c[:name]) && !c[:primary_key] && !c.has_key?(:null) && !c.has_key?(:allow_null)}
+        super
+      end
+
+      # Close the TinyTds::Client object.
+      def disconnect_connection(c)
+        c.close
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      include Sequel::MSSQL::DatasetMethods
+      
+      # Yield hashes with symbol keys, attempting to optimize for
+      # various cases.
+      def fetch_rows(sql)
+        execute(sql) do |result|
+          each_opts = {:cache_rows=>false}
+          each_opts[:timezone] = :utc if Sequel.database_timezone == :utc
+          offset = @opts[:offset]
+          @columns = cols = result.fields.map{|c| output_identifier(c)}
+          if identifier_output_method
+            each_opts[:as] = :array
+            result.each(each_opts) do |r|
+              h = {}
+              cols.zip(r).each{|k, v| h[k] = v}
+              h.delete(row_number_column) if offset
+              yield h
+            end
+          else
+            each_opts[:symbolize_keys] = true
+            if offset
+              result.each(each_opts) do |r|
+                r.delete(row_number_column) if offset
+                yield r
+              end
+            else
+              result.each(each_opts, &block)
+            end
+          end
+        end
+        self
+      end
+      
+      private
+      
+      # Properly escape the given string +v+.
+      def literal_string(v)
+        db.synchronize{|c| "N'#{c.escape(v)}'"}
+      end
+    end
+  end
+end

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
 
     # Whether to use the single threaded connection pool by default
     @@single_threaded = false

data/lib/sequel/database/schema_methods.rb

@@ -20,6 +20,9 @@ module Sequel
     UNIQUE = ' UNIQUE'.freeze
     UNSIGNED = ' UNSIGNED'.freeze
 
+    # The order of column modifiers to use when defining a column.
+    COLUMN_DEFINITION_ORDER = [:default, :null, :unique, :primary_key, :auto_increment, :references]
+
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
     #
@@ -256,21 +259,50 @@ module Sequel
       AUTOINCREMENT
     end
     
+    # The order of the column definition, as an array of symbols.
+    def column_definition_order
+      self.class.const_get(:COLUMN_DEFINITION_ORDER)
+    end
+
     # SQL DDL fragment containing the column creation SQL for the given column.
     def column_definition_sql(column)
       sql = "#{quote_identifier(column[:name])} #{type_literal(column)}"
-      sql << UNIQUE if column[:unique]
+      column_definition_order.each{|m| send(:"column_definition_#{m}_sql", sql, column)}
+      sql
+    end
+
+    # Add auto increment SQL fragment to column creation SQL.
+    def column_definition_auto_increment_sql(sql, column)
+      sql << " #{auto_increment_sql}" if column[:auto_increment]
+    end
+    
+    # Add default SQL fragment to column creation SQL.
+    def column_definition_default_sql(sql, column)
+      sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+    end
+    
+    # Add null/not null SQL fragment to column creation SQL.
+    def column_definition_null_sql(sql, column)
       null = column.fetch(:null, column[:allow_null])
       sql << NOT_NULL if null == false
       sql << NULL if null == true
-      sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+    end
+    
+    # Add primary key SQL fragment to column creation SQL.
+    def column_definition_primary_key_sql(sql, column)
       sql << PRIMARY_KEY if column[:primary_key]
-      sql << " #{auto_increment_sql}" if column[:auto_increment]
+    end
+    
+    # Add foreign key reference SQL fragment to column creation SQL.
+    def column_definition_references_sql(sql, column)
       sql << column_references_column_constraint_sql(column) if column[:table]
-      sql
     end
     
-    # SQL DDL fragment containing the column creation
+    # Add unique constraint SQL fragment to column creation SQL.
+    def column_definition_unique_sql(sql, column)
+      sql << UNIQUE if column[:unique]
+    end
+    
     # SQL for all given columns, used inside a CREATE TABLE block.
     def column_list_sql(generator)
       (generator.columns.map{|c| column_definition_sql(c)} + generator.constraints.map{|c| constraint_definition_sql(c)}).join(COMMA_SEPARATOR)

data/lib/sequel/dataset/sql.rb

@@ -177,9 +177,9 @@ module Sequel
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
     COMMA_SEPARATOR = ', '.freeze
-    COLUMN_REF_RE1 = /\A([\w ]+)__([\w ]+)___([\w ]+)\z/.freeze
-    COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
-    COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
+    COLUMN_REF_RE1 = /\A(((?!__).)+)__(((?!___).)+)___(.+)\z/.freeze
+    COLUMN_REF_RE2 = /\A(((?!___).)+)___(.+)\z/.freeze
+    COLUMN_REF_RE3 = /\A(((?!__).)+)__(.+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
     DATASET_ALIAS_BASE_NAME = 't'.freeze
@@ -934,11 +934,11 @@ module Sequel
     def split_symbol(sym)
       s = sym.to_s
       if m = COLUMN_REF_RE1.match(s)
-        m[1..3]
+        [m[1], m[3], m[5]]
       elsif m = COLUMN_REF_RE2.match(s)
-        [nil, m[1], m[2]]
+        [nil, m[1], m[3]]
       elsif m = COLUMN_REF_RE3.match(s)
-        [m[1], m[2], nil]
+        [m[1], m[3], nil]
       else
         [nil, s, nil]
       end

data/lib/sequel/extensions/schema_dumper.rb

@@ -122,7 +122,7 @@ END_MIG
         {:type=>Integer}
       when /\Atinyint(?:\((\d+)\))?\z/o
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
-      when /\Abigint(?:\((?:\d+)\))?\z/o
+      when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
         {:type=>Bignum}
       when /\A(?:real|float|double(?: precision)?)\z/o
         {:type=>Float}

data/lib/sequel/model/base.rb

@@ -23,6 +23,12 @@ module Sequel
       # stored so when the dataset changes, methods defined with def_dataset_method
       # will be applied to the new dataset.
       attr_reader :dataset_methods
+      #
+      # Array of plugin modules loaded by this class
+      #
+      #   Sequel::Model.plugins
+      #   # => [Sequel::Model, Sequel::Model::Associations]
+      attr_reader :plugins
   
       # The primary key for the class.  Sequel can determine this automatically for
       # many databases, but not all, so you may need to set it manually.  If not
@@ -308,6 +314,28 @@ module Sequel
         clear_setter_methods_cache
         @simple_pk = @primary_key = nil
       end
+      
+      # Loads a plugin for use with the model class, passing optional arguments
+      # to the plugin.  If the plugin is a module, load it directly.  Otherwise,
+      # require the plugin from either sequel/plugins/#{plugin} or
+      # sequel_#{plugin}, and then attempt to load the module using a
+      # the camelized plugin name under Sequel::Plugins.
+      def plugin(plugin, *args, &blk)
+        m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+        unless @plugins.include?(m)
+          @plugins << m
+          m.apply(self, *args, &blk) if m.respond_to?(:apply)
+          include(m::InstanceMethods) if m.const_defined?("InstanceMethods")
+          extend(m::ClassMethods)if m.const_defined?("ClassMethods")
+          if m.const_defined?("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
+        end
+        m.configure(self, *args, &blk) if m.respond_to?(:configure)
+      end
   
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
@@ -608,6 +636,27 @@ module Sequel
         @overridable_methods_module
       end
       
+      # Returns the module for the specified plugin. If the module is not 
+      # defined, the corresponding plugin required.
+      def plugin_module(plugin)
+        module_name = plugin.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+        if !Sequel::Plugins.const_defined?(module_name) ||
+           (Sequel.const_defined?(module_name) &&
+            Sequel::Plugins.const_get(module_name) == Sequel.const_get(module_name))
+          begin
+            Sequel.tsk_require "sequel/plugins/#{plugin}"
+          rescue LoadError => e
+            begin
+              Sequel.tsk_require "sequel_#{plugin}"
+            rescue LoadError => e2
+              e.message << "; #{e2.message}"
+              raise e
+            end
+          end
+        end
+        Sequel::Plugins.const_get(module_name)
+      end
+
       # Find the row in the dataset that matches the primary key.  Uses
       # a static SQL optimization if the table and primary key are simple.
       def primary_key_lookup(pk)
@@ -1444,6 +1493,7 @@ module Sequel
       end
     end
 
+    extend ClassMethods
     plugin self
   end
 end

data/lib/sequel/model/plugins.rb

@@ -21,59 +21,4 @@ module Sequel
   #   any modules.
   module Plugins
   end
-  
-  class Model
-    # Loads a plugin for use with the model class, passing optional arguments
-    # to the plugin.  If the plugin is a module, load it directly.  Otherwise,
-    # require the plugin from either sequel/plugins/#{plugin} or
-    # sequel_#{plugin}, and then attempt to load the module using a
-    # the camelized plugin name under Sequel::Plugins.
-    def self.plugin(plugin, *args, &blk)
-      m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
-      unless @plugins.include?(m)
-        @plugins << m
-        m.apply(self, *args, &blk) if m.respond_to?(:apply)
-        include(m::InstanceMethods) if m.const_defined?("InstanceMethods")
-        extend(m::ClassMethods)if m.const_defined?("ClassMethods")
-        if m.const_defined?("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
-      end
-      m.configure(self, *args, &blk) if m.respond_to?(:configure)
-    end
-    
-    module ClassMethods
-      # Array of plugin modules loaded by this class
-      #
-      #   Sequel::Model.plugins
-      #   # => [Sequel::Model, Sequel::Model::Associations]
-      attr_reader :plugins
-      
-      private
-  
-      # Returns the module for the specified plugin. If the module is not 
-      # defined, the corresponding plugin required.
-      def plugin_module(plugin)
-        module_name = plugin.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
-        if !Sequel::Plugins.const_defined?(module_name) ||
-           (Sequel.const_defined?(module_name) &&
-            Sequel::Plugins.const_get(module_name) == Sequel.const_get(module_name))
-          begin
-            Sequel.tsk_require "sequel/plugins/#{plugin}"
-          rescue LoadError => e
-            begin
-              Sequel.tsk_require "sequel_#{plugin}"
-            rescue LoadError => e2
-              e.message << "; #{e2.message}"
-              raise e
-            end
-          end
-        end
-        Sequel::Plugins.const_get(module_name)
-      end
-    end
-  end
 end

data/lib/sequel/plugins/association_autoreloading.rb

@@ -0,0 +1,48 @@
+module Sequel
+  module Plugins
+    # The AssociationAutoreloading plugin makes many_to_one association
+    # accessor methods automatically reload the cached object whenever
+    # the association's foreign key is modified:
+    #
+    #     Album.many_to_one :artists
+    #     album = Album.first
+    #     album.artist_id #=> 1
+    #     album.artist # caches associated artist
+    #     album.artist_id = 2
+    #     album.artist # reloads associated artist
+    #
+    module AssociationAutoreloading
+      module ClassMethods
+        private
+
+        # Create a setter method for +key+ in an anonymous module included
+        # in the class that calls super and clears the cache for
+        # the given array of associations.
+        def create_autoreloading_association_setter(key, assocs)
+          include(@autoreloading_associations_module ||= Module.new) unless @autoreloading_associations_module
+          @autoreloading_associations_module.class_eval do
+            unless method_defined?("#{key}=")
+              define_method("#{key}=") do |v|
+                o = send(key)
+                super(v)
+                assocs.each{|a| associations.delete(a)} if send(key) != o
+              end
+            end
+          end
+        end
+
+        # For each of the foreign keys in the association, create
+        # a setter method that will clear the association cache.
+        def def_many_to_one(opts)
+          super
+          @autoreloading_associations ||= {}
+          opts[:keys].each do |key|
+            assocs = @autoreloading_associations[key] ||= []
+            assocs << opts[:name]
+            create_autoreloading_association_setter(key, assocs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -262,7 +262,7 @@ module Sequel
               o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && v.size == i
             end
             if w = opts[:within]
-              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+              o.errors.add(a, opts[:message] || opts[:wrong_length]) unless v && w.send(w.respond_to?(:cover?) ? :cover? : :include?, v.size)
             end
           end
         end
@@ -345,14 +345,15 @@ module Sequel
         # * :message - The message to use (default: 'is not in range or set: <specified range>')
         def validates_inclusion_of(*atts)
           opts = extract_options!(atts)
-          unless opts[:in] && opts[:in].respond_to?(:include?) 
-            raise ArgumentError, "The :in parameter is required, and respond to include?"
+          n = opts[:in]
+          unless n && (n.respond_to?(:cover?) || n.respond_to?(:include?))
+            raise ArgumentError, "The :in parameter is required, and must respond to cover? or include?"
           end
-          opts[:message] ||= "is not in range or set: #{opts[:in].inspect}"
+          opts[:message] ||= "is not in range or set: #{n.inspect}"
           reflect_validation(:inclusion, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) unless opts[:in].include?(v)
+            o.errors.add(a, opts[:message]) unless n.send(n.respond_to?(:cover?) ? :cover? : :include?, v)
           end
         end