simple-sql 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cad4b0118fd0c649c4f6050f6f641245292e0b4d
-  data.tar.gz: 8e12a2a3b15218a02f3a2e7464aaec7ea84e39ae
+  metadata.gz: 00ca6e591d2e1aecbf57de4b27c3693e559c6ce5
+  data.tar.gz: c61d3dfa4eeede7e8e1c5a5c59cac3f6c788e197
 SHA512:
-  metadata.gz: acf9fe4aacd51c3a34a34a92d45b339daa673f703d8e933f31e319057c571a3c1cae8b1d181ac8700d1953b18a8f5fd83ed57262e82415adedc662fd5701418c
-  data.tar.gz: 2078e081ab1d2110a1c582a1861d617a201d37ab76896ff05d8a9f5b9f01cc3630bd430a0ae070a48d8fbff473587b3aa775e52486f5f99fd9a2097a54afe11e
+  metadata.gz: 6d9fe86fe3a97443857b51c33294512be9f9a9b555b4783b4807ad85fd2c51a948b4cae4ba96dfb941ae286fa6870cabd777c161517d4c7c14a00ff6c234846a
+  data.tar.gz: 94b1a01d68fd2b2ddc6ec5aceb9e7dda4dce2c86aed7a3bae2f310278004d221652ddd88ada42f583d59d236bfddcfa511f93a6dafa753b2b521b8b2ad802bd0

data/Gemfile.lock

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

data/lib/simple/sql.rb

@@ -9,14 +9,13 @@ require_relative "sql/logging.rb"
 require_relative "sql/connection.rb"
 require_relative "sql/reflection.rb"
 require_relative "sql/insert.rb"
+require_relative "sql/duplicate.rb"
 
 module Simple
   # The Simple::SQL module
   module SQL
     extend self
 
-    attr_accessor :logger
-
     def logger
       @logger ||= default_logger
     end

data/lib/simple/sql/duplicate.rb

@@ -0,0 +1,41 @@
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize
+
+module Simple
+  module SQL
+    def duplicate(table, ids, except: [])
+      ids = Array(ids)
+      return [] if ids.empty?
+
+      timestamp_columns = Reflection.timestamp_columns(table)
+      primary_key_columns = Reflection.primary_key_columns(table)
+
+      # duplicate all columns in the table that need to be SELECTed.
+      #
+      columns_to_dupe = Reflection.columns(table)
+
+      # 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
+
+      # timestamp_columns will not be selected from the table, they will be
+      # set to now() explicitely.
+      columns_to_dupe -= timestamp_columns
+
+      # 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)
+
+      # build query
+      select_columns = columns_to_dupe + timestamp_columns
+      select_values  = columns_to_dupe + timestamp_columns.map { |col| "now() AS #{col}" }
+
+      Simple::SQL.all <<~SQL, ids
+        INSERT INTO #{table}(#{select_columns.join(', ')})
+        SELECT #{select_values.join(', ')} FROM #{table} WHERE id = ANY($1) RETURNING id
+      SQL
+    end
+  end
+end

data/lib/simple/sql/insert.rb

@@ -42,7 +42,7 @@ module Simple
         cols += columns
         vals += columns.each_with_index.map { |_, idx| "$#{idx + 1}" }
 
-        timestamp_columns = timestamp_columns_in_table(table_name) - columns.map(&:to_s)
+        timestamp_columns = SQL::Reflection.timestamp_columns(table_name) - columns.map(&:to_s)
 
         cols += timestamp_columns
         vals += timestamp_columns.map { "now()" }
@@ -50,17 +50,6 @@ module Simple
         @sql = "INSERT INTO #{table_name} (#{cols.join(',')}) VALUES(#{vals.join(',')}) RETURNING id"
       end
 
-      # timestamp_columns are columns that will be set to the current time when
-      # inserting a record. This includes:
-      #
-      # - inserted_at (for Ecto)
-      # - created_at (for ActiveRecord)
-      # - updated_at (for Ecto and ActiveRecord)
-      def timestamp_columns_in_table(table_name)
-        columns_for_table = SQL::Reflection.columns(table_name).keys
-        columns_for_table & %w(inserted_at created_at updated_at)
-      end
-
       def insert(records:)
         SQL.transaction do
           records.map do |record|

data/lib/simple/sql/reflection.rb

@@ -9,23 +9,55 @@ module Simple
       delegate [:ask, :all, :records, :record] => ::Simple::SQL
 
       def tables(schema: "public")
-        select = if schema == "public"
-                   "table_name AS name, *"
-                 else
-                   "table_schema || '.' || table_name AS name, *"
-                 end
-
-        records = ::Simple::SQL.records <<~SQL, schema
-          SELECT #{select}
+        table_info(schema: schema).keys
+      end
+
+      def primary_key_columns(table_name)
+        all <<~SQL, table_name
+          SELECT pg_attribute.attname
+          FROM   pg_index
+          JOIN   pg_attribute ON pg_attribute.attrelid = pg_index.indrelid AND pg_attribute.attnum = ANY(pg_index.indkey)
+          WHERE  pg_index.indrelid = $1::regclass
+          AND    pg_index.indisprimary;
+        SQL
+      end
+
+      TIMESTAMP_COLUMN_NAMES = %w(inserted_at created_at updated_at)
+
+      # timestamp_columns are columns that will be set automatically after
+      # inserting or updating a record. This includes:
+      #
+      # - inserted_at (for Ecto)
+      # - created_at (for ActiveRecord)
+      # - updated_at (for Ecto and ActiveRecord)
+      def timestamp_columns(table_name)
+        columns(table_name) & TIMESTAMP_COLUMN_NAMES
+      end
+
+      def columns(table_name)
+        column_info(table_name).keys
+      end
+
+      private
+
+      def table_info(schema: "public")
+        columns = if schema == "public"
+                    "table_name AS name, *"
+                  else
+                    "table_schema || '.' || table_name AS name, *"
+                  end
+
+        recs = records <<~SQL, schema
+          SELECT #{columns}
           FROM information_schema.tables
           WHERE table_schema=$1
           SQL
-        records_by_attr(records, :name)
+        records_by_attr(recs, :name)
       end
 
-      def columns(table_name)
+      def column_info(table_name)
         schema, table_name = parse_table_name(table_name)
-        records = ::Simple::SQL.records <<~SQL, schema, table_name
+        recs = records <<~SQL, schema, table_name
           SELECT
             column_name AS name,
             *
@@ -33,11 +65,9 @@ module Simple
           WHERE table_schema=$1 AND table_name=$2
         SQL
 
-        records_by_attr(records, :column_name)
+        records_by_attr(recs, :column_name)
       end
 
-      private
-
       def parse_table_name(table_name)
         p1, p2 = table_name.split(".", 2)
         if p2
@@ -49,6 +79,7 @@ module Simple
 
       def records_by_attr(records, attr)
         records.inject({}) do |hsh, record|
+          record.reject! { |_k, v| v.nil? }
           hsh.update record[attr] => OpenStruct.new(record)
         end
       end

data/lib/simple/sql/version.rb

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

data/spec/simple/sql_duplicate_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe "Simple::SQL.duplicate" do
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  let!(:source_ids) { SQL.all("SELECT id FROM users") }
+
+  before do
+    SQL.ask "UPDATE users SET created_at=created_at - interval '1 hour', updated_at=updated_at - interval '1 hour'"
+  end
+
+  it "does not fail on a non-existing 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)
+  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)
+  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)
+  end
+
+  it "updates the timestamp columns" do
+    source_id = source_ids.first
+    dupe_ids = SQL.duplicate "users", source_ids.first
+    dupe_id = dupe_ids.first
+
+    source_timestamp = SQL.ask("SELECT updated_at FROM users WHERE id=$1", source_id)
+    dupe_timestamp = SQL.ask("SELECT updated_at FROM users WHERE id=$1", dupe_id)
+
+    expect(dupe_timestamp).to be > source_timestamp
+  end
+end
+

data/spec/simple/sql_insert_spec.rb

@@ -1,10 +1,6 @@
 require "spec_helper"
 
 describe "Simple::SQL.insert" do
-  def expects(expected_result, sql, *args)
-    expect(SQL.record(sql, *args)).to eq(expected_result)
-  end
-
   let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
 
   it "inserts a single user" do

data/spec/simple/sql_record_spec.rb

@@ -1,10 +1,6 @@
 require "spec_helper"
 
 describe "Simple::SQL.record" do
-  def expects(expected_result, sql, *args)
-    expect(SQL.record(sql, *args)).to eq(expected_result)
-  end
-
   let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
 
   it "calls the database" do

data/spec/simple/sql_reflection_spec.rb

@@ -3,29 +3,21 @@ require "spec_helper"
 describe "Simple::SQL::Reflection" do
   describe ".columns" do
     it "returns the columns of a table in the public schema" do
-      r = SQL::Reflection.columns("users")
-      expect(r).to be_a(Hash)
-      expect(r["first_name"].name).to eq("first_name")
+      expect(SQL::Reflection.columns("users")).to include("first_name")
     end
 
     it "returns the columns of a table in a non-'public' schema" do
-      r = SQL::Reflection.columns("information_schema.tables")
-      expect(r["table_name"].name).to eq("table_name")
+      expect(SQL::Reflection.columns("information_schema.tables")).to include("table_name")
     end
   end
 
   describe ".tables" do
     it "returns the tables in the public schema" do
-      r = SQL::Reflection.tables
-      expect(r.keys).to include("users")
-      expect(r["users"].name).to eq("users")
+      expect(SQL::Reflection.tables).to include("users")
     end
 
     it "returns tables in a non-'public' schema" do
-      r = SQL::Reflection.tables(schema: "information_schema")
-      expect(r.keys).to include("information_schema.tables")
-      expect(r["information_schema.tables"].name).to eq("information_schema.tables")
-      expect(r["information_schema.tables"].table_name).to eq("tables")
+      expect(SQL::Reflection.tables(schema: "information_schema")).to include("information_schema.tables")
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-19 00:00:00.000000000 Z
+date: 2018-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -185,6 +185,7 @@ files:
 - lib/simple/sql/config.rb
 - lib/simple/sql/connection.rb
 - lib/simple/sql/decoder.rb
+- lib/simple/sql/duplicate.rb
 - lib/simple/sql/encoder.rb
 - lib/simple/sql/insert.rb
 - lib/simple/sql/logging.rb
@@ -196,6 +197,7 @@ files:
 - spec/simple/sql_ask_spec.rb
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb
+- spec/simple/sql_duplicate_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb
@@ -235,6 +237,7 @@ test_files:
 - spec/simple/sql_ask_spec.rb
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb
+- spec/simple/sql_duplicate_spec.rb
 - spec/simple/sql_insert_spec.rb
 - spec/simple/sql_record_spec.rb
 - spec/simple/sql_reflection_spec.rb