ar-extensions 0.5.1

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

@@ -0,0 +1,70 @@
+module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
+
+  include ActiveRecord::Extensions::Import::ImportSupport  
+  include ActiveRecord::Extensions::Import::OnDuplicateKeyUpdateSupport
+  
+  # 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
+    post_sql_statements
+  end
+  
+  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 a generated ON DUPLICATE KEY UPDATE statement given the passed
+  # in +args+. 
+  def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    arg = args.first
+    if arg.is_a?( Array )
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, arg )
+    elsif arg.is_a?( Hash )
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, arg )
+    else
+      raise ArgumentError.new( "Expected Array or Hash" )
+    end
+    sql
+  end
+
+  def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
+    qt = quote_column_name( table_name )
+    results = arr.map do |column|
+      qc = quote_column_name( column )
+      "#{qt}.#{qc}=VALUES(#{qc})"        
+    end
+    results.join( ',' )
+  end
+  
+  def sql_for_on_duplicate_key_update_as_hash( table_name, hsh ) # :nodoc:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    qt = quote_column_name( table_name )
+    results = hsh.map do |column1, column2|
+      qc1 = quote_column_name( column1 )
+      qc2 = quote_column_name( column2 )
+      "#{qt}.#{qc1}=VALUES( #{qc2} )"
+    end
+    results.join( ',')
+  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
+  
+end
+
+ActiveRecord::ConnectionAdapters::MysqlAdapter.send( 'include', ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter )

data/lib/ar-extensions/temporary_table.rb

@@ -0,0 +1,124 @@
+module ActiveRecord::Extensions::TemporaryTableSupport # :nodoc:
+  def supports_temporary_tables? #:nodoc:
+    true
+  end
+end
+
+
+class ActiveRecord::Base
+  @@temporary_table_hsh ||= {}		
+
+  # Returns true if the underlying database connection supports temporary tables
+  def self.supports_temporary_tables?
+    connection.supports_temporary_tables?
+  rescue NoMethodError
+    false
+  end
+  
+  ######################################################################
+  # Creates a temporary table given the passed in options hash.  The
+  # temporary table is created based off from another table the
+  # current model class. This method returns the constant for the new
+  # new model. This can also be used with block form (see below).
+  # 
+  # == Parameters
+  # * options - the options hash used to define the temporary table. 
+  # 
+  # ==== Options
+  # * :table_name - the desired name of the temporary table. If not supplied \
+  #   then a name of "temp_" + the current table_name of the current model \
+  #   will be used.
+  # * :like - the table model you want to base the temporary tables \
+  #   structure off from. If this is not supplied then the table_name of the \
+  #   current model will be used.
+  # * :model_name - the name of the model you want to use for the temporary \
+  #   table. This must be compliant with Ruby's naming conventions for \
+  #   constants. If this is not supplied a rails-generated table name will \
+  #   be created which is based off from the table_name of the temporary table. \
+  #   IE: Account.create_temporary_table creates the TempAccount model class
+  #
+  # ==== Example 1, using defaults
+  #  class Project < ActiveRecord::Base ; end
+  #
+  #  Project.create_temporary_table
+  #
+  # This creates a temporary table named 'temp_projects' and creates a constant
+  # name TempProject. The table structure is copied from the _projects_ table.
+  #
+  # ==== Example 2, using :table_name and :model options
+  #   Project.create_temporary_table :table_name=>'my_projects', :model=>'MyProject'
+  #
+  # This creates a temporary table named 'my_projects' and creates a constant named
+  # MyProject. The table structure is copied from the _projects_ table.
+  #
+  # ==== Example 3, using :like
+  #   ActiveRecord::Base.create_temporary_table :like=>Project 
+  #  
+  # This is the same as calling Project.create_temporary_table.
+  #
+  # ==== Example 4, using block form
+  #   Project.create_temporary_table do |t|
+  #     # ...
+  #   end
+  # 
+  # Using the block form will automatically drop the temporary table
+  # when the block exits. _t_ which is passed into the block is the temporary
+  # table class. In the above example _t_ equals TempProject. The block form
+  # can be used with all of the available options.
+  #
+  # === See
+  # * drop
+  ######################################################################
+  def self.create_temporary_table( options={} )
+    options[:table_name] = "temp_#{self.table_name}" unless options[:table_name]
+    options[:like] = self unless options[:like]	
+    options[:temporary] = true if not options[:permanent] and not options.has_key?( :temporary )
+    table_name = options[:table_name]
+    model_name = options[:model_name] || Inflector.classify( table_name )	
+    raise Exception.new( "Model #{model_name} already exists! \n" ) if Object.const_defined? model_name 
+    
+    like_table_name = options[:like].table_name || self.table_name
+    sql = "CREATE #{options[:temporary] ? 'TEMPORARY' : ''} TABLE #{table_name} LIKE #{like_table_name}"
+    connection.execute( sql )		
+    
+    eval "class ::#{model_name} < #{ActiveRecord::TemporaryTable.name}
+					set_table_name :#{table_name}
+				end"
+
+    @@temporary_table_hsh[ model = Object.const_get( model_name ) ] = true
+
+    if block_given?
+      yield model
+      model.drop
+      nil
+    else
+      model
+    end
+  end
+
+end
+
+class ActiveRecord::TemporaryTable < ActiveRecord::Base
+  
+  # Drops a temporary table from the database and removes
+  # the temporary table constant.
+  #
+  # ==== Example
+  #   Project.create_temporary_table
+  #   Object.const_defined?( :TempProject ) # => true
+  #   TempProject.drop
+  #   Object.const_defined?( :TempProject ) # => false
+  #
+  def self.drop
+    if @@temporary_table_hsh[ self ]
+      sql = 'DROP TABLE ' + self.table_name + ';'
+      connection.execute( sql )
+      Object.send( :remove_const, self.name.to_sym )
+      @@temporary_table_hsh.delete( self )
+    else
+      raise StandardError.new "Trying to drop nonexistance temporary table: #{self.name}"
+    end
+  end
+  
+end
+

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

@@ -0,0 +1,3 @@
+class ActiveRecord::ConnectionAdapters::MysqlAdapter # :nodoc:
+  include ActiveRecord::Extensions::TemporaryTableSupport 
+end

data/lib/ar-extensions/version.rb

@@ -0,0 +1,8 @@
+module ActiveRecord # :nodoc:
+  module Extensions # :nodoc: 
+    module VERSION  
+      MAJOR, MINOR, REVISION = %W( 0 4 0 )
+      STRING = [ MAJOR, MINOR, REVISION ].join( '.' )
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.1
+specification_version: 1
+name: ar-extensions
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+date: 2007-03-15 00:00:00 -04:00
+summary: Extends ActiveRecord functionality.
+require_paths: 
+- lib
+email: zach.dennis@gmail.com
+homepage: http://www.continuousthinking.com/tags/arext
+rubyforge_project: arext
+description: Extends ActiveRecord functionality by adding better finder/query support, as well as supporting mass data import, foreign key, CSV and temporary tables
+autorequire: ar-extensions.rb
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Zach Dennis
+- Mark Van Holstyn
+files: 
+- init.rb
+- db/migrate
+- db/migrate/generic_schema.rb
+- db/migrate/mysql_schema.rb
+- db/migrate/version.rb
+- Rakefile
+- ChangeLog
+- README
+- config/database.yml
+- config/database.yml.template
+- config/mysql.schema
+- config/postgresql.schema
+- lib/ar-extensions.rb
+- lib/ar-extensions/csv.rb
+- lib/ar-extensions/extensions.rb
+- lib/ar-extensions/finders.rb
+- lib/ar-extensions/foreign_keys.rb
+- lib/ar-extensions/fulltext.rb
+- lib/ar-extensions/import.rb
+- lib/ar-extensions/temporary_table.rb
+- lib/ar-extensions/version.rb
+- lib/ar-extensions/adapters/abstract_adapter.rb
+- lib/ar-extensions/adapters/mysql_adapter.rb
+- lib/ar-extensions/adapters/postgresql.rb
+- lib/ar-extensions/fulltext/mysql.rb
+- lib/ar-extensions/import/mysql.rb
+- lib/ar-extensions/import/postgresql.rb
+- lib/ar-extensions/temporary_table/mysql.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.14.1
+    version: