Add Postgres support

lib/polo/adapters/mysql.rb

@@ -0,0 +1,24 @@
+module Polo
+  module Adapters
+    class MySQL
+      def on_duplicate_key_update(inserts, records)
+        insert_and_record = inserts.zip(records)
+        insert_and_record.map do |insert, record|
+          values_syntax = record.attributes.keys.map do |key|
+            "#{key} = VALUES(#{key})"
+          end
+
+          on_dup_syntax = "ON DUPLICATE KEY UPDATE #{values_syntax.join(', ')}"
+
+          "#{insert} #{on_dup_syntax}"
+        end
+      end
+
+      def ignore_transform(inserts, records)
+        inserts.map do |insert|
+          insert.gsub("INSERT", "INSERT IGNORE")
+        end
+      end
+    end
+  end
+end

lib/polo/adapters/postgres.rb

@@ -0,0 +1,32 @@
+module Polo
+  module Adapters
+    class Postgres
+      # TODO: Implement UPSERT. This command became available in 9.1.
+      #
+      # See: http://www.the-art-of-web.com/sql/upsert/
+      def on_duplicate_key_update(inserts, records)
+        raise 'on_duplicate: :override is not currently supported in the PostgreSQL adapter'
+      end
+
+      # Internal: Transforms an INSERT with PostgreSQL-specific syntax. Ignores
+      #           records that alread exist in the table. To do this, it uses
+      #           a heuristic, i.e. checks if there is a record with the same id
+      #           in the table.
+      #           See: http://stackoverflow.com/a/6527838/32816
+      #
+      # inserts - The Array of INSERT statements.
+      # records - The Array of Arel objects.
+      #
+      # Returns the Array of transformed INSERT statements.
+      def ignore_transform(inserts, records)
+        insert_and_record = inserts.zip(records)
+        insert_and_record.map do |insert, record|
+          table_name = record.class.arel_table.name
+          id = record[:id]
+          insert = insert.gsub(/VALUES \((.+)\)$/m, 'SELECT \\1')
+          insert << " WHERE NOT EXISTS (SELECT 1 FROM #{table_name} WHERE id=#{id});"
+        end
+      end
+    end
+  end
+end

lib/polo/configuration.rb

@@ -1,10 +1,11 @@
 module Polo
 
   class Configuration
-    attr_reader :on_duplicate_strategy, :blacklist
+    attr_reader :on_duplicate_strategy, :blacklist, :adapter
 
     def initialize(options={})
-      options = { on_duplicate: nil, obfuscate: {} }.merge(options)
+      options = { on_duplicate: nil, obfuscate: {}, adapter: :mysql }.merge(options)
+      @adapter = options[:adapter]
       @on_duplicate_strategy = options[:on_duplicate]
       obfuscate(options[:obfuscate])
     end
@@ -33,5 +34,9 @@ def obfuscate(*fields)
     def on_duplicate(strategy)
       @on_duplicate_strategy = strategy
     end
+
+    def set_adapter(db)
+      @adapter = db
+    end
   end
 end

lib/polo/sql_translator.rb

@@ -1,53 +1,47 @@
 require 'active_record'
 require 'polo/configuration'
+require 'polo/adapters/mysql'
+require 'polo/adapters/postgres'
 
 module Polo
   class SqlTranslator
 
-    def initialize(object, configuration=Configuration.new)
+    def initialize(object, configuration = Configuration.new)
       @record = object
       @configuration = configuration
-    end
-
-    def to_sql
-      records = Array.wrap(@record)
 
-      sqls = records.map do |record|
-        raw_sql(record)
-      end
-
-      if @configuration.on_duplicate_strategy == :ignore
-        sqls = ignore_transform(sqls)
+      case @configuration.adapter
+      when :mysql
+        @adapter = Polo::Adapters::MySQL.new
+      when :postgres
+        @adapter = Polo::Adapters::Postgres.new
+      else
+        raise "Unknown SQL adapter: #{@configuration.adapter}"
       end
+    end
 
-      if @configuration.on_duplicate_strategy == :override
-        sqls = on_duplicate_key_update(sqls, records)
+    def to_sql
+      case @configuration.on_duplicate_strategy
+      when :ignore
+        @adapter.ignore_transform(inserts, records)
+      when :override
+        @adapter.on_duplicate_key_update(inserts, records)
+      else inserts
       end
-
-      sqls
     end
 
-    private
-
-    def on_duplicate_key_update(sqls, records)
-      insert_and_record = sqls.zip(records)
-      insert_and_record.map do |insert, record|
-        values_syntax = record.attributes.keys.map do |key|
-          "#{key} = VALUES(#{key})"
-        end
-
-        on_dup_syntax = "ON DUPLICATE KEY UPDATE #{values_syntax.join(', ')}"
-
-        "#{insert} #{on_dup_syntax}"
-      end
+    def records
+      Array.wrap(@record)
     end
 
-    def ignore_transform(inserts)
-      inserts.map do |insert|
-        insert.gsub("INSERT", "INSERT IGNORE")
+    def inserts
+      records.map do |record|
+        raw_sql(record)
       end
     end
 
+    private
+
     # Internal: Generates an insert SQL statement for a given record
     #
     # It will make use of the InsertManager class from the Arel gem to generate

spec/adapters/mysql_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Polo::Adapters::MySQL do
+
+  let(:adapter) { Polo::Adapters::MySQL.new }
+
+  let(:netto) do
+    AR::Chef.where(name: 'Netto').first
+  end
+
+  before(:all) do
+    TestData.create_netto
+  end
+
+  let(:translator) { Polo::SqlTranslator.new(netto, Polo::Configuration.new(adapter: :mysql)) }
+
+  describe '#ignore_transform' do
+    it 'appends the IGNORE command after INSERTs' do
+      insert_netto = [%q{INSERT IGNORE INTO "chefs" ("id", "name", "email") VALUES (1, 'Netto', 'nettofarah@gmail.com')}]
+
+      records = translator.records
+      inserts = translator.inserts
+      translated_sql = adapter.ignore_transform(inserts, records)
+      expect(translated_sql).to eq(insert_netto)
+    end
+  end
+
+
+  describe '#on_duplicate_key_update' do
+    it 'appends ON DUPLICATE KEY UPDATE with all values to the current INSERT statement' do
+      insert_netto = [
+        %q{INSERT INTO "chefs" ("id", "name", "email") VALUES (1, 'Netto', 'nettofarah@gmail.com') ON DUPLICATE KEY UPDATE id = VALUES(id), name = VALUES(name), email = VALUES(email)}
+      ]
+
+      inserts = translator.inserts
+      records = translator.records
+      translated_sql = adapter.on_duplicate_key_update(inserts, records)
+      expect(translated_sql).to eq(insert_netto)
+    end
+  end
+end

spec/adapters/postgres_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Polo::Adapters::Postgres do
+
+  let(:adapter) { Polo::Adapters::Postgres.new }
+
+  let(:netto) do
+    AR::Chef.where(name: 'Netto').first
+  end
+
+  before(:all) do
+    TestData.create_netto
+  end
+
+  let(:translator) { Polo::SqlTranslator.new(netto, Polo::Configuration.new(adapter: :postgres)) }
+
+  describe '#on_duplicate_key_update' do
+    it 'should raise an error' do
+      expect { adapter.on_duplicate_key_update(double(), double()) }.to raise_error('on_duplicate: :override is not currently supported in the PostgreSQL adapter')
+    end
+  end
+
+  describe '#ignore_transform' do
+    it 'transforms INSERT by appending WHERE NOT EXISTS clause' do
+
+      insert_netto = [%q{INSERT INTO "chefs" ("id", "name", "email") SELECT 1, 'Netto', 'nettofarah@gmail.com' WHERE NOT EXISTS (SELECT 1 FROM chefs WHERE id=1);}]
+
+      records = translator.records
+      inserts = translator.inserts
+      translated_sql = adapter.ignore_transform(inserts, records)
+      expect(translated_sql).to eq(insert_netto)
+    end
+  end
+end

spec/configuration_spec.rb

@@ -2,6 +2,12 @@
 
 describe Polo::Configuration do
 
+  describe 'adapter' do
+    it 'defaults to mysql' do
+      expect(Polo.defaults.adapter).to be :mysql
+    end
+  end
+
   describe 'on_duplicate' do
     it 'defaults to nothing' do
       expect(Polo.defaults.on_duplicate_strategy).to be nil

spec/sql_translator_spec.rb

@@ -21,25 +21,4 @@
     recipe_to_sql = Polo::SqlTranslator.new(recipe).to_sql.first
     expect(recipe_to_sql).to include(%q{'{"quality":"ok"}'}) # JSON, not YAML
   end
-
-  describe "options" do
-    describe "on_duplicate: :ignore" do
-      it 'uses INSERT IGNORE as opposed to regular inserts' do
-        insert_netto = [%q{INSERT IGNORE INTO "chefs" ("id", "name", "email") VALUES (1, 'Netto', 'nettofarah@gmail.com')}]
-        netto_to_sql = Polo::SqlTranslator.new(netto, Polo::Configuration.new(on_duplicate: :ignore)).to_sql
-        expect(netto_to_sql).to eq(insert_netto)
-      end
-    end
-
-    describe "on_duplicate: :override" do
-      it 'appends ON DUPLICATE KEY UPDATE to the statement' do
-        insert_netto = [
-          %q{INSERT INTO "chefs" ("id", "name", "email") VALUES (1, 'Netto', 'nettofarah@gmail.com') ON DUPLICATE KEY UPDATE id = VALUES(id), name = VALUES(name), email = VALUES(email)}
-        ]
-
-        netto_to_sql = Polo::SqlTranslator.new(netto, Polo::Configuration.new(on_duplicate: :override)).to_sql
-        expect(netto_to_sql).to eq(insert_netto)
-      end
-    end
-  end
 end