upsert 1.0.2 → 1.1.0

data/lib/upsert/merge_function/Java_ComMysqlJdbc_JDBC4Connection.rb

@@ -0,0 +1,42 @@
+require 'upsert/merge_function/mysql'
+
+class Upsert
+  class MergeFunction
+    # @private
+    class Java_ComMysqlJdbc_JDBC4Connection < MergeFunction
+      include Mysql
+
+      def sql
+        @sql ||= begin
+          bind_params = Array.new(selector_keys.length + setter_keys.length, '?')
+          %{CALL #{name}(#{bind_params.join(', ')})}
+        end
+      end
+
+      def execute(row)
+        first_try = true
+        bind_selector_values = row.selector.values.map { |v| connection.bind_value v }
+        bind_setter_values = row.setter.values.map { |v| connection.bind_value v }
+        begin
+          connection.execute sql, (bind_selector_values + bind_setter_values)
+        rescue com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException => e
+          if e.message =~ /PROCEDURE.*does not exist/i
+            if first_try
+              Upsert.logger.info %{[upsert] Function #{name.inspect} went missing, trying to recreate}
+              first_try = false
+              create!
+              retry
+            else
+              Upsert.logger.info %{[upsert] Failed to create function #{name.inspect} for some reason}
+              raise e
+            end
+          else
+            raise e
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/upsert/merge_function/Java_OrgPostgresqlJdbc4_Jdbc4Connection.rb

@@ -0,0 +1,35 @@
+require 'upsert/merge_function/postgresql'
+
+class Upsert
+  class MergeFunction
+    # @private
+    class Java_OrgPostgresqlJdbc4_Jdbc4Connection < MergeFunction
+      include Postgresql
+
+      def execute(row)
+        first_try = true
+        bind_selector_values = row.selector.values.map { |v| connection.bind_value v }
+        bind_setter_values = row.setter.values.map { |v| connection.bind_value v }
+        begin
+          connection.execute sql, (bind_selector_values + bind_setter_values)
+        rescue org.postgresql.util.PSQLException => pg_error
+          if pg_error.message =~ /function #{name}.* does not exist/i
+            if first_try
+              Upsert.logger.info %{[upsert] Function #{name.inspect} went missing, trying to recreate}
+              first_try = false
+              create!
+              retry
+            else
+              Upsert.logger.info %{[upsert] Failed to create function #{name.inspect} for some reason}
+              raise pg_error
+            end
+          else
+            raise pg_error
+          end
+        end
+      end
+
+
+    end
+  end
+end

data/lib/upsert/merge_function/Java_OrgSqliteConn.rb

@@ -0,0 +1,10 @@
+require 'upsert/merge_function/sqlite3'
+
+class Upsert
+  class MergeFunction
+    # @private
+    class Java_OrgSqliteConn < MergeFunction
+      include Sqlite3
+    end
+  end
+end

data/lib/upsert/merge_function/Mysql2_Client.rb

@@ -1,18 +1,14 @@
-require 'digest/md5'
+require 'upsert/merge_function/mysql'
 
 class Upsert
   class MergeFunction
     # @private
     class Mysql2_Client < MergeFunction
-      MAX_NAME_LENGTH = 63
+      include Mysql
 
-      class << self
-        # http://stackoverflow.com/questions/733349/list-of-stored-procedures-functions-mysql-command-line
-        def clear(connection)
-          connection.execute("SHOW PROCEDURE STATUS WHERE Db = DATABASE() AND Name LIKE 'upsert_%'").map { |row| row['Name'] }.each do |name|
-            connection.execute "DROP PROCEDURE IF EXISTS #{connection.quote_ident(name)}"
-          end
-        end
+      def sql(row)
+        quoted_params = (row.selector.values + row.setter.values).map { |v| connection.quote_value v }
+        %{CALL #{name}(#{quoted_params.join(', ')})}
       end
 
       def execute(row)
@@ -35,55 +31,6 @@ class Upsert
           end
         end
       end
-
-      def sql(row)
-        quoted_params = (row.selector.values + row.setter.values).map(&:quoted_value)
-        %{CALL #{name}(#{quoted_params.join(', ')})}
-      end
-
-      # http://stackoverflow.com/questions/11371479/how-to-translate-postgresql-merge-db-aka-upsert-function-into-mysql/
-      def create!
-        Upsert.logger.info "[upsert] Creating or replacing database function #{name.inspect} on table #{table_name.inspect} for selector #{selector_keys.map(&:inspect).join(', ')} and setter #{setter_keys.map(&:inspect).join(', ')}"
-        selector_column_definitions = column_definitions.select { |cd| selector_keys.include?(cd.name) }
-        setter_column_definitions = column_definitions.select { |cd| setter_keys.include?(cd.name) }
-        quoted_name = connection.quote_ident name
-        connection.execute "DROP PROCEDURE IF EXISTS #{quoted_name}"
-        connection.execute(%{
-          CREATE PROCEDURE #{quoted_name}(#{(selector_column_definitions.map(&:to_selector_arg) + setter_column_definitions.map(&:to_setter_arg)).join(', ')})
-          BEGIN
-            DECLARE done BOOLEAN;
-            REPEAT
-              BEGIN
-                -- If there is a unique key constraint error then 
-                -- someone made a concurrent insert. Reset the sentinel
-                -- and try again.
-                DECLARE ER_DUP_UNIQUE CONDITION FOR 23000;
-                DECLARE ER_INTEG CONDITION FOR 1062;
-                DECLARE CONTINUE HANDLER FOR ER_DUP_UNIQUE BEGIN
-                  SET done = FALSE;
-                END;
-                
-                DECLARE CONTINUE HANDLER FOR ER_INTEG BEGIN
-                  SET done = TRUE;
-                END;
-
-                SET done = TRUE;
-                SELECT COUNT(*) INTO @count FROM #{quoted_table_name} WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ')};
-                -- Race condition here. If a concurrent INSERT is made after
-                -- the SELECT but before the INSERT below we'll get a duplicate
-                -- key error. But the handler above will take care of that.
-                IF @count > 0 THEN 
-                  -- UPDATE table_name SET b = b_SET WHERE a = a_SEL;
-                  UPDATE #{quoted_table_name} SET #{setter_column_definitions.map(&:to_setter).join(', ')} WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ')};
-                ELSE
-                  -- INSERT INTO table_name (a, b) VALUES (k, data);
-                  INSERT INTO #{quoted_table_name} (#{setter_column_definitions.map(&:quoted_name).join(', ')}) VALUES (#{setter_column_definitions.map(&:quoted_setter_name).join(', ')});
-                END IF;
-              END;
-            UNTIL done END REPEAT;
-          END
-        })
-      end
     end
   end
 end

data/lib/upsert/merge_function/PG_Connection.rb

@@ -1,47 +1,15 @@
+require 'upsert/merge_function/postgresql'
+
 class Upsert
   class MergeFunction
     # @private
     class PG_Connection < MergeFunction
-      MAX_NAME_LENGTH = 63
-
-      class << self
-        def clear(connection)
-          # http://stackoverflow.com/questions/7622908/postgresql-drop-function-without-knowing-the-number-type-of-parameters
-          connection.execute(%{
-            CREATE OR REPLACE FUNCTION pg_temp.upsert_delfunc(text)
-              RETURNS void AS
-            $BODY$
-            DECLARE
-              _sql text;
-            BEGIN
-            FOR _sql IN
-              SELECT 'DROP FUNCTION ' || quote_ident(n.nspname)
-                               || '.' || quote_ident(p.proname)
-                               || '(' || pg_catalog.pg_get_function_identity_arguments(p.oid) || ');'
-              FROM   pg_catalog.pg_proc p
-              LEFT   JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-              WHERE  p.proname = $1
-              AND    pg_catalog.pg_function_is_visible(p.oid) -- you may or may not want this
-            LOOP
-              EXECUTE _sql;
-            END LOOP;
-            END;
-            $BODY$
-              LANGUAGE plpgsql;
-          })
-          connection.execute(%{SELECT proname FROM pg_proc WHERE proname LIKE 'upsert_%'}).each do |row|
-            k = row['proname']
-            next if k == 'upsert_delfunc'
-            Upsert.logger.info %{[upsert] Dropping function #{k.inspect}}
-            connection.execute %{SELECT pg_temp.upsert_delfunc('#{k}')}
-          end
-        end
-      end
+      include Postgresql
 
       def execute(row)
         first_try = true
-        bind_selector_values = row.selector.values.map(&:bind_value)
-        bind_setter_values = row.setter.values.map(&:bind_value)
+        bind_selector_values = row.selector.values.map { |v| connection.bind_value v }
+        bind_setter_values = row.setter.values.map { |v| connection.bind_value v }
         begin
           connection.execute sql, (bind_selector_values + bind_setter_values)
         rescue PG::Error => pg_error
@@ -61,6 +29,7 @@ class Upsert
         end
       end
 
+      # strangely ? can't be used as a placeholder
       def sql
         @sql ||= begin
           bind_params = []
@@ -68,47 +37,6 @@ class Upsert
           %{SELECT #{name}(#{bind_params.join(', ')})}
         end
       end
-
-      # the "canonical example" from http://www.postgresql.org/docs/9.1/static/plpgsql-control-structures.html#PLPGSQL-UPSERT-EXAMPLE
-      # differentiate between selector and setter
-      def create!
-        Upsert.logger.info "[upsert] Creating or replacing database function #{name.inspect} on table #{table_name.inspect} for selector #{selector_keys.map(&:inspect).join(', ')} and setter #{setter_keys.map(&:inspect).join(', ')}"
-        selector_column_definitions = column_definitions.select { |cd| selector_keys.include?(cd.name) }
-        setter_column_definitions = column_definitions.select { |cd| setter_keys.include?(cd.name) }
-        connection.execute(%{
-          CREATE OR REPLACE FUNCTION #{name}(#{(selector_column_definitions.map(&:to_selector_arg) + setter_column_definitions.map(&:to_setter_arg)).join(', ')}) RETURNS VOID AS
-          $$
-          DECLARE
-            first_try INTEGER := 1;
-          BEGIN
-            LOOP
-              -- first try to update the key
-              UPDATE #{quoted_table_name} SET #{setter_column_definitions.map(&:to_setter).join(', ')}
-                WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ') };
-              IF found THEN
-                RETURN;
-              END IF;
-              -- not there, so try to insert the key
-              -- if someone else inserts the same key concurrently,
-              -- we could get a unique-key failure
-              BEGIN
-                INSERT INTO #{quoted_table_name}(#{setter_column_definitions.map(&:quoted_name).join(', ')}) VALUES (#{setter_column_definitions.map(&:quoted_setter_name).join(', ')});
-                RETURN;
-              EXCEPTION WHEN unique_violation THEN
-                -- seamusabshere 9/20/12 only retry once
-                IF (first_try = 1) THEN
-                  first_try := 0;
-                ELSE
-                  RETURN;
-                END IF;
-                -- Do nothing, and loop to try the UPDATE again.
-              END;
-            END LOOP;
-          END;
-          $$
-          LANGUAGE plpgsql;
-        })
-      end
     end
   end
 end

data/lib/upsert/merge_function/SQLite3_Database.rb

@@ -1,29 +1,10 @@
+require 'upsert/merge_function/sqlite3'
+
 class Upsert
   class MergeFunction
     # @private
     class SQLite3_Database < MergeFunction
-      attr_reader :quoted_setter_names
-      attr_reader :quoted_selector_names
-
-      def initialize(*)
-        super
-        @quoted_setter_names = setter_keys.map { |k| connection.quote_ident k }
-        @quoted_selector_names = selector_keys.map { |k| connection.quote_ident k }
-      end
-
-      def create!
-        # not necessary
-      end
-
-      def execute(row)
-        bind_setter_values = row.setter.values.map(&:bind_value)
-        
-        insert_or_ignore_sql = %{INSERT OR IGNORE INTO #{quoted_table_name} (#{quoted_setter_names.join(',')}) VALUES (#{Array.new(bind_setter_values.length, '?').join(',')})}
-        connection.execute insert_or_ignore_sql, bind_setter_values
-
-        update_sql = %{UPDATE #{quoted_table_name} SET #{quoted_setter_names.map { |qk| "#{qk}=?" }.join(',')} WHERE #{quoted_selector_names.map { |qk| "#{qk}=?" }.join(' AND ')}}
-        connection.execute update_sql, (bind_setter_values + row.selector.values.map(&:bind_value))
-      end
+      include Sqlite3
     end
   end
 end

data/lib/upsert/merge_function/mysql.rb

@@ -0,0 +1,67 @@
+class Upsert
+  class MergeFunction
+    # @private
+    module Mysql
+      MAX_NAME_LENGTH = 63
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # http://stackoverflow.com/questions/733349/list-of-stored-procedures-functions-mysql-command-line
+        def clear(connection)
+          connection.execute("SHOW PROCEDURE STATUS WHERE Db = DATABASE() AND Name LIKE 'upsert_%'").map do |row|
+            row['Name'] || row['ROUTINE_NAME']
+          end.each do |name|
+            connection.execute "DROP PROCEDURE IF EXISTS #{connection.quote_ident(name)}"
+          end
+        end
+      end
+
+      # http://stackoverflow.com/questions/11371479/how-to-translate-postgresql-merge-db-aka-upsert-function-into-mysql/
+      def create!
+        Upsert.logger.info "[upsert] Creating or replacing database function #{name.inspect} on table #{table_name.inspect} for selector #{selector_keys.map(&:inspect).join(', ')} and setter #{setter_keys.map(&:inspect).join(', ')}"
+        selector_column_definitions = column_definitions.select { |cd| selector_keys.include?(cd.name) }
+        setter_column_definitions = column_definitions.select { |cd| setter_keys.include?(cd.name) }
+        quoted_name = connection.quote_ident name
+        connection.execute "DROP PROCEDURE IF EXISTS #{quoted_name}"
+        connection.execute(%{
+          CREATE PROCEDURE #{quoted_name}(#{(selector_column_definitions.map(&:to_selector_arg) + setter_column_definitions.map(&:to_setter_arg)).join(', ')})
+          BEGIN
+            DECLARE done BOOLEAN;
+            REPEAT
+              BEGIN
+                -- If there is a unique key constraint error then 
+                -- someone made a concurrent insert. Reset the sentinel
+                -- and try again.
+                DECLARE ER_DUP_UNIQUE CONDITION FOR 23000;
+                DECLARE ER_INTEG CONDITION FOR 1062;
+                DECLARE CONTINUE HANDLER FOR ER_DUP_UNIQUE BEGIN
+                  SET done = FALSE;
+                END;
+                
+                DECLARE CONTINUE HANDLER FOR ER_INTEG BEGIN
+                  SET done = TRUE;
+                END;
+
+                SET done = TRUE;
+                SELECT COUNT(*) INTO @count FROM #{quoted_table_name} WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ')};
+                -- Race condition here. If a concurrent INSERT is made after
+                -- the SELECT but before the INSERT below we'll get a duplicate
+                -- key error. But the handler above will take care of that.
+                IF @count > 0 THEN 
+                  -- UPDATE table_name SET b = b_SET WHERE a = a_SEL;
+                  UPDATE #{quoted_table_name} SET #{setter_column_definitions.map(&:to_setter).join(', ')} WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ')};
+                ELSE
+                  -- INSERT INTO table_name (a, b) VALUES (k, data);
+                  INSERT INTO #{quoted_table_name} (#{setter_column_definitions.map(&:quoted_name).join(', ')}) VALUES (#{setter_column_definitions.map(&:to_setter_value).join(', ')});
+                END IF;
+              END;
+            UNTIL done END REPEAT;
+          END
+        })
+      end
+    end
+  end
+end

data/lib/upsert/merge_function/postgresql.rb

@@ -0,0 +1,94 @@
+class Upsert
+  class MergeFunction
+    # @private
+    module Postgresql
+      MAX_NAME_LENGTH = 63
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def clear(connection)
+          # http://stackoverflow.com/questions/7622908/postgresql-drop-function-without-knowing-the-number-type-of-parameters
+          connection.execute(%{
+            CREATE OR REPLACE FUNCTION pg_temp.upsert_delfunc(text)
+              RETURNS void AS
+            $BODY$
+            DECLARE
+              _sql text;
+            BEGIN
+            FOR _sql IN
+              SELECT 'DROP FUNCTION ' || quote_ident(n.nspname)
+                               || '.' || quote_ident(p.proname)
+                               || '(' || pg_catalog.pg_get_function_identity_arguments(p.oid) || ');'
+              FROM   pg_catalog.pg_proc p
+              LEFT   JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+              WHERE  p.proname = $1
+              AND    pg_catalog.pg_function_is_visible(p.oid) -- you may or may not want this
+            LOOP
+              EXECUTE _sql;
+            END LOOP;
+            END;
+            $BODY$
+              LANGUAGE plpgsql;
+          })
+          connection.execute(%{SELECT proname FROM pg_proc WHERE proname LIKE 'upsert_%'}).each do |row|
+            k = row['proname']
+            next if k == 'upsert_delfunc'
+            Upsert.logger.info %{[upsert] Dropping function #{k.inspect}}
+            connection.execute %{SELECT pg_temp.upsert_delfunc('#{k}')}
+          end
+        end
+      end
+
+      def sql
+        @sql ||= begin
+          bind_params = Array.new(selector_keys.length + setter_keys.length, '?')
+          %{SELECT #{name}(#{bind_params.join(', ')})}
+        end
+      end
+
+      # the "canonical example" from http://www.postgresql.org/docs/9.1/static/plpgsql-control-structures.html#PLPGSQL-UPSERT-EXAMPLE
+      # differentiate between selector and setter
+      def create!
+        Upsert.logger.info "[upsert] Creating or replacing database function #{name.inspect} on table #{table_name.inspect} for selector #{selector_keys.map(&:inspect).join(', ')} and setter #{setter_keys.map(&:inspect).join(', ')}"
+        selector_column_definitions = column_definitions.select { |cd| selector_keys.include?(cd.name) }
+        setter_column_definitions = column_definitions.select { |cd| setter_keys.include?(cd.name) }
+        connection.execute(%{
+          CREATE OR REPLACE FUNCTION #{name}(#{(selector_column_definitions.map(&:to_selector_arg) + setter_column_definitions.map(&:to_setter_arg)).join(', ')}) RETURNS VOID AS
+          $$
+          DECLARE
+            first_try INTEGER := 1;
+          BEGIN
+            LOOP
+              -- first try to update the key
+              UPDATE #{quoted_table_name} SET #{setter_column_definitions.map(&:to_setter).join(', ')}
+                WHERE #{selector_column_definitions.map(&:to_selector).join(' AND ') };
+              IF found THEN
+                RETURN;
+              END IF;
+              -- not there, so try to insert the key
+              -- if someone else inserts the same key concurrently,
+              -- we could get a unique-key failure
+              BEGIN
+                INSERT INTO #{quoted_table_name}(#{setter_column_definitions.map(&:quoted_name).join(', ')}) VALUES (#{setter_column_definitions.map(&:to_setter_value).join(', ')});
+                RETURN;
+              EXCEPTION WHEN unique_violation THEN
+                -- seamusabshere 9/20/12 only retry once
+                IF (first_try = 1) THEN
+                  first_try := 0;
+                ELSE
+                  RETURN;
+                END IF;
+                -- Do nothing, and loop to try the UPDATE again.
+              END;
+            END LOOP;
+          END;
+          $$
+          LANGUAGE plpgsql;
+        })
+      end
+    end
+  end
+end