simple-sql 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e55274f31115f6ee480e24a6d539b0709dc9328
-  data.tar.gz: 8756486ff1f0d4f6c71e65d8f0cc945a45cfc73b
+  metadata.gz: 8f45fc27ee92d2023cdcd3eb2b5a0cfbd1a05672
+  data.tar.gz: 8036ee0f56cd039cf1555f8f3fbe323dbaf76a09
 SHA512:
-  metadata.gz: cefcba8027cc317ae3fbcced4ccbf30a6ebc24b29525b0601231d6db6eb8f32df6d7283b54824c55d235816d9861ca055ca2088d946a209d1c40c27e5d73d34e
-  data.tar.gz: 4d5b0b7303076914e8cfe1a154442ffdbb4e2eed2e77e1776a714604a76f0d30308320ae133483a7e276c60e263dc72abe419eccf33e534e8396266a855eaafb
+  metadata.gz: fcef39ebaa97f2807ea6812257b22775d70b3ac21620bdfcf508e4a06340c4142791d7bb6a93d7a17a1c40950236aa3431691afe7c3fcd4072cd1b78d199e1fe
+  data.tar.gz: af8c3af9c817824a76e89c2ed5e7cb9856ad87a696da7e87c26c5cad8a0b9d48d5df92841484e8c27a33a48152069be9a22a0e4269ae7bfb8043a00938cac8d5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.3.1)
+    simple-sql (0.3.2)
       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.3.1"
+    VERSION = "0.3.2"
   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.3.1
+  version: 0.3.2
 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