simple-sql 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00ca6e591d2e1aecbf57de4b27c3693e559c6ce5
-  data.tar.gz: c61d3dfa4eeede7e8e1c5a5c59cac3f6c788e197
+  metadata.gz: d43876c5b3fa11a6a4a3bc08bae85bc6b1c6763e
+  data.tar.gz: 93d58890035c02fe21e0c6016e7efd9344070a36
 SHA512:
-  metadata.gz: 6d9fe86fe3a97443857b51c33294512be9f9a9b555b4783b4807ad85fd2c51a948b4cae4ba96dfb941ae286fa6870cabd777c161517d4c7c14a00ff6c234846a
-  data.tar.gz: 94b1a01d68fd2b2ddc6ec5aceb9e7dda4dce2c86aed7a3bae2f310278004d221652ddd88ada42f583d59d236bfddcfa511f93a6dafa753b2b521b8b2ad802bd0
+  metadata.gz: c7ce6284971ed8827b13aac443c0874e20191a60221b8dbb2745a86a276299a2964451a24623e9ed581dc1e64c88ff1e22dd40f5db18b2146d3dcfbf54f419ce
+  data.tar.gz: d2f5fa8ba870f10a77a8928ec5c9b5be6b11fa55a0e0859040e35b8f276c5dc4341e86223576247ed55df7122ccf2ccb95e9dbad805e23bc1c6b9b07ff4b02b7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.2.8)
+    simple-sql (0.2.9)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 

data/lib/simple/sql/duplicate.rb

@@ -1,41 +1,89 @@
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/AbcSize
+# rubocop:disable Style/StructInheritance
 
 module Simple
   module SQL
-    def duplicate(table, ids, except: [])
+    class Fragment < Struct.new(:to_sql)
+    end
+
+    def fragment(str)
+      Fragment.new(str)
+    end
+
+    #
+    # Creates duplicates of record in a table.
+    #
+    # This method handles timestamp columns (these will be set to the current
+    # time) and primary keys (will be set to NULL.) You can pass in overrides
+    # as a third argument for specific columns.
+    #
+    # Parameters:
+    #
+    # - ids: (Integer, Array<Integer>) primary key ids
+    # - overrides: Hash[column_names => SQL::Fragment]
+    #
+    def duplicate(table, ids, overrides = {})
       ids = Array(ids)
       return [] if ids.empty?
 
-      timestamp_columns = Reflection.timestamp_columns(table)
-      primary_key_columns = Reflection.primary_key_columns(table)
+      Duplicator.new(table, overrides).call(ids)
+    end
+
+    class Duplicator
+      attr_reader :table_name, :custom_overrides
+
+      def initialize(table_name, overrides)
+        @table_name = table_name
+        @custom_overrides = validated_overrides(overrides)
+      end
+
+      def call(ids)
+        Simple::SQL.all query, ids
+      rescue PG::UndefinedColumn => e
+        raise ArgumentError, e.message
+      end
+
+      private
+
+      # This stringify all keys of the overrides hash, and verifies that
+      # all values in there are SQL::Fragments
+      def validated_overrides(overrides)
+        overrides.inject({}) do |hsh, (key, value)|
+          raise ArgumentError, "Unknown value #{value.inspect}" unless value.is_a?(Fragment)
+          hsh.update key.to_s => value.to_sql
+        end
+      end
 
-      # duplicate all columns in the table that need to be SELECTed.
-      #
-      columns_to_dupe = Reflection.columns(table)
+      def timestamp_overrides
+        Reflection.timestamp_columns(table_name).inject({}) do |hsh, column|
+          hsh.update column => "now() AS #{column}"
+        end
+      end
 
-      # Primary keys will not be selected from the table, they should be set
-      # automatically by the database, via a DEFAULT role on the column.
-      columns_to_dupe -= primary_key_columns
+      def copy_columns
+        (Reflection.columns(table_name) - Reflection.primary_key_columns(table_name)).inject({}) do |hsh, column|
+          hsh.update column => column
+        end
+      end
 
-      # timestamp_columns will not be selected from the table, they will be
-      # set to now() explicitely.
-      columns_to_dupe -= timestamp_columns
+      # build SQL query
+      def query
+        sources = {}
 
-      # If some other columns must be excluded they have to be added in the
-      # except: keyword argument. This is helpful for UNIQUE columns, but
-      # a column which is supposed to be UNIQUE and NOT NULL can not be dealt
-      # with.
-      columns_to_dupe -= except.map(&:to_s)
+        sources.update copy_columns
+        sources.update timestamp_overrides
+        sources.update custom_overrides
 
-      # build query
-      select_columns = columns_to_dupe + timestamp_columns
-      select_values  = columns_to_dupe + timestamp_columns.map { |col| "now() AS #{col}" }
+        # convert into an Array, to make sure that keys and values aka firsts
+        # and lasts are always in the correct order.
+        sources = sources.to_a
 
-      Simple::SQL.all <<~SQL, ids
-        INSERT INTO #{table}(#{select_columns.join(', ')})
-        SELECT #{select_values.join(', ')} FROM #{table} WHERE id = ANY($1) RETURNING id
-      SQL
+        <<~SQL
+          INSERT INTO #{table_name}(#{sources.map(&:first).join(', ')})
+            SELECT #{sources.map(&:last).join(', ')}
+            FROM #{table_name}
+            WHERE id = ANY($1) RETURNING id
+        SQL
+      end
     end
   end
 end

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.2.8"
+    VERSION = "0.2.9"
   end
 end

data/spec/simple/sql_duplicate_spec.rb

@@ -10,24 +10,24 @@ describe "Simple::SQL.duplicate" do
   end
 
   it "does not fail on a non-existing user" do
-    dupe_ids = SQL.duplicate "users", source_ids.first
+    dupe_ids = SQL.duplicate "users", -1
 
-    expect(dupe_ids.length).to eq(1)
-    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(3)
+    expect(dupe_ids.length).to eq(0)
+    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(USER_COUNT)
   end
 
   it "duplicates a single user" do
     dupe_ids = SQL.duplicate "users", source_ids.first
 
     expect(dupe_ids.length).to eq(1)
-    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(3)
+    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(1 + USER_COUNT)
   end
 
   it "duplicates many users" do
     dupe_ids = SQL.duplicate "users", (source_ids + [ -10 ])
 
     expect(dupe_ids.length).to eq(2)
-    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(4)
+    expect(SQL.ask("SELECT COUNT(*) FROM users")).to eq(2 + USER_COUNT)
   end
 
   it "updates the timestamp columns" do

data/spec/simple/sql_duplicate_unique_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe "Simple::SQL.duplicate/unique indices" do
+  let!(:unique_users) { 1.upto(USER_COUNT).map { create(:unique_user) } }
+
+  let!(:source_ids) { SQL.all("SELECT id FROM unique_users") }
+
+  it "cannot duplicate unique_user" do
+    expect {
+      SQL.duplicate "unique_users", source_ids
+    }.to raise_error(PG::UniqueViolation)
+  end
+
+  it "raises an ArgumentError when called with unknown columns" do
+    expect {
+      SQL.duplicate "unique_users", source_ids, foo: SQL.fragment("baz")
+    }.to raise_error(ArgumentError)
+  end
+
+  it "raises an ArgumentError when called with invalid overrides" do
+    expect {
+      SQL.duplicate "unique_users", source_ids, first_name: "I am invalid"
+    }.to raise_error(ArgumentError)
+  end
+
+  it "duplicates unique_users" do
+    overrides = {
+      first_name:  SQL.fragment("first_name || '.' || id"),
+      last_name:   SQL.fragment("last_name || '.' || id")
+    }
+
+    dupe_ids = SQL.duplicate "unique_users", source_ids, overrides
+
+    expect(dupe_ids.length).to eq(2)
+    expect(SQL.ask("SELECT COUNT(*) FROM unique_users")).to eq(4)
+  end
+end

data/spec/simple/sql_insert_spec.rb

@@ -15,11 +15,6 @@ describe "Simple::SQL.insert" do
     expect(user.first_name).to eq("foo")
     expect(user.last_name).to eq("bar")
     expect(user.created_at).to be_a(Time)
-
-    #
-    # r = SQL.record("SELECT COUNT(*) AS count FROM users")
-    # r = SQL.record("SELECT COUNT(*) AS count FROM users")
-    # expect(r).to eq({count: 2})
   end
 end
 

data/spec/support/001_database.rb

@@ -35,4 +35,13 @@ ActiveRecord::Schema.define do
 
     t.timestamps null: true
   end
+
+  create_table :unique_users, force: true do |t|
+    t.string    :first_name
+    t.string    :last_name
+  end
+
+  execute <<-SQL
+  CREATE UNIQUE INDEX unique_users_ix1 ON unique_users(first_name, last_name)
+  SQL
 end

data/spec/support/factories/user_factory.rb

@@ -1,8 +1,14 @@
 FactoryGirl.define do
   factory :user do
     role_id         123
-    first_name      "Uni"
-    last_name       "Corn"
+
+    sequence :first_name do |n| "First #{n}" end
+    sequence :last_name  do |n| "Last #{n}"  end
     access_level    "viewable"
   end
+
+  factory :unique_user do
+    sequence :first_name do |n| "First #{n}" end
+    sequence :last_name  do |n| "Last #{n}"  end
+  end
 end

data/spec/support/model/user.rb

@@ -1,2 +1,5 @@
 class User < ActiveRecord::Base
 end
+
+class UniqueUser < ActiveRecord::Base
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - radiospiel
@@ -198,6 +198,7 @@ files:
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb
 - spec/simple/sql_duplicate_spec.rb
+- spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb
@@ -238,6 +239,7 @@ test_files:
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb
 - spec/simple/sql_duplicate_spec.rb
+- spec/simple/sql_duplicate_unique_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb