ghazel-ar-extensions 0.9.3

data/lib/ar-extensions/temporary_table.rb

@@ -0,0 +1,131 @@
+module ActiveRecord::Extensions::TemporaryTableSupport # :nodoc:
+  def supports_temporary_tables? #:nodoc:
+    true
+  end
+end
+
+class ActiveRecord::Base
+  # 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
+  # <tt>:table_name</tt>::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.
+  # <tt>:like</tt>:: 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.
+  # <tt>:model_name</tt>:: 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
+  #
+  #  > t = Project.create_temporary_table
+  #  > t.class
+  #  => "TempProject"
+  #  > t.superclass
+  #  => Project
+  #
+  # This creates a temporary table named 'temp_projects' and creates a constant
+  # name TempProject. The table structure is copied from the 'projects' table. 
+  # TempProject is a subclass of Project as you would expect.
+  #
+  # ==== Example 2, using <tt>:table_name</tt> and <tt>:model options</tt>
+  #
+  #   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 <tt>:like</tt>
+  #
+  #   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(opts={})
+    opts[:temporary]  ||= !opts[:permanent]
+    opts[:like]       ||= self
+    opts[:table_name] ||= "temp_#{self.table_name}"
+    opts[:model_name] ||= ActiveSupport::Inflector.classify(opts[:table_name])
+
+    if Object.const_defined?(opts[:model_name])
+      raise Exception, "Model #{opts[:model_name]} already exists!"
+    end
+
+    like_table_name = opts[:like].table_name || self.table_name
+
+    connection.execute <<-SQL
+      CREATE #{opts[:temporary] ? 'TEMPORARY' : ''} TABLE #{opts[:table_name]}
+        LIKE #{like_table_name}
+    SQL
+    
+    # Sample evaluation:
+    #
+    #   class ::TempFood < Food
+    #     set_table_name :temp_food
+    #
+    #     def self.drop
+    #       connection.execute "DROP TABLE temp_foo"
+    #       Object.send(:remove_const, self.name.to_sym)
+    #     end
+    #   end
+    class_eval(<<-RUBY, __FILE__, __LINE__)
+      class ::#{opts[:model_name]} < #{self.name}
+        set_table_name :#{opts[:table_name]}
+
+        def self.drop
+          connection.execute "DROP TABLE #{opts[:table_name]};"
+          Object.send(:remove_const, self.name.to_sym)
+        end
+      end
+    RUBY
+
+    model = Object.const_get(opts[:model_name])
+
+    if block_given?
+      begin
+        yield(model)
+      ensure
+        model.drop
+      end
+    else
+      return model
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+#insert select functionality is dependent on finder options
+require 'ar-extensions/finder_options/mysql'
+
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::Union::UnionSupport
+end

data/lib/ar-extensions/union.rb

@@ -0,0 +1,204 @@
+module ActiveRecord::Extensions::Union#:nodoc:
+  module UnionSupport #:nodoc:
+    def supports_union? #:nodoc:
+      true
+    end
+  end
+end
+
+class ActiveRecord::Base
+  supports_extension :union
+
+  extend ActiveRecord::Extensions::SqlGeneration
+  class << self
+    # Find a union of two or more queries
+    # === Args
+    # Each argument is a hash map of options sent to <tt>:find :all</tt>
+    # including <tt>:conditions</tt>, <tt>:join</tt>, <tt>:group</tt>,
+    # <tt>:having</tt>, and <tt>:limit</tt>
+    #
+    # In addition the following options are accepted
+    # * <tt>:pre_sql</tt> inserts SQL before the SELECT statement of this protion of the +union+
+    # * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+    # * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+    #
+    # == Examples
+    # Find the union of a San Fran zipcode with a Seattle zipcode
+    #    union_args1 = {:conditions => ['zip_id = ?', 94010], :select => :phone_number_id}
+    #    union_args2 = {:conditions => ['zip_id = ?', 98102], :select => :phone_number_id}
+    #    Contact.find_union(union_args1, union_args2, ...)
+    #
+    #    SQL>  (SELECT phone_number_id FROM contacts WHERE zip_id = 94010) UNION
+    #          (SELECT phone_number_id FROM contacts WHERE zip_id = 98102) UNION ...
+    #
+    # == Global Options
+    # To specify global options that apply to the entire union, specify a hash as the
+    # first parameter with a key <tt>:union_options</tt>. Valid options include
+    # <tt>:group</tt>, <tt>:having</tt>, <tt>:order</tt>, and <tt>:limit</tt>
+    #
+    #
+    # Example:
+    #  Contact.find_union(:union_options => {:limit => 10, :order => 'created_on'},
+    #  union_args1, union_args2, ...)
+    #
+    #  SQL> ((select phone_number_id from contacts ...) UNION (select phone_number_id from contacts ...)) order by created_on limit 10
+    #
+    def find_union(*args)
+      supports_union!
+      find_by_sql(find_union_sql(*args))
+    end
+
+    # Count across a union of two or more queries
+    # === Args
+    # * +column_name+ - The column to count. Defaults to all ('*')
+    # * <tt>*args</tt> - Each additional argument is a hash map of options used by <tt>:find :all</tt>
+    # including <tt>:conditions</tt>, <tt>:join</tt>, <tt>:group</tt>,
+    # <tt>:having</tt>, and <tt>:limit</tt>
+    #
+    # In addition the following options are accepted
+    # * <tt>:pre_sql</tt> inserts SQL before the SELECT statement of this protion of the +union+
+    # * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+    # * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+    #
+    # Note that distinct is implied so a record that matches more than one
+    # portion of the union is counted only once.
+    #
+    # == Global Options
+    # To specify global options that apply to the entire union, specify a hash as the
+    # first parameter with a key <tt>:union_options</tt>. Valid options include
+    # <tt>:group</tt>, <tt>:having</tt>, <tt>:order</tt>, and <tt>:limit</tt>
+    #
+    # == Examples
+    # Count the number of people who live in Seattle and San Francisco
+    #  Contact.count_union(:phone_number_id,
+    #        {:conditions => ['zip_id = ?, 94010]'},
+    #        {:conditions => ['zip_id = ?', 98102]})
+    #  SQL> select count(*) from ((select phone_number_id from contacts ...) UNION (select phone_number_id from contacts ...)) as counter_tbl;
+    def count_union(column_name, *args)
+      supports_union!
+      count_val = calculate_union(:count, column_name, *args)
+      (args.length == 1 && args.first[:limit] && args.first[:limit].to_i < count_val) ? args.first[:limit].to_i : count_val
+    end
+
+    protected
+
+    #do a union of specified calculation. Only for simple calculations
+    def calculate_union(operation, column_name, *args)#:nodoc:
+      union_options = remove_union_options(args)
+
+
+      if args.length == 1
+        column_name     = '*' if column_name == :all
+        calculate(operation, column_name, args.first.update(union_options))
+
+      # For more than one map of options, count off the subquery of all the column_name fields unioned together
+      # For example, if column_name is phone_number_id the generated query is
+      #  Contact.calculate_union(:count, :phone_number_id, args)
+      #  SQL> select count(*) from
+      #     ((select phone_number_id from contacts ...)
+      #      UNION
+      #     (select phone_number_id from contacts ...)) as counter_tbl
+      else
+        column_name     = primary_key if column_name == :all
+        column          = column_for column_name
+        column_name     = "#{table_name}.#{column_name}" unless column_name.to_s.include?('.')
+
+        group_by = union_options.delete(:group)
+        having = union_options.delete(:having)
+        query_alias = union_options.delete(:query_alias)||"#{operation}_giraffe"
+
+
+        #aggregate_alias should be table_name_id
+        aggregate_alias = column_alias_for('', column_name)
+        #main alias is operation_table_name_id
+        main_aggregate_alias = column_alias_for(operation, column_name)
+
+        sql = "SELECT "
+        sql << (group_by ? "#{group_by}, #{operation}(#{aggregate_alias})" : "#{operation}(*)")
+        sql << " AS #{main_aggregate_alias}"
+        sql << " FROM ("
+
+        #by nature of the union the results will always be distinct, so remove distinct column here
+        sql << args.inject([]){|l, a|
+          calc = "(#{construct_calculation_sql_with_extension('', column_name, a)})"
+          #for group by we need to select the group by column also
+          calc.gsub!(" AS #{aggregate_alias}", " AS #{aggregate_alias}, #{group_by} ") if group_by
+          l <<  calc
+        }.join(" UNION ")
+
+        add_union_options!(sql, union_options)
+
+        sql << ") as #{query_alias}"
+
+        if group_by
+          #add groupings
+          sql << " GROUP BY #{group_by}"
+          sql << " HAVING #{having}" if having
+
+          calculated_data = connection.select_all(sql)
+
+          calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
+            key   = type_cast_calculated_value(row[group_by], column_for(group_by.to_s))
+            value = row[main_aggregate_alias]
+            all << [key, type_cast_calculated_value(value, column_for(column), operation)]
+          end
+
+        else
+          count_by_sql(sql)
+        end
+      end
+    end
+
+
+    #Add Global Union options
+    def add_union_options!(sql, options)#:nodoc:
+      sql << " GROUP BY #{options[:group]} " if options[:group]
+
+      if options[:order] || options[:limit]
+        scope = scope(:find)
+        add_order!(sql, options[:order], scope)
+        add_limit!(sql, options, scope)
+      end
+      sql
+    end
+
+    #Remove the global union options
+    def remove_union_options(args)#:nodoc:
+      args.first.is_a?(Hash) && args.first.has_key?(:union_options)  ? (args.shift)[:union_options] : {}
+    end
+
+    def construct_calculation_sql_with_extension(operation, column_name, options)
+      construct_ar_extension_sql(options.merge(:command => '', :keywords => nil, :distinct => nil)) {|sql, o|
+        calc_sql = construct_calculation_sql(operation, column_name, options)
+
+        #this is really gross but prevents us from rewriting construct_calculation_sql
+        calc_sql.gsub!(/^SELECT\s/, "SELECT #{options[:keywords]} ") if options[:keywords]
+
+        sql << calc_sql
+      }
+    end
+
+    # Return the sql for union of the query options specified on the command line
+    # If the first parameter is a map containing :union_options, use these
+    def find_union_sql(*args)#:nodoc:
+      options = remove_union_options(args)
+
+      if args.length == 1
+        return finder_sql_to_string(args.first.update(options))
+      end
+
+      sql = args.inject([]) do |sql_list, union_args|
+        part = union_args.merge(:force_eager_load => true,
+                                :override_select => union_args[:select]||"#{quoted_table_name}.*",
+                                :select => nil)
+        sql_list << "(#{finder_sql_to_string(part)})"
+        sql_list
+      end.join(" UNION ")
+
+
+      add_union_options!(sql, options)
+      sql
+    end
+  end
+end
+

data/lib/ar-extensions/util/sql_generation.rb

@@ -0,0 +1,27 @@
+
+#Extend this module on ActiveRecord to access global functions
+module ActiveRecord
+  module Extensions
+    module SqlGeneration#:nodoc:
+
+      protected
+
+      def post_sql_statements(options)#:nodoc:
+        connection.post_sql_statements(quoted_table_name, options).join(' ')
+      end
+
+      def pre_sql_statements(options)#:nodoc:
+        connection.pre_sql_statements({:command => 'SELECT'}.merge(options)).join(' ').strip + " "
+      end
+
+      def construct_ar_extension_sql(options={}, valid_options = [], &block)#:nodoc:
+        options.assert_valid_keys(valid_options)if valid_options.any?
+
+        sql = pre_sql_statements(options)
+        yield sql, options
+        sql << post_sql_statements(options)
+        sql
+      end
+    end
+  end
+end

data/lib/ar-extensions/util/support_methods.rb

@@ -0,0 +1,32 @@
+#Extend this module on ActiveRecord to access global functions
+class ExtensionNotSupported < Exception; end;
+
+module ActiveRecord
+  module Extensions
+    module SupportMethods#:nodoc:
+      def supports_extension(name)
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          def self.supports_#{name}?#:nodoc:
+            connection.supports_#{name}?
+          rescue NoMethodError
+           false
+          end
+
+          def supports_#{name}?#:nodoc:
+            self.class.supports_#{name}?
+          end
+
+          def self.supports_#{name}!#:nodoc:
+            supports_#{name}? or raise ExtensionNotSupported.new("#{name} extension is not supported. Please require the adapter file.")
+          end
+
+          def supports_#{name}!#:nodoc:
+            self.class.supports_#{name}!
+          end
+        EOS
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend, ActiveRecord::Extensions::SupportMethods

data/lib/ar-extensions/version.rb

@@ -0,0 +1,9 @@
+
+module ActiveRecord # :nodoc:
+  module Extensions # :nodoc: 
+    module VERSION  
+      MAJOR, MINOR, REVISION = %W( 0 9 2 )
+      STRING = [ MAJOR, MINOR, REVISION ].join( '.' )
+    end
+  end
+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' ))

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: ghazel-ar-extensions
+version: !ruby/object:Gem::Version 
+  version: 0.9.3
+platform: ruby
+authors: 
+- Zach Dennis
+- Mark Van Holstyn
+- Blythe Dunham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.1"
+    version: 
+description: Extends ActiveRecord functionality by adding better finder/query support, as well as supporting mass data import, foreign key, CSV and temporary tables
+email: zach.dennis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- init.rb
+- db/migrate/generic_schema.rb
+- db/migrate/mysql_schema.rb
+- db/migrate/oracle_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/adapters/abstract_adapter.rb
+- lib/ar-extensions/adapters/mysql.rb
+- lib/ar-extensions/adapters/oracle.rb
+- lib/ar-extensions/adapters/postgresql.rb
+- lib/ar-extensions/adapters/sqlite.rb
+- lib/ar-extensions/create_and_update/mysql.rb
+- lib/ar-extensions/create_and_update.rb
+- lib/ar-extensions/csv.rb
+- lib/ar-extensions/delete/mysql.rb
+- lib/ar-extensions/delete.rb
+- lib/ar-extensions/extensions.rb
+- lib/ar-extensions/finders.rb
+- lib/ar-extensions/finder_options/mysql.rb
+- lib/ar-extensions/finder_options.rb
+- lib/ar-extensions/foreign_keys.rb
+- lib/ar-extensions/fulltext/mysql.rb
+- lib/ar-extensions/fulltext.rb
+- lib/ar-extensions/import/mysql.rb
+- lib/ar-extensions/import/postgresql.rb
+- lib/ar-extensions/import/sqlite.rb
+- lib/ar-extensions/import.rb
+- lib/ar-extensions/insert_select/mysql.rb
+- lib/ar-extensions/insert_select.rb
+- lib/ar-extensions/synchronize.rb
+- lib/ar-extensions/temporary_table/mysql.rb
+- lib/ar-extensions/temporary_table.rb
+- lib/ar-extensions/union/mysql.rb
+- lib/ar-extensions/union.rb
+- lib/ar-extensions/util/sql_generation.rb
+- lib/ar-extensions/util/support_methods.rb
+- lib/ar-extensions/version.rb
+- lib/ar-extensions.rb
+has_rdoc: true
+homepage: http://www.continuousthinking.com/tags/arext
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: arext
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Extends ActiveRecord functionality.
+test_files: []
+