ghazel-ar-extensions 0.9.3

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/mysql.rb

@@ -0,0 +1,7 @@
+# Although the finder options actually override ActiveRecord::Base functionality instead of
+# connector functionality, the methods are included here to keep the syntax of 0.8.0 intact
+#
+# To include finder options, use:
+# require 'ar-extensions/create_and_update/mysql.rb'
+
+ActiveRecord::Base.send :include, ActiveRecord::Extensions::CreateAndUpdate