Empact-ar-extensions 0.9.2

data/config/postgresql.schema

@@ -0,0 +1,39 @@
+CREATE TABLE topics (
+  id serial NOT NULL,
+  title character varying(255) default NULL,
+  author_name character varying(255) default NULL,
+  author_email_address character varying(255) default NULL,
+  written_on timestamp default NULL,
+  bonus_time time default NULL,
+  last_read date default NULL,
+  content text,
+  approved bool default TRUE,
+  replies_count integer default 0,
+  parent_id serial default NULL,
+  type character varying(50) default NULL,
+  PRIMARY KEY  (id)
+); 
+
+CREATE TABLE projects (
+  id serial NOT NULL,
+  name character varying(100) default NULL,
+  type character varying(255) NOT NULL,
+  PRIMARY KEY  (id)
+); 
+
+CREATE TABLE developers (
+  id serial NOT NULL,
+  name character varying(100) default NULL,
+  salary integer default 70000,
+  created_at timestamp default NULL,
+  updated_at timestamp default NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE books (
+  id serial NOT NULL,
+  title character varying(255) NOT NULL,
+  publisher character varying(255) NOT NULL,
+  author_name character varying(255) NOT NULL,
+  PRIMARY KEY (id)
+);

data/db/migrate/generic_schema.rb

@@ -0,0 +1,97 @@
+ActiveRecord::Schema.define do
+
+  create_table :schema_info, :force=>true do |t|
+    t.column :version, :integer, :unique=>true
+  end
+  SchemaInfo.create :version=>SchemaInfo::VERSION
+
+  create_table :group, :force => true do |t|
+    t.column :order, :string
+    t.timestamps
+  end
+
+  create_table :topics, :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :author_name, :string
+    t.column :author_email_address, :string
+    t.column :written_on, :datetime
+    t.column :bonus_time, :time
+    t.column :last_read, :datetime
+    t.column :content, :text
+    t.column :approved, :boolean, :default=>'1'
+    t.column :replies_count, :integer
+    t.column :parent_id, :integer
+    t.column :type, :string
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+
+  create_table :projects, :force=>true do |t|
+    t.column :name, :string
+    t.column :type, :string    
+  end
+  
+  create_table :developers, :force=>true do |t|
+    t.column :name, :string
+    t.column :salary, :integer, :default=>'70000'
+    t.column :created_at, :datetime
+    t.column :team_id, :integer
+    t.column :updated_at, :datetime
+  end
+
+  create_table :addresses, :force=>true do |t|
+    t.column :address, :string
+    t.column :city, :string
+    t.column :state, :string
+    t.column :zip, :string
+    t.column :developer_id, :integer
+  end
+
+  create_table :teams, :force=>true do |t|
+    t.column :name, :string
+  end
+  
+  create_table :books, :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :publisher, :string, :null=>false, :default => 'Default Publisher'
+    t.column :author_name, :string, :null=>false
+    t.column :created_at, :datetime
+    t.column :created_on, :datetime
+    t.column :updated_at, :datetime
+    t.column :updated_on, :datetime
+    t.column :publish_date, :date
+    t.column :topic_id, :integer
+    t.column :for_sale, :boolean, :default => true
+  end  
+
+  create_table :languages, :force=>true do |t|
+    t.column :name, :string
+    t.column :developer_id, :integer
+  end
+
+  create_table :shopping_carts, :force=>true do |t|
+    t.column :name, :string, :null => true
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+
+  create_table :cart_items, :force => true do |t|
+    t.column :shopping_cart_id, :string, :null => false
+    t.column :book_id, :string, :null => false
+    t.column :copies, :integer, :default => 1
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+
+  add_index :cart_items, [:shopping_cart_id, :book_id], :unique => true, :name => 'uk_shopping_cart_books'
+
+  create_table :animals, :force => true do |t|
+    t.column :name, :string, :null => false
+    t.column :size, :string, :default => nil
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+  
+  add_index :animals, [:name], :unique => true, :name => 'uk_animals'
+
+end

data/db/migrate/mysql_schema.rb

@@ -0,0 +1,32 @@
+ActiveRecord::Schema.define do
+ 
+  create_table :test_myisam, :options=>'ENGINE=MyISAM', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+  
+  create_table :test_innodb, :options=>'ENGINE=InnoDb', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+
+  create_table :test_memory, :options=>'ENGINE=Memory', :force=>true do |t|
+    t.column :my_name, :string, :null=>false
+    t.column :description, :string
+  end
+  
+  create_table :books, :options=>'ENGINE=MyISAM', :force=>true do |t|
+    t.column :title, :string, :null=>false
+    t.column :publisher, :string, :null=>false, :default => 'Default Publisher'
+    t.column :author_name, :string, :null=>false
+    t.column :created_at, :datetime
+    t.column :created_on, :datetime
+    t.column :updated_at, :datetime
+    t.column :updated_on, :datetime
+    t.column :publish_date, :date
+    t.column :topic_id, :integer
+    t.column :for_sale, :boolean, :default => true
+  end
+  execute "ALTER TABLE books ADD FULLTEXT( `title`, `publisher`, `author_name` )"
+
+end

data/db/migrate/oracle_schema.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Schema.define do
+ 
+  execute "CREATE SEQUENCE books_seq START_WITH 1"
+
+end

data/db/migrate/version.rb

@@ -0,0 +1,4 @@
+class SchemaInfo < ActiveRecord::Base
+  set_table_name 'schema_info'
+  VERSION = 12
+end

data/init.rb

@@ -0,0 +1,31 @@
+require 'ostruct'
+begin ; require 'active_record' ; rescue LoadError; require 'rubygems'; require 'active_record'; end
+
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'ar-extensions/util/support_methods'
+require 'ar-extensions/util/sql_generation'
+require 'ar-extensions/version'
+require 'ar-extensions/delete'
+require 'ar-extensions/extensions'
+require 'ar-extensions/create_and_update'
+require 'ar-extensions/finder_options'
+require 'ar-extensions/foreign_keys'
+require 'ar-extensions/fulltext'
+require 'ar-extensions/import'
+require 'ar-extensions/insert_select'
+require 'ar-extensions/finders'
+require 'ar-extensions/synchronize'
+require 'ar-extensions/temporary_table'
+require 'ar-extensions/union'
+require 'ar-extensions/adapters/abstract_adapter'
+
+#load all available functionality for specified adapter
+# Ex. ENV['LOAD_ADAPTER_EXTENSIONS'] = 'mysql'
+if ENV['LOAD_ADAPTER_EXTENSIONS']
+  require "active_record/connection_adapters/#{ENV['LOAD_ADAPTER_EXTENSIONS']}_adapter.rb"
+  file_regexp = File.join(File.dirname(__FILE__), 'lib', 'ar-extensions','**',
+                          "#{ENV['LOAD_ADAPTER_EXTENSIONS']}.rb")
+                        
+  Dir.glob(file_regexp){|file| require(file) }
+end

data/lib/ar-extensions.rb

@@ -0,0 +1,5 @@
+begin ; require 'rubygems' rescue LoadError; end
+require 'active_record' # ActiveRecord loads the Benchmark library automatically
+require 'active_record/version'
+
+require File.expand_path(File.join( File.dirname( __FILE__ ), '..', 'init.rb' ))

data/lib/ar-extensions/adapters/abstract_adapter.rb

@@ -0,0 +1,146 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter # :nodoc:
+      NO_MAX_PACKET = 0
+      QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
+      
+      def next_value_for_sequence(sequence_name)
+        %{#{sequence_name}.nextval}
+      end
+      
+      # +sql+ can be a single string or an array. If it is an array all 
+      # elements that are in position >= 1 will be appended to the final SQL.
+      def insert_many( sql, values, *args ) # :nodoc:
+        # the number of inserts default
+        number_of_inserts = 0
+        
+        base_sql,post_sql = if sql.is_a?( String )
+          [ sql, '' ]
+        elsif sql.is_a?( Array )
+          [ sql.shift, sql.join( ' ' ) ]
+        end
+        
+        sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size 
+
+        # the number of bytes the requested insert statement values will take up
+        values_in_bytes = self.class.sum_sizes( *values )
+        
+        # the number of bytes (commas) it will take to comma separate our values
+        comma_separated_bytes = values.size-1
+        
+        # the total number of bytes required if this statement is one statement
+        total_bytes = sql_size + values_in_bytes + comma_separated_bytes
+        
+        max = max_allowed_packet
+        
+        # if we can insert it all as one statement
+        if NO_MAX_PACKET == max or total_bytes < max
+          number_of_inserts += 1
+          sql2insert = base_sql + values.join( ',' ) + post_sql
+          insert( sql2insert, *args )
+        else
+          value_sets = self.class.get_insert_value_sets( values, sql_size, max )
+          value_sets.each do |values|
+            number_of_inserts += 1
+            sql2insert = base_sql + values.join( ',' ) + post_sql
+            insert( sql2insert, *args )
+          end
+        end        
+
+        number_of_inserts
+      end
+
+      def pre_sql_statements(options)
+        sql = []
+        sql << options[:pre_sql] if options[:pre_sql]
+        sql << options[:command] if options[:command]
+        sql << "IGNORE" if options[:ignore]
+
+        #add keywords like IGNORE or DELAYED
+        if options[:keywords].is_a?(Array)
+          sql.concat(options[:keywords])
+        elsif options[:keywords]
+          sql << options[:keywords].to_s
+        end
+
+        sql
+      end
+
+      # Synchronizes the passed in ActiveRecord instances with the records in
+      # the database by calling +reload+ on each instance.
+      def after_import_synchronize( instances )
+        instances.each { |e| e.reload }
+      end
+
+      # Returns an array of post SQL statements given the passed in options.
+      def post_sql_statements( table_name, options ) # :nodoc:
+        post_sql_statements = []
+        if options[:on_duplicate_key_update]
+          post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update] )
+        end
+
+        #custom user post_sql
+        post_sql_statements << options[:post_sql] if options[:post_sql]
+
+        #with rollup
+        post_sql_statements << rollup_sql if options[:rollup]
+
+        post_sql_statements
+      end
+
+
+      # Generates the INSERT statement used in insert multiple value sets.
+      def multiple_value_sets_insert_sql(table_name, column_names, options) # :nodoc:
+        "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{table_name} (#{column_names.join(',')}) VALUES "
+      end  
+
+      # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
+      # and +array_of_attributes+.
+      def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
+        values = []
+        array_of_attributes.each do |arr|
+          my_values = []
+          arr.each_with_index do |val,j|
+            my_values << quote( val, columns[j] )
+          end
+          values << my_values
+        end   
+        values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
+      end
+
+      # Returns the sum of the sizes of the passed in objects. This should
+      # probably be moved outside this class, but to where?
+      def self.sum_sizes( *objects ) # :nodoc:
+        objects.inject( 0 ){|sum,o| sum += o.size }
+      end
+            
+      # Returns the maximum number of bytes that the server will allow
+      # in a single packet
+      def max_allowed_packet
+        NO_MAX_PACKET
+      end
+      
+      def self.get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
+        value_sets = []          
+        arr, current_arr_values_size, current_size = [], 0, 0
+        values.each_with_index do |val,i|
+          comma_bytes = arr.size
+          sql_size_thus_far = sql_size + current_size + val.size + comma_bytes
+          if NO_MAX_PACKET == max_bytes or sql_size_thus_far <= max_bytes
+            current_size += val.size            
+            arr << val
+          else
+            value_sets << arr
+            arr = [ val ]
+            current_size = val.size
+          end
+          
+          # if we're on the last iteration push whatever we have in arr to value_sets
+          value_sets << arr if i == (values.size-1)
+        end
+        [ *value_sets ]
+      end     
+    
+    end
+  end
+end

data/lib/ar-extensions/adapters/mysql.rb

@@ -0,0 +1,10 @@
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  # Returns the maximum number of bytes that the server will allow
+  # in a single packet
+  def max_allowed_packet # :nodoc:
+    result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+    result.fetch_row[1].to_i
+  end
+
+  def rollup_sql; " WITH ROLLUP "; end
+end

data/lib/ar-extensions/adapters/oracle.rb

@@ -0,0 +1,14 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class OracleAdapter # :nodoc:
+      
+      def next_value_for_sequence(sequence_name)
+        %{#{sequence_name}.nextval}
+      end
+      
+      def supports_import?
+        true
+      end
+    end
+  end
+end

data/lib/ar-extensions/adapters/postgresql.rb

@@ -0,0 +1,9 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class PostgreSQLAdapter # :nodoc:
+      def next_value_for_sequence(sequence_name)
+        %{nextval('#{sequence_name}')}
+      end
+    end
+  end
+end

data/lib/ar-extensions/adapters/sqlite.rb

@@ -0,0 +1,7 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class SqliteAdapter # :nodoc:
+
+    end
+  end
+end

data/lib/ar-extensions/create_and_update.rb

@@ -0,0 +1,508 @@
+# ActiveRecord::Extensions::CreateAndUpdate extends ActiveRecord adding additionaly functionality for
+# insert and updates. Methods +create+, +update+, and +save+ accept
+# additional hash map of parameters to allow customization of database access.
+#
+# Include the appropriate adapter file in <tt>environment.rb</tt> to access this functionality
+#   require 'ar-extenstion/create_and_update/mysql'
+#
+# === Options
+# * <tt>:pre_sql</tt> inserts SQL before the +INSERT+ or +UPDATE+ command
+# * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+# * <tt>:keywords</tt> additional keywords to follow the command. Examples
+#   include +LOW_PRIORITY+, +HIGH_PRIORITY+, +DELAYED+
+# * <tt>:on_duplicate_key_update</tt> - an array of fields (or a custom string) specifying which parameters to
+#   update if there is a duplicate row (unique key violoation)
+# * <tt>:ignore => true </tt> - skips insert or update for duplicate existing rows on a unique key value
+# * <tt>:command</tt> an additional command to replace +INSERT+ or +UPDATE+
+# * <tt>:reload</tt> - If a duplicate is ignored (+ignore+) or updated with
+#   +on_duplicate_key_update+, the instance is reloaded to reflect the data
+#   in the database. If the record is not reloaded, it may contain stale data and
+#   <tt>stale_record?</tt> will evaluate to true. If the object is discared after
+#   create or update, it is preferrable to avoid reloading the record to avoid
+#   superflous queries
+# * <tt>:duplicate_columns</tt> - an Array required with +reload+ to specify the columns used
+#   to locate the duplicate record. These are the unique key columns.
+#   Refer to the documentation under the +duplicate_columns+ method.
+#
+#
+# === Create Examples
+# Assume that there is a unique key on the +name+ field
+#
+# Create a new giraffe, and ignore the error if a giraffe already exists
+# If a giraffe exists, then the instance of animal is stale, as it may not
+# reflect the data in the database.
+#  animal = Animal.create!({:name => 'giraffe', :size => 'big'}, :ignore => true)
+#
+#
+# Create a new giraffe; update the existing +size+ and +updated_at+ fields if the
+# giraffe already exists. The instance of animal is not stale and reloaded
+# to reflect the content in the database.
+#  animal = Animal.create({:name => 'giraffe', :size => 'big'},
+#                 :on_duplicate_key_update => [:size, :updated_at],
+#                 :duplicate_columns => [:name], :reload => true)
+#
+# Save a new giraffe, ignoring existing duplicates and inserting a comment
+# in the SQL before the insert.
+#  giraffe = Animal.new(:name => 'giraffe', :size => 'small')
+#  giraffe.save!(:ignore => true, :pre_sql => '/* My Comment */')
+#
+#
+# === Update Examples
+# Update the giraffe with the low priority keyword
+#  big_giraffe.update(:keywords => 'LOW_PRIORITY')
+#
+# Update an existing record. If a duplicate exists, it is updated with the
+# fields specified by +:on_duplicate_key_update+. The original instance(big_giraffe) is
+# deleted, and the instance is reloaded to reflect the database (giraffe).
+#  big_giraffe = Animal.create!(:name => 'big_giraffe', :size => 'biggest')
+#  big_giraffe.name = 'giraffe'
+#  big_giraffe.save(:on_duplicate_key_update => [:size, :updated_at],
+#                   :duplicate_columns => [:name], :reload => true)
+#
+# === Misc
+#
+# <tt>stale_record?</tt> - returns true if the record is stale
+# Example: <tt>animal.stale_record?</tt>
+#
+# == Developers
+# * Blythe Dunham http://blythedunham.com
+#
+# == Homepage
+# * Project Site: http://www.continuousthinking.com/tags/arext
+# * Rubyforge Project: http://rubyforge.org/projects/arext
+# * Anonymous SVN: svn checkout svn://rubyforge.org/var/svn/arext
+#
+
+module ActiveRecord::Extensions::ConnectionAdapters; end
+
+module ActiveRecord
+  module Extensions
+
+
+    # ActiveRecord::Extensions::CreateAndUpdate extends ActiveRecord adding additionaly functionality for
+    # insert and updates. Methods +create+, +update+, and +save+ accept
+    # additional hash map of parameters to allow customization of database access.
+    #
+    # Include the appropriate adapter file in <tt>environment.rb</tt> to access this functionality
+    #   require 'ar-extenstion/create_and_update/mysql'
+    #
+    # === Options
+    # * <tt>:pre_sql</tt> inserts +SQL+ before the +INSERT+ or +UPDATE+ command
+    # * <tt>:post_sql</tt> appends additional +SQL+ to the end of the statement
+    # * <tt>:keywords</tt> additional keywords to follow the command. Examples
+    #   include +LOW_PRIORITY+, +HIGH_PRIORITY+, +DELAYED+
+    # * <tt>:on_duplicate_key_update</tt> - an array of fields (or a custom string) specifying which parameters to
+    #   update if there is a duplicate row (unique key violoation)
+    # * <tt>:ignore => true </tt> - skips insert or update for duplicate existing rows on a unique key value
+    # * <tt>:command</tt> an additional command to replace +INSERT+ or +UPDATE+
+    # * <tt>:reload</tt> - If a duplicate is ignored (+ignore+) or updated with
+    #   +on_duplicate_key_update+, the instance is reloaded to reflect the data
+    #   in the database. If the record is not reloaded, it may contain stale data and
+    #   <tt>stale_record?</tt> will evaluate to true. If the object is discared after
+    #   create or update, it is preferrable to avoid reloading the record to avoid
+    #   superflous queries
+    # * <tt>:duplicate_columns</tt> - an Array required with +reload+ to specify the columns used
+    #   to locate the duplicate record. These are the unique key columns.
+    #   Refer to the documentation under the +duplicate_columns+ method.
+    #
+    #
+    # === Create Examples
+    # Assume that there is a unique key on the +name+ field
+    #
+    # Create a new giraffe, and ignore the error if a giraffe already exists
+    # If a giraffe exists, then the instance of animal is stale, as it may not
+    # reflect the data in the database.
+    #  animal = Animal.create!({:name => 'giraffe', :size => 'big'}, :ignore => true)
+    #
+    #
+    # Create a new giraffe; update the existing +size+ and +updated_at+ fields if the
+    # giraffe already exists. The instance of animal is not stale and reloaded
+    # to reflect the content in the database.
+    #  animal = Animal.create({:name => 'giraffe', :size => 'big'},
+    #                 :on_duplicate_key_update => [:size, :updated_at],
+    #                 :duplicate_columns => [:name], :reload => true)
+    #
+    # Save a new giraffe, ignoring existing duplicates and inserting a comment
+    # in the SQL before the insert.
+    #  giraffe = Animal.new(:name => 'giraffe', :size => 'small')
+    #  giraffe.save!(:ignore => true, :pre_sql => '/* My Comment */')
+    #
+    #
+    # === Update Examples
+    # Update the giraffe with the low priority keyword
+    #  big_giraffe.update(:keywords => 'LOW_PRIORITY')
+    #
+    # Update an existing record. If a duplicate exists, it is updated with the
+    # fields specified by +:on_duplicate_key_update+. The original instance(big_giraffe) is
+    # deleted, and the instance is reloaded to reflect the database (giraffe).
+    #  big_giraffe = Animal.create!(:name => 'big_giraffe', :size => 'biggest')
+    #  big_giraffe.name = 'giraffe'
+    #  big_giraffe.save(:on_duplicate_key_update => [:size, :updated_at],
+    #                   :duplicate_columns => [:name], :reload => true)
+    #
+    module CreateAndUpdate
+
+      class NoDuplicateFound < Exception; end
+
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+        base.extend(ActiveRecord::Extensions::SqlGeneration)
+
+        #alias chain active record methods if they have not already
+        #been chained
+        unless base.method_defined?(:save_without_extension)
+          base.class_eval do
+            [:save, :update, :save!, :create_or_update, :create].each { |method|  alias_method_chain method, :extension }
+
+            class << self
+              [:create, :create!].each {|method| alias_method_chain method, :extension }
+            end
+
+          end
+        end
+      end
+
+      def supports_create_and_update? #:nodoc:
+        true
+      end
+
+      module ClassMethods#:nodoc:
+
+        # Creates an object, instantly saves it as a record (if the validation permits it), and returns it. If the save
+        # fails under validations, the unsaved object is still returned.
+        def create_with_extension(attributes = nil, options={}, &block)#:nodoc:
+          return create_without_extension(attributes, &block) unless options.any?
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr, &block) }
+          else
+            object = new(attributes)
+            yield(object) if block_given?
+            object.save(options)
+            object
+          end
+        end
+
+        # Creates an object just like Base.create but calls save! instead of save
+        # so an exception is raised if the record is invalid.
+        def create_with_extension!(attributes = nil, options={}, &block)#:nodoc:
+          return create_without_extension!(attributes, &block) unless options.any?
+          create_with_extension(attributes, options.merge(:raise_exception => true), &block)
+        end
+
+      end#ClassMethods
+
+
+      def save_with_extension(options={})#:nodoc:
+
+        #invoke save_with_validation if the argument is not a hash
+        return save_without_extension(options) if !options.is_a?(Hash)
+        return save_without_extension unless options.any?
+
+        perform_validation = options.delete(:perform_validation)
+        raise_exception = options.delete(:raise_exception)
+
+        if (perform_validation.is_a?(FalseClass)) || valid?
+          raise ActiveRecord::ReadOnlyRecord if readonly?
+          create_or_update(options)
+        else
+          raise ActiveRecord::RecordInvalid.new(self) if raise_exception
+          false
+        end
+      end
+
+      def save_with_extension!(options={})#:nodoc:
+
+        return save_without_extension!(options) if !options.is_a?(Hash)
+        return save_without_extension! unless options.any?
+
+        save_with_extension(options.merge(:raise_exception => true)) || raise(ActiveRecord::RecordNotSaved)
+      end
+
+      #overwrite the create_or_update to call into
+      #the appropriate method create or update with the new options
+      #call the callbacks here
+      def create_or_update_with_extension(options={})#:nodoc:
+        return create_or_update_without_extension unless options.any?
+
+        return false if callback(:before_save) == false
+        raise ReadOnlyRecord if readonly?
+        result = new_record? ? create(options) : update(@attributes.keys, options)
+        callback(:after_save)
+
+        result != false
+      end
+
+
+      # Updates the associated record with values matching those of the instance attributes.
+      def update_with_extension(attribute_names = @attributes.keys, options={})#:nodoc:
+
+        return update_without_extension unless options.any?
+
+        check_insert_and_update_arguments(options)
+
+        return false if callback(:before_update) == false
+        insert_with_timestamps(false)
+
+        #set the command to update unless specified
+        #remove the duplicate_update_key if any
+        sql_options = options.dup
+        sql_options[:command]||='UPDATE'
+        sql_options.delete(:on_duplicate_key_update)
+
+        quoted_attributes = attributes_with_quotes(false, false, attribute_names)
+        return 0 if quoted_attributes.empty?
+
+        locking_sql = update_locking_sql
+
+        sql = self.class.construct_ar_extension_sql(sql_options) do |sql, o|
+          sql << "#{self.class.quoted_table_name} "
+          sql << "SET #{quoted_comma_pair_list(connection, quoted_attributes)} " +
+            "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}"
+          sql << locking_sql if locking_sql
+        end
+
+
+        reloaded = false
+
+        begin
+          affected_rows = connection.update(sql,
+            "#{self.class.name} Update X #{'With optimistic locking' if locking_sql} ")
+          #raise exception if optimistic locking is enabled and no rows were updated
+          raise ActiveRecord::StaleObjectError, "#{affected_rows} Attempted to update a stale object" if locking_sql && affected_rows != 1
+          @stale_record = (affected_rows == 0)
+          callback(:after_update)
+
+          #catch the duplicate error and update the existing record
+        rescue Exception => e
+          if (duplicate_columns(options) && options[:on_duplicate_key_update] &&
+                connection.respond_to?('duplicate_key_update_error?') &&
+                connection.duplicate_key_update_error?(e))
+            update_existing_record(options)
+            reloaded = true
+          else
+            raise
+          end
+        end
+
+        load_duplicate_record(options) if options[:reload] && !reloaded
+
+        return true
+      end
+
+      # Creates a new record with values matching those of the instance attributes.
+      def create_with_extension(options={})#:nodoc:
+        return create_without_extension unless options.any?
+
+        check_insert_and_update_arguments(options)
+
+        return 0 if callback(:before_create) == false
+        insert_with_timestamps(true)
+
+        if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
+          self.id = connection.next_sequence_value(self.class.sequence_name)
+
+        end
+
+        quoted_attributes = attributes_with_quotes
+
+        statement = if quoted_attributes.empty?
+          connection.empty_insert_statement(self.class.table_name)
+        else
+          options[:command]||='INSERT'
+          sql = self.class.construct_ar_extension_sql(options) do |sql, options|
+            sql << "INTO #{self.class.table_name} (#{quoted_column_names.join(', ')}) "
+            sql << "VALUES(#{attributes_with_quotes.values.join(', ')})"
+          end
+        end
+
+        self.id = connection.insert(statement, "#{self.class.name} Create X",
+          self.class.primary_key, self.id, self.class.sequence_name)
+
+
+        @new_record = false
+
+        #most adapters update the insert id number even if nothing was
+        #inserted. Reset to 0 for all :on_duplicate_key_update
+        self.id = 0 if options[:on_duplicate_key_update]
+
+
+        #the record was not created. Set the value to stale
+        if self.id == 0
+          @stale_record = true
+          load_duplicate_record(options) if options[:reload]
+        end
+
+        callback(:after_create)
+
+        self.id
+      end
+
+      # Replace deletes the existing duplicate if one exists and then
+      # inserts the new record. Foreign keys are updated only if
+      # performed by the database.
+      #
+      # The +options+ hash accepts the following attributes:
+      # * <tt>:pre_sql</tt> - sql that appears before the query
+      # * <tt>:post_sql</tt> - sql that appears after the query
+      # * <tt>:keywords</tt> - text that appears after the 'REPLACE' command
+      #
+      # ==== Examples
+      # Replace a single object
+      #   user.replace
+
+      def replace(options={})
+        options.assert_valid_keys(:pre_sql, :post_sql, :keywords)
+        create_with_extension(options.merge(:command => 'REPLACE'))
+      end
+
+      # Returns true if the record data is stale
+      # This can occur when creating or updating a record with
+      # options <tt>:on_duplicate_key_update</tt> or <tt>:ignore</tt>
+      # without reloading(<tt> :reload  => true</tt>)
+      #
+      # In other words, the attributes of a stale record may not reflect those
+      # in the database
+      def stale_record?; @stale_record.is_a?(TrueClass); end
+
+      # Reload Duplicate records like +reload_duplicate+ but
+      # throw an exception if no duplicate record is found
+      def reload_duplicate!(options={})
+        options.assert_valid_keys(:duplicate_columns, :force, :delete)
+        raise NoDuplicateFound.new("Record is not stale") if !stale_record? and !options[:force].is_a?(TrueClass)
+        load_duplicate_record(options.merge(:reload => true))
+      end
+
+      # Reload the record's duplicate based on the
+      # the duplicate_columns. Returns true if the reload was successful.
+      # <tt>:duplicate_columns</tt> - the columns to search on
+      # <tt>:force</tt> - force a reload even if the record is not stale
+      # <tt>:delete</tt> - delete the existing record if there is one. Defaults to true
+      def reload_duplicate(options={})
+        reload_duplicate!(options)
+      rescue NoDuplicateFound => e
+        return false
+      end
+      protected
+
+      # Returns the list of fields for which there is a unique key.
+      # When reloading duplicates during updates, with the <tt> :reload => true </tt>
+      # the reloaded existing duplicate record is the one matching the attributes specified
+      # by +duplicate_columns+.
+      #
+      # This data can either be passed into the save command, or the
+      # +duplicate_columns+ method can be overridden in the
+      # ActiveRecord subclass to return the columns with a unique key
+      #
+      # ===Example
+      # User has a unique key on name. If a user exists already
+      # the user object will be replaced by the existing user
+      #   user.name = 'blythe'
+      #   user.save(:ignore => true, :duplicate_columns => 'name', :reload => true)
+      #
+      # Alternatively, the User class can be overridden
+      #   class User
+      #     protected
+      #       def duplicate_columns(options={}); [:name]; end
+      #   end
+      #
+      # Then, the <tt>:duplicate_columns</tt> field is not needed during save
+      #   user.update(:on_duplicate_key_update => [:password, :updated_at], :reload => true)
+      #
+
+      def duplicate_columns(options={})
+        options[:duplicate_columns]
+      end
+
+      #update timestamps
+      def insert_with_timestamps(bCreate=true)#:nodoc:
+        if record_timestamps
+          t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
+          write_attribute('created_at', t) if bCreate && respond_to?(:created_at) && created_at.nil?
+          write_attribute('created_on', t) if bCreate && respond_to?(:created_on) && created_on.nil?
+
+          write_attribute('updated_at', t) if respond_to?(:updated_at)
+          write_attribute('updated_on', t) if respond_to?(:updated_on)
+        end
+      end
+
+      # Update the optimistic locking column and
+      # return the sql necessary. update_with_lock is not called
+      # since update_x is aliased to update
+      def update_locking_sql()#:nodoc:
+        if locking_enabled?
+          lock_col = self.class.locking_column
+          previous_value = send(lock_col)
+          send(lock_col + '=', previous_value + 1)
+          " AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}"
+        else
+          nil
+        end
+      end
+
+
+      def duplicate_option_check?(options)#:nodoc:
+        options.has_key?(:on_duplicate_key_update) ||
+          options[:keywords].to_s.downcase == 'ignore' ||
+          options[:ignore]
+      end
+
+      #Update the existing record with the new data from the duplicate column fields
+      #automatically delete and reload the object
+      def update_existing_record(options)#:nodoc:
+        load_duplicate_record(options.merge(:reload => true)) do |record|
+          updated_attributes = options[:on_duplicate_key_update].inject({}) {|map, attribute| map[attribute] = self.send(attribute); map}
+          record.update_attributes(updated_attributes)
+        end
+      end
+
+      #reload the record's duplicate based on the
+      #the duplicate_columns parameter or overwritten function
+      def load_duplicate_record(options, &block)#:nodoc:
+
+        search_columns = duplicate_columns(options)
+
+        #search for the existing columns
+        conditions = search_columns.inject([[],{}]){|sql, field|
+          sql[0] << "#{field} = :#{field}"
+          sql[1][field] = send(field)
+          sql
+        }
+
+        conditions[0] = conditions[0].join(' and ')
+
+        record = self.class.find :first, :conditions => conditions
+
+        raise NoDuplicateFound.new("Cannot find duplicate record.") if record.nil?
+
+        yield record if block
+
+        @stale_record = true
+
+        if options[:reload]
+          #do not delete new records, the same record or
+          #if user specified not to delete
+          if self.id.to_i > 0 && self.id != record.id && !options[:delete].is_a?(FalseClass)
+            self.class.delete_all(['id = ?', self.id])
+          end
+          reset_to_record(record)
+        end
+        true
+      end
+      #reload this object to the specified record
+      def reset_to_record(record)#:nodoc:
+        self.id = record.id
+        self.reload
+        @stale_record = false
+      end
+
+      #assert valid options
+      #ensure that duplicate_columns are specified with reload
+      def check_insert_and_update_arguments(options)#:nodoc:
+        options.assert_valid_keys([:on_duplicate_key_update, :reload, :command, :ignore, :pre_sql, :post_sql, :keywords, :duplicate_columns])
+        if duplicate_columns(options).blank? && duplicate_option_check?(options) && options[:reload]
+          raise(ArgumentError, "Unknown key: on_duplicate_key_update is not supported for updates without :duplicate_columns")
+        end
+      end
+    end
+  end
+end