sequel 4.12.0 → 4.13.0

data/lib/sequel/model/base.rb

@@ -900,6 +900,14 @@ module Sequel
         schema_array = check_non_connection_error{db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
+
+          # Set the primary key(s) based on the schema information,
+          # if the schema information includes primary key information
+          if schema_array.all?{|k,v| v.has_key?(:primary_key)}
+            pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
+            pks.length > 0 ? set_primary_key(pks) : no_primary_key
+          end
+
           if (select = ds_opts[:select]) && !(select.length == 1 && select.first.is_a?(SQL::ColumnAll))
             # We don't remove the columns from the schema_hash,
             # as it's possible they will be used for typecasting
@@ -913,12 +921,6 @@ module Sequel
             # returned by the schema.
             cols = schema_array.collect{|k,v| k}
             set_columns(cols)
-            # Set the primary key(s) based on the schema information,
-            # if the schema information includes primary key information
-            if schema_array.all?{|k,v| v.has_key?(:primary_key)}
-              pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
-              pks.length > 0 ? set_primary_key(pks) : no_primary_key
-            end
             # Also set the columns for the dataset, so the dataset
             # doesn't have to do a query to get them.
             dataset.instance_variable_set(:@columns, cols)
@@ -1036,6 +1038,8 @@ module Sequel
           ds.literal_append(sql, pk)
           ds.fetch_rows(sql){|r| return ds.row_proc.call(r)}
           nil
+        elsif dataset.joined_dataset?
+          first_where(qualified_primary_key_hash(pk))
         else
           first_where(primary_key_hash(pk))
         end
@@ -1147,7 +1151,7 @@ module Sequel
         changed_columns.clear 
         yield self if block_given?
       end
-      
+
       # Returns value of the column's attribute.
       #
       #   Artist[1][:id] #=> 1
@@ -1216,14 +1220,6 @@ module Sequel
         @changed_columns ||= []
       end
   
-      # Similar to Model#dup, but copies frozen status to returned object
-      # if current object is frozen.
-      def clone
-        o = dup
-        o.freeze if frozen?
-        o
-      end
-
       # Deletes and returns +self+.  Does not run destroy hooks.
       # Look into using +destroy+ instead.
       #
@@ -1249,18 +1245,6 @@ module Sequel
         checked_save_failure(opts){checked_transaction(opts){_destroy(opts)}}
       end
 
-      # Produce a shallow copy of the object, similar to Object#dup.
-      def dup
-        s = self
-        super.instance_eval do
-          @values = s.values.dup
-          @changed_columns = s.changed_columns.dup
-          @errors = s.errors.dup
-          @this = s.this.dup if !new? && model.primary_key
-          self
-        end
-      end
-  
       # Iterates through all of the current values using each.
       #
       #  Album[1].each{|k, v| puts "#{k} => #{v}"}
@@ -1511,6 +1495,7 @@ module Sequel
       def save(opts=OPTS)
         raise Sequel::Error, "can't save frozen object" if frozen?
         set_server(opts[:server]) if opts[:server] 
+        _before_validation
         if opts[:validate] != false
           unless checked_save_failure(opts){_valid?(true, opts)}
             raise(ValidationFailed.new(self)) if raise_on_failure?(opts)
@@ -1642,7 +1627,16 @@ module Sequel
       #   Artist[1].this
       #   # SELECT * FROM artists WHERE (id = 1) LIMIT 1
       def this
-        @this ||= use_server(model.instance_dataset.filter(pk_hash))
+        return @this if @this
+        raise Error, "No dataset for model #{model}" unless ds = model.instance_dataset
+
+        cond = if ds.joined_dataset?
+          model.qualified_primary_key_hash(pk)
+        else
+          pk_hash
+        end
+
+        @this = use_server(ds.where(cond))
       end
       
       # Runs #set with the passed hash and then runs save_changes.
@@ -1701,11 +1695,21 @@ module Sequel
       #   artist(:name=>'Invalid').valid? # => false
       #   artist.errors.full_messages # => ['name cannot be Invalid']
       def valid?(opts = OPTS)
+        _before_validation
         _valid?(false, opts)
       end
 
       private
       
+      # Run code before any validation is done, but also run it before saving
+      # even if validation is skipped.  This is a private hook.  It exists so that
+      # plugins can set values automatically before validation (as the values
+      # need to be validated), but should be set even if validation is skipped.
+      # Unlike the regular before_validation hook, we do not skip the save/validation
+      # if this returns false.
+      def _before_validation
+      end
+
       # Do the deletion of the object's dataset, and check that the row
       # was actually deleted.
       def _delete
@@ -1761,7 +1765,7 @@ module Sequel
       # the record should be refreshed from the database.
       def _insert
         ds = _insert_dataset
-        if !ds.opts[:select] and ds.supports_insert_select? and h = _insert_select_raw(ds)
+        if _use_insert_select?(ds) && (h = _insert_select_raw(ds))
           _save_set_values(h)
           nil
         else
@@ -1924,6 +1928,11 @@ module Sequel
         _update_dataset.update(columns)
       end
 
+      # Whether to use insert_select when inserting a new row.
+      def _use_insert_select?(ds)
+        (!ds.opts[:select] || ds.opts[:returning]) && ds.supports_insert_select? 
+      end
+
       # Internal validation method.  If +raise_errors+ is +true+, hook
       # failures will be raised as HookFailure exceptions.  If it is
       # +false+, +false+ will be returned instead.
@@ -1990,6 +1999,36 @@ module Sequel
         Errors
       end
 
+      if RUBY_VERSION >= '1.9'
+        # Clone constructor -- freeze internal data structures if the original's
+        # are frozen.
+        def initialize_clone(other)
+          super
+          freeze if other.frozen?
+          self
+        end
+      else
+        # :nocov:
+        # Ruby 1.8 doesn't support initialize_clone, so override clone to dup and freeze. 
+        def clone
+          o = dup
+          o.freeze if frozen?
+          o
+        end
+        public :clone
+        # :nocov:
+      end
+
+      # Copy constructor -- Duplicate internal data structures.
+      def initialize_copy(other)
+        super
+        @values = @values.dup
+        @changed_columns = @changed_columns.dup if @changed_columns
+        @errors = @errors.dup if @errors
+        @this = @this.dup if @this
+        self
+      end
+
       # Set the columns with the given hash.  By default, the same as +set+, but
       # exists so it can be overridden.  This is called only for new records, before
       # changed_columns is cleared.

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -31,12 +31,20 @@ module Sequel
     # When using the class_table_inheritance plugin, subclasses use joined 
     # datasets:
     #
-    #   Employee.dataset.sql  # SELECT * FROM employees
-    #   Manager.dataset.sql   # SELECT * FROM employees
-    #                         # INNER JOIN managers USING (id)
-    #   Executive.dataset.sql # SELECT * FROM employees 
-    #                         # INNER JOIN managers USING (id)
-    #                         # INNER JOIN executives USING (id)
+    #   Employee.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind
+    #   # FROM employees
+    #
+    #   Manager.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind, managers.num_staff
+    #   # FROM employees
+    #   # JOIN managers ON (managers.id = employees.id)
+    #
+    #   Executive.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers
+    #   # FROM employees
+    #   # JOIN managers ON (managers.id = employees.id)
+    #   # JOIN executives ON (executives.id = managers.id)
     #
     # This allows Executive.all to return instances with all attributes
     # loaded.  The plugin overrides the deleting, inserting, and updating
@@ -99,12 +107,13 @@ module Sequel
       def self.configure(model, opts=OPTS)
         model.instance_eval do
           @cti_base_model = self
-          @cti_key = key = opts[:key] 
+          @cti_key = opts[:key] 
           @cti_tables = [table_name]
           @cti_columns = {table_name=>columns}
           @cti_table_map = opts[:table_map] || {}
           @cti_model_map = opts[:model_map]
           set_dataset_cti_row_proc
+          set_dataset(dataset.select(*columns.map{|c| Sequel.qualify(table_name, Sequel.identifier(c))}))
         end
       end
 
@@ -163,7 +172,7 @@ module Sequel
             # Need to set dataset and columns before calling super so that
             # the main column accessor module is included in the class before any
             # plugin accessor modules (such as the lazy attributes accessor module).
-            set_dataset(ds.join(table, [pk]))
+            set_dataset(ds.join(table, pk=>pk).select_append(*(columns - [primary_key]).map{|c| Sequel.qualify(table, Sequel.identifier(c))}))
             set_columns(self.columns)
           end
           super
@@ -221,14 +230,6 @@ module Sequel
       end
 
       module InstanceMethods
-        # Set the cti_key column to the name of the model.
-        def before_validation
-          if new? && model.cti_key && !model.cti_model_map
-            send("#{model.cti_key}=", model.name.to_s)
-          end
-          super
-        end
-        
         # Delete the row from all backing tables, starting from the
         # most recent table and going through all superclasses.
         def delete
@@ -242,6 +243,14 @@ module Sequel
         
         private
         
+        # Set the cti_key column to the name of the model.
+        def _before_validation
+          if new? && model.cti_key && !model.cti_model_map
+            send("#{model.cti_key}=", model.name.to_s)
+          end
+          super
+        end
+        
         # Insert rows into all backing tables, using the columns
         # in each table.  
         def _insert

data/lib/sequel/plugins/column_select.rb

@@ -0,0 +1,57 @@
+module Sequel
+  module Plugins
+    # The column_select plugin changes the default selection for a
+    # model dataset to explicit select all columns from the table:
+    # <tt>table.column1, table.column2, table.column3, ...</tt>.
+    # This makes it simpler to add columns to the model's table
+    # in a migration concurrently while running the application,
+    # without it affecting the operation of the application.
+    #
+    # Note that by default on databases that supporting RETURNING,
+    # using explicit column selections will cause instance creations
+    # to use two queries (insert and refresh) instead of a single
+    # query using RETURNING.  You can use the insert_returning_select
+    # plugin to automatically use RETURNING for instance creations
+    # for models where the column_select plugin automatically sets up
+    # an explicit column selection.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses explicitly select qualified columns
+    #   Sequel::Model.plugin :column_select
+    #
+    #   # Make the Album class select qualified columns
+    #   Album.plugin :column_select
+    module ColumnSelect
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model)
+        model.instance_eval do
+          self.dataset = dataset if @dataset
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # If the underlying dataset selects from a single table and
+        # has no explicit selection, explicitly select all columns from that table,
+        # qualifying them with table's name.
+        def convert_input_dataset(ds)
+          ds = super
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+            if db.supports_schema_parsing?
+              cols = check_non_connection_error{db.schema(ds)}
+              if cols
+                cols = cols.map{|c, _| c}
+              end
+            end
+            cols ||= check_non_connection_error{ds.columns}
+            ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+          end
+          ds
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/composition.rb

@@ -149,27 +149,11 @@ module Sequel
       end
 
       module InstanceMethods
-        # For each composition, set the columns in the model class based
-        # on the composition object.
-        def before_save
-          @compositions.keys.each{|n| instance_eval(&model.compositions[n][:decomposer])} if @compositions
-          super
-        end
-        
         # Cache of composition objects for this class.
         def compositions
           @compositions ||= {}
         end
 
-        # Duplicate compositions hash when duplicating model instance.
-        def dup
-          s = self
-          super.instance_eval do
-            @compositions = s.compositions.dup
-            self
-          end
-        end
-
         # Freeze compositions hash when freezing model instance.
         def freeze
           compositions.freeze
@@ -178,11 +162,25 @@ module Sequel
 
         private
 
+        # For each composition, set the columns in the model class based
+        # on the composition object.
+        def _before_validation
+          @compositions.keys.each{|n| instance_eval(&model.compositions[n][:decomposer])} if @compositions
+          super
+        end
+        
         # Clear the cached compositions when manually refreshing.
         def _refresh_set_values(hash)
           @compositions.clear if @compositions
           super
         end
+
+        # Duplicate compositions hash when duplicating model instance.
+        def initialize_copy(other)
+          super
+          @compositions = other.compositions.dup
+          self
+        end
       end
     end
   end

data/lib/sequel/plugins/dirty.rb

@@ -85,17 +85,6 @@ module Sequel
           initial_values.has_key?(column)
         end
 
-        # Duplicate internal data structures
-        def dup 
-          s = self
-          super.instance_eval do
-            @initial_values = s.initial_values.dup
-            @missing_initial_values = s.send(:missing_initial_values).dup
-            @previous_changes = s.previous_changes.dup if s.previous_changes
-            self
-          end
-        end
-
         # Freeze internal data structures
         def freeze
           initial_values.freeze
@@ -209,6 +198,15 @@ module Sequel
           end
         end
 
+        # Duplicate internal data structures
+        def initialize_copy(other)
+          super
+          @initial_values = other.initial_values.dup
+          @missing_initial_values = other.send(:missing_initial_values).dup
+          @previous_changes = other.previous_changes.dup if other.previous_changes
+          self
+        end
+
         # Reset the initial values when initializing.
         def initialize_set(h)
           super

data/lib/sequel/plugins/insert_returning_select.rb

@@ -0,0 +1,70 @@
+module Sequel
+  module Plugins
+    # If the model's dataset selects explicit columns and the
+    # database supports it, the insert_returning_select plugin will
+    # automatically set the RETURNING clause on the dataset used to
+    # insert rows to the columns selected, which allows the default model
+    # support to run the insert and refresh of the data in a single
+    # query, instead of two separate queries.  This is Sequel's default
+    # behavior when the model does not select explicit columns.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses automatically setup insert returning clauses
+    #   Sequel::Model.plugin :insert_returning_select
+    #
+    #   # Make the Album class automatically setup insert returning clauses
+    #   Album.plugin :insert_returning_select
+    module InsertReturningSelect
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model)
+        model.instance_eval do
+          self.dataset = dataset if @dataset && @dataset.opts[:select]
+        end
+      end
+
+      module ClassMethods
+        # The dataset to use to insert new rows.  For internal use only.
+        attr_reader :instance_insert_dataset
+
+        private
+
+        # When reseting the instance dataset, also reset the instance_insert_dataset.
+        def reset_instance_dataset
+          ret = super
+          ds = @instance_dataset
+
+          if columns = insert_returning_columns(ds)
+            ds = ds.returning(*columns)
+          end
+          @instance_insert_dataset = ds
+
+          ret
+        end
+
+        # Determine the columns to use for the returning clause, or return nil
+        # if they can't be determined and a returning clause should not be
+        # added automatically.
+        def insert_returning_columns(ds)
+          return unless ds.supports_returning?(:insert)
+          return unless values = ds.opts[:select]
+
+          values = values.map{|v| ds.unqualified_column_for(v)}
+          if values.all?
+            values
+          end
+        end
+      end
+      
+      module InstanceMethods
+        private
+
+        # Use the instance_insert_dataset as the base dataset for the insert.
+        def _insert_dataset
+          use_server(model.instance_insert_dataset)
+        end
+      end
+    end
+  end
+end