rapids 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rapids.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/rapids.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__),'rapids','batch')

data/lib/rapids/batch.rb

@@ -0,0 +1,64 @@
+require 'rapids/batch/create_table'
+require 'rapids/batch/insert_into'
+require 'rapids/batch/create_trigger'
+require 'rapids/batch/find_or_create'
+
+module Rapids
+  module Batch
+    class DefineBatch
+      attr_reader :find_or_creates
+      
+      def initialize
+        @find_or_creates = []
+      end
+      
+      def find_or_create(name,find_columns,*fill_columns_plus_other_params)
+        @find_or_creates << FindOrCreate.new(name,find_columns,fill_columns_plus_other_params.first)
+      end
+    end
+    
+    def batch_create(collection)
+      drop_batch_table_if_exists
+      
+      create_batch_table
+      
+      create_batch_trigger
+      
+      batch_insert(collection)
+    end
+    
+    def batch(&block)
+      @batch = DefineBatch.new
+      @batch.instance_exec(&block) if block_given?
+    end
+    
+    private
+    def drop_batch_table_if_exists
+      drop_table_sql = "DROP TABLE IF EXISTS `#{batch_table_name}`"
+      self.connection.execute(drop_table_sql)
+    end
+    
+    def create_batch_table
+      create_table = CreateTable.new(self,@batch)
+      
+      connection.execute(create_table.to_sql)
+    end
+    
+    def create_batch_trigger
+      create_trigger = CreateTrigger.new(self,@batch)
+      
+      connection.execute(create_trigger.to_sql)
+    end
+    
+    def batch_insert(values)
+      insert_into = InsertInto.new(self,@batch,values)
+
+      connection.execute(insert_into.to_sql)
+    end
+    
+    #TODO refactor this it duplicates what's done in model_extensions.rb
+    def batch_table_name
+      "$#{table_name}_batch"
+    end
+  end
+end

data/lib/rapids/batch/columns_helper.rb

@@ -0,0 +1,81 @@
+module Rapids
+  module Batch
+    class ColumnsHelper
+      include Enumerable
+      include ModelExtensions
+      
+      def initialize(model,find_or_creates)
+        @hash = generate_columns_hash(model,find_or_creates)
+      end
+      
+      def each(&block)
+        internal_each(@hash,[],&block)
+      end
+      
+      private
+      def internal_each(columns_hash,hash_path,&block)
+        columns_hash.sort{|a,b| a[0].to_s <=> b[0].to_s}.each do |key,column_or_hash|
+          if column_or_hash.is_a?(Hash)
+            internal_each(column_or_hash,hash_path + [key],&block)
+          else
+            yield(column_or_hash,hash_path)
+          end
+        end
+      end
+      
+      def generate_columns_hash(model,criteria_hash,skip_columns = [])
+        hash = {}
+        skip_columns_next_time = {}
+        
+        batch_association_primary_keys = if criteria_hash.is_a?(Array)
+          criteria_hash.map do |find_or_create|
+            name = find_or_create.name
+            if model.reflections[name]
+              if model.reflections[name].collection?
+                skip_columns_next_time[name] = [model.reflections[name].primary_key_name]
+                nil
+              else
+                model.reflections[name].primary_key_name
+              end
+            end
+          end.compact
+        else
+          []
+        end
+        
+        columns(model).reject{|c|batch_association_primary_keys.include?(c.name) || skip_columns.include?(c.name)}.each do |column|
+          hash[column.name.to_sym] = column
+        end
+
+        if criteria_hash.is_a?(Array)
+          criteria_hash.each do |find_or_create|
+            name,criteria_array = find_or_create.name,find_or_create.find_columns
+
+            new_model = if criteria_array.is_a?(Array)
+              if name.is_a?(String) && Kernel.const_get(name)
+                Kernel.const_get(name)
+              elsif model.reflections[name]
+                model.reflections[name].klass
+              end
+            end
+            
+            if new_model
+              hash[name] = criteria_array.inject({}) do |memo,criteria|
+                if criteria.is_a?(Hash)
+                  new_find_or_creates = criteria.map do |n,c|
+                    FindOrCreate.new(n,c,[])
+                  end
+                  memo.merge(generate_columns_hash(new_model,new_find_or_creates,skip_columns_next_time[name] || []))
+                else
+                  memo.merge(generate_columns_hash(new_model,[],skip_columns_next_time[name] || []))
+                end
+              end
+            end
+          end
+        end
+        
+        hash        
+      end
+    end
+  end
+end

data/lib/rapids/batch/create_table.rb

@@ -0,0 +1,37 @@
+require 'rapids/batch/model_extensions'
+require 'rapids/batch/columns_helper'
+
+module Rapids
+  module Batch
+    class CreateTable
+      include ModelExtensions
+      
+      def initialize(model,batch_definition)
+        @model = model
+        @batch = batch_definition
+      end
+      
+      def to_sql
+        columns_helper = ColumnsHelper.new(@model,@batch.find_or_creates)
+        columns_sql = columns_helper.map do |column,path|
+          association = nil
+          model = @model
+          path.each do |association_name|
+            if model.reflections[association_name]
+              association = model.reflections[association_name]
+              model = model.reflections[association_name].klass
+            end
+          end
+          column_type = if association && association.collection? && column.number?
+            "varchar(255)"
+          else
+            column.sql_type
+          end
+          "#{sql_column_name(column,path)} #{column_type}"
+        end.join(",")
+
+        "CREATE TABLE `#{batch_table_name}` (#{columns_sql}) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+      end
+    end
+  end
+end

data/lib/rapids/batch/create_trigger.rb

@@ -0,0 +1,177 @@
+require 'rapids/batch/model_extensions'
+require 'rapids/batch/columns_helper'
+
+module Rapids
+  module Batch
+    class CreateTrigger
+      include ModelExtensions
+      
+      def initialize(model,batch_definition)
+        @model = model
+        @batch = batch_definition
+      end
+
+      def to_sql
+        declares = @batch.find_or_creates.map do |find_or_create|
+          "declare #{variable_name(find_or_create.name,[])} integer;"
+        end.join("\n")
+
+        columns_helper = ColumnsHelper.new(@model,@batch.find_or_creates)
+        main_columns = columns_helper.find_all{|column,path| path == []}
+
+        insert_header = (main_columns.map(&:first) + criteria_columns(@model,association_find_or_creates.map(&:name))).map{|a|sql_column_name(a,[])}
+        insert_values = main_columns.map{|a|"new.#{sql_column_name(a.first,[])}"} + association_find_or_creates.map(&:name).map{|name|variable_name(name,[])}
+
+        <<-TRIGGER_SQL
+          create trigger `#{batch_table_name}_trigger` after insert on `#{batch_table_name}` for each row
+          begin
+            #{declares}
+            
+            #{find_or_create_sql(@model,@batch.find_or_creates)}
+            
+            insert into `#{@model.table_name}` (#{insert_header.join(",")})
+                                        values (#{insert_values.join(",")});
+          end
+        TRIGGER_SQL
+      end
+      
+      private
+      def association_find_or_creates(model = @model,find_or_creates = @batch.find_or_creates)
+        find_or_creates.reject{|foc|model.reflections[foc.name].nil?}
+      end
+      
+      def find_or_create_sql(model,find_or_creates, recursion_path = [])
+        columns_helper = ColumnsHelper.new(model,find_or_creates)
+        
+        find_or_creates.map do |find_or_create|
+          name,criteria = find_or_create.name,find_or_create.find_columns
+          if model.reflections[name]
+            sub_model = model.reflections[name].klass
+            association_table_name = sub_model.table_name
+            sub_model_columns = columns_helper.find_all{|column,path| path == [name]}
+          
+            where_sql = foc_where_sql(sub_model,criteria,[name])
+
+            "select id from `#{association_table_name}` where #{where_sql} into #{variable_name(name,recursion_path)};
+             if #{variable_name(name,recursion_path)} is null then
+               insert into #{association_table_name} (#{sub_model_columns.map{|a|sql_column_name(a.first,[])}.join(",")})
+                                              values (#{sub_model_columns.map{|a|"new.#{sql_column_name(a.first,a.last)}"}.join(",")});
+             
+               select last_insert_id() into #{variable_name(name,recursion_path)};
+             
+               #{sub_inserts(sub_model,criteria,[name],variable_name(name,recursion_path))}
+             end if;
+            "
+          elsif name.is_a?(String) && Kernel.const_get(name)
+            sub_model = Kernel.const_get(name)
+            association_table_name = sub_model.table_name
+            sub_model_columns = columns_helper.find_all{|column,path| path == [name]}
+          
+            where_sql = foc_where_sql(sub_model,criteria,[name])
+            
+            "select id from `#{association_table_name}` where #{where_sql} into #{variable_name(name,recursion_path)};
+             if #{variable_name(name,recursion_path)} is null then
+               insert into #{association_table_name} (#{sub_model_columns.map{|a|sql_column_name(a.first,[])}.join(",")})
+                                              values (#{sub_model_columns.map{|a|"new.#{sql_column_name(a.first,a.last)}"}.join(",")});
+             
+               #{sub_inserts(sub_model,criteria,[name],variable_name(name,recursion_path))}
+             end if;
+            "
+          end
+        end.join("\n")
+      end
+      
+      def variable_name(name,recursion_path)
+        "find_or_create$#{(recursion_path + [name]).join("$")}"
+      end
+      
+      def foc_where_sql(model,criteria_array,path)
+        and_comparisons = criteria_array.map do |column_or_association_name_or_hash|
+          if column_or_association_name_or_hash.is_a?(Hash)
+            sub_comparisons = column_or_association_name_or_hash.map do |association_name,sub_criteria|
+              association = model.reflections[association_name]
+              if association.collection?
+                sub_criteria.map do |column_name|
+                  column = lookup_column_by_name(association.klass,column_name)
+                  "new.#{sql_column_name(column,path+[association_name])} = (select GROUP_CONCAT(#{sql_column_name(column,[])} ORDER BY #{sql_column_name(column,[])})
+                        from #{association.quoted_table_name}
+                        where `#{model.table_name}`.id = `#{association.primary_key_name}`)
+                  "
+                end.join(" and ")
+              else
+                "true"
+              end
+            end
+            
+            "("+sub_comparisons.join(" and ")+")"
+          else
+            if column_or_association_name_or_hash.is_a?(Array)
+              destination_column = lookup_column_by_name(model,column_or_association_name_or_hash.first)
+              source_column = lookup_column_by_name(model,column_or_association_name_or_hash.last)
+            else
+              destination_column = lookup_column_by_name(model,column_or_association_name_or_hash)
+              source_column = lookup_column_by_name(model,column_or_association_name_or_hash)
+            end
+
+            "#{sql_column_name(destination_column,[])} <=> new.#{sql_column_name(destination_column,path)}"
+          end
+        end
+        
+        and_comparisons.join(" and ")
+      end
+      
+      def sub_inserts(model,criteria_array,path,key_variable)
+        criteria_array.map do |column_or_association_name_or_hash|
+          if column_or_association_name_or_hash.is_a?(Hash)
+            column_or_association_name_or_hash.map do |association_name,sub_criteria|
+              association = model.reflections[association_name]
+              column = lookup_column_by_name(association.klass,sub_criteria.first)
+              "begin
+                 DECLARE cur_position INT DEFAULT 1;
+                 DECLARE remainder VARCHAR(255);
+                 DECLARE cur_string VARCHAR(255);
+
+                 SET remainder = new.#{sql_column_name(column,path+[association_name])};
+
+                 WHILE CHAR_LENGTH(remainder) > 0 AND cur_position > 0 DO
+                   SET cur_position = INSTR(remainder, ',');
+                   IF cur_position = 0 THEN
+                     SET cur_string = remainder;
+                   ELSE
+                     SET cur_string = LEFT(remainder, cur_position - 1);
+                   END IF;
+                   INSERT INTO #{association.quoted_table_name} (#{["`#{association.primary_key_name}`",sql_column_name(column,[])].join(",")}) VALUES (#{[key_variable,'cur_string'].join(",")});
+                   SET remainder = SUBSTRING(remainder, cur_position + 1);
+                 END WHILE;
+               end;"
+            end.join("\n")
+          end
+        end.join("\n")
+      end
+      
+      def lookup_column_by_name(model,column_name)
+        column = model.columns.detect{|c|c.name == column_name.to_s}
+
+        unless column
+          # doesn't match a column name look for an assocation instead then
+          association = model.reflections[column_name]
+
+          column = if association.nil? || association.collection?
+            nil #TODO implement
+          else
+            model.columns.detect{|c|c.name == association.primary_key_name}
+          end
+        end
+        column
+      end
+      
+      def criteria_columns(model,criteria_array)
+        criteria_array.map do |column_or_association_name_or_hash|
+          unless column_or_association_name_or_hash.is_a?(Hash)
+            lookup_column_by_name(model,column_or_association_name_or_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rapids/batch/find_or_create.rb

@@ -0,0 +1,13 @@
+module Rapids
+  module Batch
+    class FindOrCreate
+      attr_reader :name, :find_columns, :fill_columns
+      
+      def initialize(name,find_columns,fill_columns)
+        @name = name
+        @find_columns = find_columns
+        @fill_columns = fill_columns
+      end
+    end
+  end
+end

data/lib/rapids/batch/insert_into.rb

@@ -0,0 +1,59 @@
+require 'rapids/batch/model_extensions'
+require 'rapids/batch/columns_helper'
+
+module Rapids
+  module Batch
+    class InsertInto
+      include ModelExtensions
+      
+      def initialize(model,batch_definition,values)
+        @model = model
+        @batch = batch_definition
+        @values = values
+      end
+      
+      def to_sql
+        columns_helper = ColumnsHelper.new(@model,@batch.find_or_creates)
+        insert_header_sql = columns_helper.map{|column,path|sql_column_name(column,path)}.join(",")
+        
+        values_sql = @values.map do |row|
+          row_sql = columns_helper.map do |column,path|
+            source_column_name = column.name
+            destination_column = column
+            
+            @batch.find_or_creates.each do |find_or_create|
+              if find_or_create.name == path.first && find_or_create.find_columns.any?{|fc|fc.is_a?(Array) && fc.first.to_s == column.name}
+                source_column_name = find_or_create.find_columns.detect{|fc|fc.is_a?(Array) && fc.first.to_s == column.name}.last.to_s
+              end
+            end
+          
+            specific_object = path.inject(row) do |memo,association|
+              if memo.respond_to?(association)
+                memo.send(association)
+              elsif association.is_a?(String)
+                memo
+              end
+            end
+
+            if specific_object.respond_to?(:each)
+              many_attributes = specific_object.map do |s|
+                s.instance_variable_get(:@attributes)[source_column_name]
+              end.compact
+              if many_attributes.empty?
+                default_on_nil(nil,destination_column)
+              else
+                default_on_nil(many_attributes.sort.join(","),destination_column)
+              end
+            else
+              val = specific_object.instance_variable_get(:@attributes)[source_column_name] #speeds things up a bit since it's not typed first before being quoted
+              default_on_nil(val,destination_column)
+            end
+          end
+          "(#{row_sql.join(",")})"
+        end.join(",")
+        
+        "INSERT INTO `#{batch_table_name}` (#{insert_header_sql}) VALUES #{values_sql}"
+      end
+    end
+  end
+end

data/lib/rapids/batch/model_extensions.rb

@@ -0,0 +1,46 @@
+module Rapids
+  module Batch
+    module ModelExtensions
+      def columns(model = @model)
+        model.columns.reject{|c|c.primary}
+      end
+      
+      def batch_table_name
+        "$#{@model.table_name}_batch"
+      end
+      
+      def sql_column_name(column,hash_path)
+        prefix = hash_path.empty? ? "" : "foc$"
+        association_list = (hash_path + [column.name]).map(&:to_s).join("$")
+        "`#{prefix+association_list}`"
+      end
+      
+      def default_on_nil(value,column)
+        if value.nil?
+          case
+          when %w{created_at updated_at}.include?(column.name)
+            "UTC_TIMESTAMP()"
+          else
+            quote_bound_value(value)
+          end
+        else
+          quote_bound_value(value)
+        end
+      end
+      
+      #Stolen from ActiveRecord::Base
+      def quote_bound_value(value)
+        c = ActiveRecord::Base.connection
+        if value.respond_to?(:map) && !value.acts_like?(:string)
+          if value.respond_to?(:empty?) && value.empty?
+            c.quote(nil)
+          else
+            value.map { |v| c.quote(v) }.join(',')
+          end
+        else
+          c.quote(value)
+        end
+      end
+    end
+  end
+end

data/lib/rapids/version.rb

@@ -0,0 +1,3 @@
+module Rapids
+  VERSION = "0.1.0"
+end

data/rapids.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rapids/version"
+
+
+
+Gem::Specification.new do |s|
+  rapids_summary = "A ruby library to provide rapid insertion of rows into a database"
+  
+  s.name        = "rapids"
+  s.version     = Rapids::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['James Smith']
+  s.email       = ["sunblaze@gmail.com"]
+  s.homepage    = 'http://github.com/sunblaze/rapids'
+  s.summary     = rapids_summary
+  s.description = rapids_summary #TODO write a better long form description
+  s.license     = 'MIT'
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.rubyforge_project = "rapids"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "rspec", "2.5.0"
+  s.add_development_dependency "activerecord", "~> 3.0.6"
+  s.add_development_dependency "mysql", "~> 2.8.1"
+end

data/spec/batch/columns_helper_spec.rb

@@ -0,0 +1,37 @@
+require 'batch/spec_helper'
+
+module Rapids::Batch
+  describe ColumnsHelper do
+    it "should intialize with an empty find or create list" do
+      ColumnsHelper.new(Post,[])
+    end
+
+    it "should initialize with the association find or create" do
+      find_or_creates = [FindOrCreate.new(:author,[:name],[])]
+      columns_helper = ColumnsHelper.new(Post,find_or_creates)
+      
+      columns_helper.map{|a|a.first.name}.include?("name").should be_true
+      columns_helper.map{|a|a.first.name}.include?("author_id").should be_false, "expected author_id not to be present in this list:\n#{columns_helper.to_a.inspect}"
+    end
+    
+    it "should initialize with the manual find or create format" do
+      find_or_creates = [FindOrCreate.new("Category",[:category],[])]
+      columns_helper = ColumnsHelper.new(Post,find_or_creates)
+      
+      columns_helper.any? do |pair|
+        column,path = *pair
+        column.name == "category" && path == ["Category"]
+      end.should be_true, "expected to find a column named 'category' and the path to be [\"Category\"] in the following:\n#{columns_helper.to_a.inspect}"
+    end
+    
+    it "should initialize with the association find or create with a has_many find or create" do
+      find_or_creates = [FindOrCreate.new(:post,[:name,{:post_tags => [:tag_id]}],[])]
+      columns_helper = ColumnsHelper.new(Comment,find_or_creates)
+      
+      columns_helper.any? do |pair|
+        column,path = *pair
+        column.name == "tag_id" && path == [:post,:post_tags]
+      end.should be_true, "expected to find a column named 'tag_id' and the path to be [:post,:post_tags] in the following:\n#{columns_helper.to_a.inspect}"
+    end
+  end
+end

data/spec/batch/create_table_spec.rb

@@ -0,0 +1,44 @@
+require 'batch/spec_helper'
+
+module Rapids::Batch
+  describe CreateTable do
+    it "should generate sql for a simple batch definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      
+      create_table = CreateTable.new(Category,batch)
+      create_table.to_sql.should == "CREATE TABLE `$categories_batch` (`category` varchar(255)) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+    end
+    
+    it "should generate sql for a basic definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create(:author,[:name])
+      
+      create_table = CreateTable.new(Post,batch)
+      create_table.to_sql.should == "CREATE TABLE `$posts_batch` (`foc$author$name` varchar(255),`category` varchar(255),`name` varchar(255)) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+    end
+    
+    it "should generate sql for a manual definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("Category",[:category])
+      
+      create_table = CreateTable.new(Post,batch)
+      create_table.to_sql.should == "CREATE TABLE `$posts_batch` (`foc$Category$category` varchar(255),`author_id` int(11),`category` varchar(255),`name` varchar(255)) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+    end
+    
+    it "should generate sql for a manual definition, with explicit source column" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("AltCategory",[[:name,:category]])
+      
+      create_table = CreateTable.new(Post,batch)
+      create_table.to_sql.should == "CREATE TABLE `$posts_batch` (`foc$AltCategory$name` varchar(255),`author_id` int(11),`category` varchar(255),`name` varchar(255)) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+    end
+    
+    it "should generate sql for a more complicated find or create with reliances on a has_many relationship" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create(:post,[:name,{:post_tags => [:tag_id]}])
+      
+      create_table = CreateTable.new(Comment,batch)
+      create_table.to_sql.should == "CREATE TABLE `$comments_batch` (`body` varchar(255),`foc$post$author_id` int(11),`foc$post$category` varchar(255),`foc$post$name` varchar(255),`foc$post$post_tags$tag_id` varchar(255),`title` varchar(255)) ENGINE=BLACKHOLE DEFAULT CHARSET=utf8"
+    end
+  end
+end

data/spec/batch/create_trigger_spec.rb

@@ -0,0 +1,36 @@
+require 'batch/spec_helper'
+
+module Rapids::Batch
+  describe CreateTrigger do
+    it "should generate sql for a simple batch definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      
+      create_trigger = CreateTrigger.new(Category,batch)
+      clean_sql(create_trigger.to_sql).should == "create trigger `$categories_batch_trigger` after insert on `$categories_batch` for each row\nbegin\ninsert into `categories` (`category`)\nvalues (new.`category`);\nend"
+    end
+    
+    it "should generate sql for a basic definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create(:author,[:name])
+      
+      create_trigger = CreateTrigger.new(Post,batch)
+      clean_sql(create_trigger.to_sql).should == "create trigger `$posts_batch_trigger` after insert on `$posts_batch` for each row\nbegin\ndeclare find_or_create$author integer;\nselect id from `authors` where `name` <=> new.`foc$author$name` into find_or_create$author;\nif find_or_create$author is null then\ninsert into authors (`name`)\nvalues (new.`foc$author$name`);\nselect last_insert_id() into find_or_create$author;\nend if;\ninsert into `posts` (`category`,`name`,`author_id`)\nvalues (new.`category`,new.`name`,find_or_create$author);\nend"
+    end
+    
+    it "should generate sql for a manual definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("Category",[:category])
+      
+      create_trigger = CreateTrigger.new(Post,batch)
+      clean_sql(create_trigger.to_sql).should == "create trigger `$posts_batch_trigger` after insert on `$posts_batch` for each row\nbegin\ndeclare find_or_create$Category integer;\nselect id from `categories` where `category` <=> new.`foc$Category$category` into find_or_create$Category;\nif find_or_create$Category is null then\ninsert into categories (`category`)\nvalues (new.`foc$Category$category`);\nend if;\ninsert into `posts` (`author_id`,`category`,`name`)\nvalues (new.`author_id`,new.`category`,new.`name`);\nend"
+    end
+    
+    it "should generate sql for a manual definition, with explicit source column" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("AltCategory",[[:name,:category]])
+      
+      create_trigger = CreateTrigger.new(Post,batch)
+      clean_sql(create_trigger.to_sql).should == "create trigger `$posts_batch_trigger` after insert on `$posts_batch` for each row\nbegin\ndeclare find_or_create$AltCategory integer;\nselect id from `alt_categories` where `name` <=> new.`foc$AltCategory$name` into find_or_create$AltCategory;\nif find_or_create$AltCategory is null then\ninsert into alt_categories (`name`)\nvalues (new.`foc$AltCategory$name`);\nend if;\ninsert into `posts` (`author_id`,`category`,`name`)\nvalues (new.`author_id`,new.`category`,new.`name`);\nend"
+    end
+  end
+end

data/spec/batch/insert_into_spec.rb

@@ -0,0 +1,42 @@
+require 'batch/spec_helper'
+
+module Rapids::Batch
+  describe InsertInto do
+    it "should generate sql for a simple batch definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      collection = %w{food politics}.map do |category_name|
+        Category.new(:category => category_name)
+      end
+      
+      insert_into = InsertInto.new(Category,batch,collection)
+      clean_sql(insert_into.to_sql).should == "INSERT INTO `$categories_batch` (`category`) VALUES ('food'),('politics')"
+    end
+    
+    it "should generate sql for a basic definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create(:author,[:name])
+      collection = [Post.new(:name => "Dining at 323 Butter St",:category => "food",:author => Author.new(:name => "Joe"))]
+      
+      insert_into = InsertInto.new(Post,batch,collection)
+      clean_sql(insert_into.to_sql).should == "INSERT INTO `$posts_batch` (`foc$author$name`,`category`,`name`) VALUES ('Joe','food','Dining at 323 Butter St')"
+    end
+    
+    it "should generate sql for a manual definition" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("Category",[:name])
+      collection = [Post.new(:name => "Dining at 323 Butter St",:category => "food")]
+      
+      insert_into = InsertInto.new(Post,batch,collection)
+      clean_sql(insert_into.to_sql).should == "INSERT INTO `$posts_batch` (`foc$Category$category`,`author_id`,`category`,`name`) VALUES ('food',NULL,'food','Dining at 323 Butter St')"
+    end
+    
+    it "should generate sql for a manual definition, with explicit source column" do
+      batch = Rapids::Batch::DefineBatch.new
+      batch.find_or_create("AltCategory",[[:name,:category]])
+      collection = [Post.new(:name => "Dining at 323 Butter St",:category => "food")]
+      
+      insert_into = InsertInto.new(Post,batch,collection)
+      clean_sql(insert_into.to_sql).should == "INSERT INTO `$posts_batch` (`foc$AltCategory$name`,`author_id`,`category`,`name`) VALUES ('food',NULL,'food','Dining at 323 Butter St')"
+    end
+  end
+end

data/spec/batch/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+DATABASE_NAME = 'rapids_test'
+ActiveRecord::Base.establish_connection(
+                      :adapter  => 'mysql',
+                      :username => 'root',
+                      :password => '',
+                      :host     => 'localhost')
+ActiveRecord::Base.connection.create_database(DATABASE_NAME) rescue ActiveRecord::StatementInvalid
+
+ActiveRecord::Base.establish_connection(
+                      :adapter  => 'mysql',
+                      :database => DATABASE_NAME,
+                      :username => 'root',
+                      :password => '',
+                      :host     => 'localhost')
+
+class ColumnHelperMigrations < ActiveRecord::Migration
+  def self.up
+    create_table :posts do |t|
+      t.column :name, :string, :null => false
+      t.column :category, :string, :null => false
+      t.column :author_id, :integer, :null => false
+    end
+    create_table :authors do |t|
+      t.column :name, :string, :null => false
+    end
+    create_table :categories do |t|
+      t.column :category, :string, :null => false
+    end
+    create_table :alt_categories do |t|
+      t.column :name, :string, :null => false
+    end
+    create_table :tags do |t|
+      t.column :name, :string, :null => false
+    end
+    create_table :post_tags do |t|
+      t.column :post_id, :integer, :null => false
+      t.column :tag_id, :integer, :null => false
+    end
+    create_table :comments do |t|
+      t.column :title, :string, :null => false
+      t.column :body, :string, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :posts
+    drop_table :categories
+    drop_table :alt_categories
+    drop_table :authors
+    drop_table :tags
+    drop_table :post_tags
+    drop_table :comments
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :blog
+  has_many :post_tags
+end
+
+class Category < ActiveRecord::Base
+end
+
+class AltCategory < ActiveRecord::Base
+end
+
+class Author < ActiveRecord::Base
+end
+
+class Tag < ActiveRecord::Base
+  has_many :post_tags
+end
+
+class PostTag < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :post
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ColumnHelperMigrations.migrate(:up)
+  end
+  config.after(:suite) do
+    puts "\n\n" #To help make the output nicer with these migration outputs in the testing
+    ColumnHelperMigrations.migrate(:down)
+  end
+end
+
+def clean_sql(sql)
+  sql.gsub(/(\s)\s*/,'\1').lstrip.rstrip
+end

data/spec/rapids_batch_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+class RapidsBatchTestCase < ActiveRecord::Base
+  extend Rapids::Batch
+end
+
+describe Rapids::Batch do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rapids'
+require 'active_record'
+

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: rapids
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- James Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-22 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 3
+        - 0
+        - 6
+        version: 3.0.6
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 45
+        segments: 
+        - 2
+        - 8
+        - 1
+        version: 2.8.1
+  type: :development
+  version_requirements: *id003
+description: A ruby library to provide rapid insertion of rows into a database
+email: 
+- sunblaze@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README
+- Rakefile
+- lib/rapids.rb
+- lib/rapids/batch.rb
+- lib/rapids/batch/columns_helper.rb
+- lib/rapids/batch/create_table.rb
+- lib/rapids/batch/create_trigger.rb
+- lib/rapids/batch/find_or_create.rb
+- lib/rapids/batch/insert_into.rb
+- lib/rapids/batch/model_extensions.rb
+- lib/rapids/version.rb
+- rapids.gemspec
+- spec/batch/columns_helper_spec.rb
+- spec/batch/create_table_spec.rb
+- spec/batch/create_trigger_spec.rb
+- spec/batch/insert_into_spec.rb
+- spec/batch/spec_helper.rb
+- spec/rapids_batch_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/sunblaze/rapids
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rapids
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A ruby library to provide rapid insertion of rows into a database
+test_files: 
+- spec/batch/columns_helper_spec.rb
+- spec/batch/create_table_spec.rb
+- spec/batch/create_trigger_spec.rb
+- spec/batch/insert_into_spec.rb
+- spec/batch/spec_helper.rb
+- spec/rapids_batch_spec.rb
+- spec/spec_helper.rb