em-pg-client-helper 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa2d00ac56931a1fa2d54eca37be26d9f6cdfa9e
-  data.tar.gz: d7e0a651d95809686a4b33b6d5c51ba57a190995
+  metadata.gz: f3bf320941966b1a2de9c01df789aaf6969bd371
+  data.tar.gz: a9d7145ae5bc7e361f27659103a9143450c5063c
 SHA512:
-  metadata.gz: 1eb59a300393ac2cd90a2f078467be406da140d66fe26811713646341f4f2399405ff4f92312824bf29dd7e4800980ba635f5cf703c3e180ff606f9b2e4cc229
-  data.tar.gz: 65100f76c02145ec4b4d004ffc9349db69d5dbe16f58e27468047341dc90a53814107607e49dbb27152593c9e6fc8c9163dc1009243f446e93dbe8e45869c7f0
+  metadata.gz: 4876c2c54967b115f76f2278158ad59eaa9a9b7a8c86d793d018da553dc620d60d60a4e67897a2903208c486786d0282cc639c03dc8b85da1ce5e3e58834fe00
+  data.tar.gz: 1285b6bb57a77d7aeb3876375ccbd52b4d00a2a1db90fc8c868bc74bf9b9945c380d2c5b92a2268058db13aae3f7475747fa51ee343b34630a0d9b258e51eab2

data/lib/em-pg-client-helper/transaction.rb

@@ -245,45 +245,55 @@ class PG::EM::Client::Helper::Transaction
 			df.callback(&blk) if blk
 
 			unique_index_columns_for_table(tbl) do |indexes|
-				# Guh hand-hacked SQL is fugly... but what I'm doing is so utterly
-				# niche that Sequel doesn't support it.
-				q_tbl = usdb.literal(tbl.to_sym)
-				q_cols = columns.map { |c| usdb.literal(c) }
-
-				# If there are any unique indexes which the set of columns to
-				# be inserted into *doesn't* completely cover, we need to error
-				# out, because that will cause no rows (or, at most, one row) to
-				# be successfully inserted.  In *theory*, a unique index with all-but-one
-				# row inserted *could* work, but that would only work if every value
-				# inserted was different, but quite frankly, I think that's a wicked
-				# corner case I'm not going to go *anywhere* near.
-				#
-				unless indexes.all? { |i| (i - columns).empty? }
-					ex = ArgumentError.new("Unique index columns not covered by data columns")
-					if @autorollback_on_error
-						df.fail(ex)
-						rollback(ex)
-					else
-						df.fail(ex)
+				q = if indexes.empty?
+					sequel_sql do |db|
+						db[tbl.to_sym].multi_insert_sql(columns, rows)
 					end
 				else
-					subselect_where = indexes.map do |idx|
-						"(" + idx.map do |c|
-							"src.#{usdb.literal(c)}=dst.#{usdb.literal(c)}"
-						end.join(" AND ") + ")"
-					end.join(" OR ")
-
-					subselect = "SELECT 1 FROM #{q_tbl} AS dst WHERE #{subselect_where}"
-
-					vals = rows.map do |row|
-						"(" + row.map { |v| usdb.literal(v) }.join(", ") + ")"
-					end.join(", ")
-					q = "INSERT INTO #{q_tbl} (SELECT * FROM (VALUES #{vals}) " +
-						 "AS src (#{q_cols.join(", ")}) WHERE NOT EXISTS (#{subselect}))"
-					exec(q) do |res|
-						df.succeed(res.cmd_tuples)
+					# Guh hand-hacked SQL is fugly... but what I'm doing is so utterly
+					# niche that Sequel doesn't support it.
+					q_tbl = usdb.literal(tbl.to_sym)
+					q_cols = columns.map { |c| usdb.literal(c) }
+
+					# If there are any unique indexes which the set of columns to
+					# be inserted into *doesn't* completely cover, we need to error
+					# out, because that will cause no rows (or, at most, one row) to
+					# be successfully inserted.  In *theory*, a unique index with all-but-one
+					# row inserted *could* work, but that would only work if every value
+					# inserted was different, but quite frankly, I think that's a wicked
+					# corner case I'm not going to go *anywhere* near.
+					#
+					unless indexes.all? { |i| (i - columns).empty? }
+						ex = ArgumentError.new("Unique index columns not covered by data columns")
+						if @autorollback_on_error
+							df.fail(ex)
+							rollback(ex)
+						else
+							df.fail(ex)
+						end
+					else
+						subselect_where = indexes.map do |idx|
+							"(" + idx.map do |c|
+								"src.#{usdb.literal(c)}=dst.#{usdb.literal(c)}"
+							end.join(" AND ") + ")"
+						end.join(" OR ")
+
+						subselect = "SELECT 1 FROM #{q_tbl} AS dst WHERE #{subselect_where}"
+
+						vals = rows.map do |row|
+							"(" + row.map { |v| usdb.literal(v) }.join(", ") + ")"
+						end.join(", ")
+
+						"INSERT INTO #{q_tbl} (SELECT * FROM (VALUES #{vals}) " +
+						  "AS src (#{q_cols.join(", ")}) WHERE NOT EXISTS (#{subselect}))"
 					end
 				end
+
+				exec(q) do |res|
+					df.succeed(res.cmd_tuples)
+				end.errback do |ex|
+					df.fail(ex)
+				end
 			end.errback do |ex|
 				df.fail(ex)
 			end

data/spec/db_bulk_insert_spec.rb

@@ -41,4 +41,23 @@ describe "PG::EM::Client::Helper#db_bulk_insert" do
 			end.errback { dbl.errback; EM.stop }
 		end
 	end
+
+	it "inserts multiple records without a UNIQUE index" do
+		expect(dbl = double).to receive(:results).with(2)
+		expect(dbl).to_not receive(:errback)
+
+		in_em do
+			expect_query("BEGIN")
+			expect_unique_indexes_query([])
+			expect_query('INSERT INTO "foo" ("bar", "baz") VALUES (1, \'x\'), (3, \'y\')',
+			             [], 0.001, :succeed, Struct.new(:cmd_tuples).new(2)
+			            )
+			expect_query("COMMIT")
+
+			db_bulk_insert(mock_conn, "foo", [:bar, :baz], [[1, "x"], [3, "y"]]) do |count|
+				dbl.results(count)
+				EM.stop
+			end.errback { dbl.errback; EM.stop }
+		end
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-pg-client-helper
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Matt Palmer