sequel 4.18.0 → 4.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fc29f94c84321473e3ed262bd8ac957a265e295
-  data.tar.gz: f25fc9635d509858d7275081fe1e5c67cf6db8ce
+  metadata.gz: ce1762f276f7bfdac15fe395f0eef9696c185397
+  data.tar.gz: f1164599a6a4bccd41e20d7ff36f443e6a46551f
 SHA512:
-  metadata.gz: 306ffd681a632fe5aee226016f51f62beb296e7b080d69b3c791690825e370c3e85ebea3002007ee9bc0f371f0d05026a215229364af10c9dcad0cc906f1e2bd
-  data.tar.gz: f0c9cf0fe10ce041abd556111a0f845840f2415ad6832a8ddcc2b37b0a4fcff0b538f0da3fbc95f21d7a5995df9bfb61a95bfa48a202686ba4abb4533105658d
+  metadata.gz: 31ecc2aef0b4d68eb9424f60cd2b1b7256b8916ca57d5fe6b74c5d3681e0b72a73014fa7225c4a87c87ee23656699ea85d027d919ac30613aa99269007676f22
+  data.tar.gz: fe8a6d58fab4a544a5cc5168b6721dc7d72c93567b8d17d04a940efd0ac4fb5dcf5bbe6968ed8fe9e6d52c30dbde418d571567b7f49103ec20f9f86cf9a82a7c

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 4.19.0 (2015-02-01)
+
+* Make jdbc/sqlanywhere correctly set :auto_increment entry in schema hashes (jeremyevans)
+
+* Add Model#cancel_action for canceling actions in before hooks, instead of having the hooks return false (jeremyevans)
+
+* Support not setting @@wait_timeout on MySQL via :timeout=>nil Database option (jeremyevans)
+
+* Add accessed_columns plugin, recording which columns have been accessed for a model instance (jeremyevans)
+
+* Use correct migration version when using IntegerMigrator with :allow_missing_migration_files (blerins) (#938)
+
+* Make Dataset#union, #intersect, and #except automatically handle datasets with raw SQL (jeremyevans) (#934)
+
+* Add column_conflicts plugin to automatically handle columns that conflict with method names (jeremyevans) (#929)
+
+* Add Model#get_column_value and #set_column_value to get/set column values (jeremyevans) (#929)
+
 === 4.18.0 (2015-01-02)
 
 * Make Dataset#empty? work when the dataset is ordered by a non-column expression (pete) (#923)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2014 Jeremy Evans
+Copyright (c) 2008-2015 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/doc/advanced_associations.rdoc

@@ -457,7 +457,7 @@ array of symbols and procs.  For <tt>:after_load</tt> with a *_to_many associati
 the associated object argument is an array of associated objects.
 
 If any of the before callbacks return +false+, the adding/removing
-does not happen and it either raises a <tt>Sequel::BeforeHookFailed</tt> (the default), or
+does not happen and it either raises a <tt>Sequel::HookFailed</tt> (the default), or
 returns false (if +raise_on_save_failure+ is false).
 
 === Association extensions

data/doc/association_basics.rdoc

@@ -304,6 +304,11 @@ Examples:
 
 one_through_one associations do not have any modification methods added.
 
+Note that the remove_all_* method does not call remove hooks defined on
+the association, it just issues a single query to the database.  If you
+want to remove all associated objects and call remove hooks, iterate
+over the array of associated objects and call remove_* for each.
+
 == Caching
 
 Associations are cached after being retrieved:
@@ -1165,16 +1170,18 @@ Called after adding an object to the association:
 
 ==== :before_remove [+one_to_many+, +many_to_many+]
 
-Called before removing an object from the association:
+Called before removing an object from the association using <tt>remove_<i>association</i></tt>:
 
   class Artist
     # Don't allow removing a self-titled album
     one_to_many :albums, :before_remove=>proc{|ar, al| false if al.name == ar.name}
   end
 
+This is not called when using <tt>remove_all_<i>association</i></tt>.
+
 ==== :after_remove [+one_to_many+, +many_to_many+]
 
-Called after removing an object from the association:
+Called after removing an object from the association using <tt>remove_<i>association</i></tt>:
 
   class Artist
     # Log all disassociations of albums to an audit logging table
@@ -1187,6 +1194,8 @@ Called after removing an object from the association:
     end
   end
 
+This is not called when using <tt>remove_all_<i>association</i></tt>.
+
 ==== :before_set [+many_to_one+, +one_to_one+]
 
 Called before the _<i>association</i>= method is called to modify the objects:
@@ -1490,72 +1499,84 @@ by the foreign/primary keys.  This option causes the
 you want to replace the default foreign/primary key conditions that Sequel
 would use when eagerly graphing.
 
-=== Column Naming Conflict Options
+=== Associations Based on SQL Expressions Options
 
-Sequel's association support historically called methods on model objects
-to get primary key or foreign key values instead of accessing the column
-values directly, in order to allow advanced features such as associations
-based on virtual column keys.  Unfortunately, that causes issues if columns
-are used with names that clash with existing method names, which can happen
-if you want to name the association the same name as an existing column, or
-if the column has the same name as an already defined method such as
-<tt>object_id</tt>.
+Sequel's associations can work not just with columns, but also with
+arbitrary SQL expressions.  For example, on PostgreSQL, you can store
+foreign keys to other tables in hstore, json, or jsonb columns, and Sequel
+can automatically work with such constructs, including full support for
+eager loading.
 
-Sequel has added the following options that allow you to work around the
-issue by either specifying the column name symbol or the method name symbol
-to use.  In most cases, these methods are designed to be used with column
-aliases defined with <tt>Model.def_column_alias</tt>:
+There's actually two parts to supporting associations based on SQL
+expressions.  First is you must have an instance method in the model
+that returns the value that the SQL expression would return. Second
+is you must have an SQL expression object.  If Sequel has access to
+a model instance and needs to get the value of the expression, it
+calls the method to get the value.  If Sequel does not have access
+to a model instance, but needs to use the SQL expression in a query,
+it will use the SQL expression object.
+
+Below is an example storing foreign keys to other tables in a
+PostgreSQL hstore column, using the +pg_hstore+ and +pg_hstore_ops+
+extensions.
 
   # Example schema:
-  #  albums           artists
-  #   :id        /-->  :id
-  #   :artist --/      :name
+  #  albums          artists
+  #   :id       /---> :id
+  #   :meta ---/      :name
   #   :name
   class Album < Sequel::Model
-    def_column_alias(:artist_id, :artist)
-    many_to_one :artist, :key=>:artist_id, :key_column=>:artist
+    many_to_one :artist, :key_column=>Sequel.cast(Sequel.hstore(:meta)['artist_id'], Integer)
+
+    def artist_id
+      meta['artist_id'].to_i
+    end
+  end
+  class Artist < Sequel::Model
+    one_to_many :albums, :key=>Sequel.cast(Sequel.hstore(:meta)['artist_id'], Integer), :key_method=>:artist_id
   end
   
   # Example schema:
-  #  things              objs
-  #   :id           /-->  :id
-  #   :object_id --/      :name
-  #   :name
-  class Thing < Sequel::Model
-    def_column_alias(:obj_id, :object_id)
+  #  albums   albums_artists   artists
+  #   :id  <----- :meta -------> :id
+  #   :name                      :name
+  class Album < Sequel::Model
+    many_to_many :artists, :left_key=>Sequel.cast(Sequel.hstore(:meta)['album_id'], Integer),
+      :right_key=>Sequel.cast(Sequel.hstore(:meta)['artist_id'], Integer)
   end
-  class Obj < Sequel::Model
-    one_to_many :things, :key=>:object_id, :key_method=>:obj_id
+  class Artist < Sequel::Model
+    many_to_many :albums, :left_key=>Sequel.cast(Sequel.hstore(:meta)['artist_id'], Integer),
+      :right_key=>Sequel.cast(Sequel.hstore(:meta)['album_id'], Integer)
   end
 
 ==== :key_column [+many_to_one+]
 
 Like the :key option, but :key references the method name, while
-:key_column references the underlying column.
+:key_column references the underlying column/expression.
 
 ==== :primary_key_method [+many_to_one+]
 
-Like the :primary_key option, but :primary_key references the column
+Like the :primary_key option, but :primary_key references the column/expression
 name, while :primary_key_method references the method name.
 
 ==== :primary_key_column [+one_to_many+, +one_to_one+]
 
 Like the :primary_key option, but :primary_key references the method name, while
-:primary_key_column references the underlying column.
+:primary_key_column references the underlying column/expression.
 
 ==== :key_method [+one_to_many+, +one_to_one+]
 
-Like the :key option, but :key references the column
+Like the :key option, but :key references the column/expression
 name, while :key_method references the method name.
 
 ==== :left_primary_key_column [+many_to_many+, +one_through_one+]
 
 Like the :left_primary_key option, but :left_primary_key references the method name, while
-:left_primary_key_column references the underlying column.
+:left_primary_key_column references the underlying column/expression.
 
 ==== :right_primary_key_method [+many_to_many+, +one_through_one+]
 
-Like the :right_primary_key option, but :right_primary_key references the column
+Like the :right_primary_key option, but :right_primary_key references the column/expression
 name, while :right_primary_key_method references the method name.
 
 === Private Method Overriding Options

data/doc/model_hooks.rdoc

@@ -127,20 +127,22 @@ If you want to insert a row into the model's table without running the creation
 
   Album.insert(:name=>'RF') # does not run hooks
 
-== Halting Hook Processing
+== Canceling Actions in Hooks
 
-Sequel uses a convention that if any <tt>before_*</tt> hook method returns false (but not nil), that the action will be canceled and a <tt>Sequel::HookFailed</tt> raised (or +nil+ to be returned by +save+ if +raise_on_save_failure+ is +false+).  You can use this to implement validation-like behavior, that will run even if validations are skipped.  For example:
+Sometimes want to cancel an action in a before hook, so the action is not performed.  For example, you may want to not allow destroying or saving a record in certain cases.  In those cases, you can call +cancel_action+ inside the <tt>before_*</tt> hook, which will stop processing the hook and will either raise a <tt>Sequel::HookFailed</tt> exception (the default), or return +nil+ if +raise_on_save_failure+ is +false+).  You can use this to implement validation-like behavior, that will run even if validations are skipped:
 
   class Album < Sequel::Model
     def before_save
-      return false if name == ''
+      cancel_action if name == ''
       super
     end
   end
 
-While returning false is not really recommended, you should be aware of this behavior so that you do not inadvertently return false.  For around hooks, neglecting to call +super+ halts hook processing in the same way as returning +false+ in a before hook.  You can't halt hook processing in after hooks, since by then the main processing has already taken place.
+For backwards compatibility, Sequel also treats the <tt>before_*</tt> hook methods returning +false+ as an indication that the action should be canceled.  This usage is discouraged in new code, but you should be aware of this behavior so that you do not inadvertently return false.
 
-By default, Sequel runs hooks other than validation hooks inside a transaction, so if you abort the hook by returning false in a before hook or by raising an exception in any hook, Sequel will rollback the transaction.  However, note that the implicit use of transactions when saving and destroying model objects is conditional (it depends on the model instance's +use_transactions+ setting and the <tt>:transaction</tt> option passed to save).
+For around hooks, neglecting to call +super+ halts hook processing in the same way as calling +cancel_action+ in a before hook.  It's probably a bad idea to use +cancel_action+ hook processing in after hooks, or after yielding in around hooks, since by then the main processing has already taken place.
+
+By default, Sequel runs hooks other than validation hooks inside a transaction, so if you cancel the action by calling +cancel_action+ in any hook, Sequel will rollback the transaction.  However, note that the implicit use of transactions when saving and destroying model objects is conditional (it depends on the model instance's +use_transactions+ setting and the <tt>:transaction</tt> option passed to save).
 
 == Conditional Hooks
 

data/doc/release_notes/4.19.0.txt

@@ -0,0 +1,45 @@
+= New Features
+
+* Model#get_column_value and #set_column_value have been added for
+  getting/setting column values.  Historically, to get column
+  values, you would just send the column name, and to set column
+  values you would send the column name suffixed by =.  However,
+  this doesn't work when such methods are already defined by
+  ruby or Sequel itself (e.g. class, model, object_id).
+
+  Both #get_column_value and #set_column_value are just aliases to
+  #send, but you can safely override the methods to handle column
+  names that conflict with existing method names.  Both the core
+  model code and all of the plugins that ship with Sequel have
+  been updated to use these new methods.  External plugins are
+  strongly encouraged to switch to these new methods.
+
+* A column_conflicts plugin has been added to automatically handle
+  columns that conflict with existing method names.  So if you
+  have a column named "model" in your table, you can just load the
+  column_conflicts plugin and Sequel will handle things correctly.
+
+* A accessed_columns plugin has been added, which records which
+  columns have been accessed for a model instance.  This is useful
+  in development when you are planning on restricted the columns
+  selected by the dataset that retrieved the instance.  SELECTing
+  only the columns you need can result in significant performance
+  increases, and the accessed_columns plugin makes that easier.
+
+* Model#cancel_action has been added for canceling actions in
+  before hooks, instead of having the before hook methods return
+  false (which is still supported).  In addition to being easier to
+  use, this also makes it possible to use custom exception messages
+  for hook failures, if you are using the default behavior of raising
+  exceptions on save failures.
+
+= Other Improvements
+
+* Dataset#union, #intersect, and #except now automatically handle
+  datasets with raw SQL, by wrapping such datasets in subqueries.
+
+* The integer migrator now stores the correct migration number
+  when migrating with allow_missing_migration_files set.
+
+* A :timeout=>nil Database option on MySQL no longer sets a
+  wait_timeout.

data/doc/validations.rdoc

@@ -353,6 +353,10 @@ The <tt>:allow_blank</tt> is similar to the <tt>:allow_nil</tt> option, but inst
   a.website = ''
   a.valid? # true
 
+If you are going to use <tt>:allow_blank</tt> you should make sure that all objects respond to the blank? method. Sequel ships with an extension that will do this for you:
+
+  Sequel.extension :blank
+
 === <tt>:allow_missing</tt>
 
 The <tt>:allow_missing</tt> option is different from the <tt>:allow_nil</tt> option, in that instead of checking if the attribute value is nil, it checks if the attribute is present in the model instance's values hash.   <tt>:allow_nil</tt> will skip the validation when the attribute is in the values hash and has a nil value and when the attribute is not in the values hash.  <tt>:allow_missing</tt> will only skip the validation when the attribute is not in the values hash.  If the attribute is in the values hash but has a nil value, <tt>:allow_missing</tt> will not skip it.

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

@@ -274,9 +274,11 @@ module Sequel
       def mysql_connection_setting_sqls
         sqls = []
         
-        # Increase timeout so mysql server doesn't disconnect us
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
+        if wait_timeout = opts.fetch(:timeout, 2147483)
+          # Increase timeout so mysql server doesn't disconnect us
+          # Value used by default is maximum allowed value on Windows.
+          sqls << "SET @@wait_timeout = #{wait_timeout}"
+        end
 
         # By default, MySQL 'where id is null' selects the last inserted id
         sqls <<  "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]

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

@@ -56,8 +56,9 @@ module Sequel
          from{sa_describe_query("select * from #{im.call(table)}").as(:a)}.
          join(:syscolumn___b, :table_id=>:base_table_id, :column_id=>:base_column_id).
          order(:a__column_number).
-          map do |row|
-          row[:auto_increment] = row.delete(:is_autoincrement) == 1
+         map do |row|
+          auto_increment = row.delete(:is_autoincrement)
+          row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
           row[:allow_null] = row[:nulls_allowed].is_a?(Fixnum) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
           row[:db_type] = row.delete(:domain_name)

data/lib/sequel/dataset/sql.rb

@@ -827,7 +827,7 @@ module Sequel
     # Return a from_self dataset if an order or limit is specified, so it works as expected
     # with UNION, EXCEPT, and INTERSECT clauses.
     def compound_from_self
-      (@opts[:limit] || @opts[:order]) ? from_self : self
+      (@opts[:sql] || @opts[:limit] || @opts[:order]) ? from_self : self
     end
     
     private

data/lib/sequel/extensions/migration.rb

@@ -523,13 +523,12 @@ module Sequel
     def run
       migrations.zip(version_numbers).each do |m, v|
         t = Time.now
-        lv = up? ? v : v + 1
-        db.log_info("Begin applying migration version #{lv}, direction: #{direction}")
+        db.log_info("Begin applying migration version #{v}, direction: #{direction}")
         checked_transaction(m) do
           m.apply(db, direction)
-          set_migration_version(v)
+          set_migration_version(up? ? v : v-1)
         end
-        db.log_info("Finished applying migration version #{lv}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
+        db.log_info("Finished applying migration version #{v}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
       end
       
       target
@@ -565,11 +564,10 @@ module Sequel
       remove_migration_classes
 
       # load migration files
-      files[up? ? (current + 1)..target : (target + 1)..current].compact.each{|f| load(f)}
+      version_numbers.each{|n| load(files[n])}
       
       # get migration classes
-      classes = Migration.descendants
-      up? ? classes : classes.reverse
+      Migration.descendants
     end
     
     # Returns the latest version available in the specified directory.
@@ -606,7 +604,13 @@ module Sequel
     # so that each number in the array is the migration version
     # that will be in affect after the migration is run.
     def version_numbers
-      up? ? ((current+1)..target).to_a : (target..(current - 1)).to_a.reverse
+      versions = files.
+        compact.
+        map{|f| migration_version_from_file(File.basename(f))}.
+        select{|v| up? ? (v > current && v <= target) : (v <= current && v > target)}.
+        sort
+      versions.reverse! unless up?
+      versions
     end
   end
 

data/lib/sequel/model/associations.rb

@@ -355,7 +355,7 @@ module Sequel
 
         # The values that predicate_keys should match for objects to be associated.
         def predicate_key_values(object)
-          predicate_key_methods.map{|k| object.send(k)}
+          predicate_key_methods.map{|k| object.get_column_value(k)}
         end
 
         # Qualify +col+ with the given table name.  If +col+ is an array of columns,
@@ -732,7 +732,7 @@ module Sequel
         # many_to_one associations can only have associated objects if none of
         # the :keys options have a nil value.
         def can_have_associated_objects?(obj)
-          !self[:keys].any?{|k| obj.send(k).nil?}
+          !self[:keys].any?{|k| obj.get_column_value(k).nil?}
         end
         
         # Whether the dataset needs a primary key to function, false for many_to_one associations.
@@ -897,7 +897,7 @@ module Sequel
         # one_to_many associations can only have associated objects if none of
         # the :keys options have a nil value.
         def can_have_associated_objects?(obj)
-          !self[:primary_keys].any?{|k| obj.send(k).nil?}
+          !self[:primary_keys].any?{|k| obj.get_column_value(k).nil?}
         end
 
         # one_to_many and one_to_one associations can be clones
@@ -1120,7 +1120,7 @@ module Sequel
         # many_to_many associations can only have associated objects if none of
         # the :left_primary_keys options have a nil value.
         def can_have_associated_objects?(obj)
-          !self[:left_primary_keys].any?{|k| obj.send(k).nil?}
+          !self[:left_primary_keys].any?{|k| obj.get_column_value(k).nil?}
         end
 
         # one_through_one and many_to_many associations can be clones
@@ -1851,17 +1851,17 @@ module Sequel
       
           opts[:adder] ||= proc do |o|
             h = {}
-            lcks.zip(lcpks).each{|k, pk| h[k] = send(pk)}
-            rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.send(pk)}
+            lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
+            rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
             _join_table_dataset(opts).insert(h)
           end
 
           opts[:remover] ||= proc do |o|
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.send(k)})).delete
+            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
           end
 
           opts[:clearer] ||= proc do
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| send(k)})).delete
+            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
           end
         end
 
@@ -1898,7 +1898,7 @@ module Sequel
             pk_meths = opts.primary_key_methods
 
             eager_load_results(opts, eo) do |assoc_record|
-              hash_key = uses_cks ? pk_meths.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key_method)
+              hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
               if objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
               end
@@ -1919,7 +1919,7 @@ module Sequel
       
           return if opts[:read_only]
       
-          opts[:setter] ||= proc{|o| cks.zip(opts.primary_key_methods).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
+          opts[:setter] ||= proc{|o| cks.zip(opts.primary_key_methods).each{|k, pk| set_column_value(:"#{k}=", (o.get_column_value(pk) if o))}}
           opts[:_setter] = proc{|o| set_associated_object(opts, o)}
         end
         
@@ -1947,7 +1947,7 @@ module Sequel
 
             eager_load_results(opts, eo) do |assoc_record|
               assoc_record.values.delete(delete_rn) if delete_rn
-              hash_key = uses_cks ? km.map{|k| assoc_record.send(k)} : assoc_record.send(km)
+              hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
               next unless objects = h[hash_key]
               if assign_singular
                 objects.each do |object| 
@@ -1988,10 +1988,10 @@ module Sequel
 
           if one_to_one
             opts[:setter] ||= proc do |o|
-              up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| send(k)})))
+              up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
               if o
                 up_ds = up_ds.exclude(o.pk_hash) unless o.new?
-                cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
+                cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               end
               checked_transaction do
                 up_ds.update(ck_nil_hash)
@@ -2003,17 +2003,17 @@ module Sequel
             save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
             opts[:adder] ||= proc do |o|
-              cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
+              cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               o.save(save_opts)
             end
     
             opts[:remover] ||= proc do |o|
-              cks.each{|k| o.send(:"#{k}=", nil)}
+              cks.each{|k| o.set_column_value(:"#{k}=", nil)}
               o.save(save_opts)
             end
 
             opts[:clearer] ||= proc do
-              _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| send(k)}))).update(ck_nil_hash)
+              _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)}))).update(ck_nil_hash)
             end
           end
         end
@@ -2115,7 +2115,7 @@ module Sequel
 
         # Return the associated single object using a primary key lookup on the associated class.
         def _load_associated_object_via_primary_key(opts)
-          opts.associated_class.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| send(c)} : send(fk)))
+          opts.associated_class.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| get_column_value(c)} : get_column_value(fk)))
         end
 
         # Load the associated objects for the given association reflection and dynamic options
@@ -2315,7 +2315,7 @@ module Sequel
               raise Error, "callbacks should either be Procs or Symbols"
             end
             if res == false and stop_on_false
-              raise(BeforeHookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false") if raise_error
+              raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false") if raise_error
               return false
             end
           end
@@ -2729,17 +2729,17 @@ END
           vals = if obj.is_a?(Sequel::Dataset)
             {(keys.length == 1 ? keys.first : keys)=>obj.select(*meths).exclude(Sequel::SQL::BooleanExpression.from_value_pairs(meths.zip([]), :OR))}
           else
-            vals = Array(obj).reject{|o| !meths.all?{|m| o.send(m)}}
+            vals = Array(obj).reject{|o| !meths.all?{|m| o.get_column_value(m)}}
             return SQL::Constants::FALSE if vals.empty?
             if obj.is_a?(Array)
               if keys.length == 1
                 meth = meths.first
-                {keys.first=>vals.map{|o| o.send(meth)}}
+                {keys.first=>vals.map{|o| o.get_column_value(meth)}}
               else
-                {keys=>vals.map{|o| meths.map{|m| o.send(m)}}}
+                {keys=>vals.map{|o| meths.map{|m| o.get_column_value(m)}}}
               end  
             else
-              keys.zip(meths.map{|k| obj.send(k)})
+              keys.zip(meths.map{|k| obj.get_column_value(k)})
             end
           end
           SQL::BooleanExpression.from_value_pairs(vals)
@@ -2786,11 +2786,11 @@ END
                 a.each do |rec|
                   case key
                   when Array
-                    if (k = key.map{|k2| rec.send(k2)}) && k.all?
+                    if (k = key.map{|k2| rec.get_column_value(k2)}) && k.all?
                       id_map[k] << rec
                     end
                   when Symbol
-                    if k = rec.send(key)
+                    if k = rec.get_column_value(key)
                       id_map[k] << rec
                     end
                   else