db_fuel 1.1.0 → 1.2.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e2fc7d0ced8034053e409df7d34fa7127e21e357454221ad0262a59cc5bf2be
-  data.tar.gz: 6b2ce0fd3f4b6661f84820bb2394e49e1e11b111d3df02ce7981996b1eae386e
+  metadata.gz: b4f5691edb9519be2c43b787f9eeee14d2e2e83fcf9071e21dbef2442449d3fa
+  data.tar.gz: a95cc6d63d3eba9256c022891328352662b64cf8e0391a92962609f6d3a8062c
 SHA512:
-  metadata.gz: 73019f998b6db2d10d397e017ab5764dae1e7f4c42ceac403c0a345d91d21fe9da680a46a512a7dad0de85e0a731d6b81bffa0bfab85e7d9b6ca4912c571f0b0
-  data.tar.gz: f0e9b1e9dc28d29659c8532ef39229a8fa7e13c37f2476a75b37dbb62a46469e96ba6916a3eb0df1cc7cdb392c63031271443c0ab54d6933b8c7985f3fcb871b
+  metadata.gz: 36c2477f3010bd60a7ef7a49f60f7a5302d2cec2ad8be034d83e18923eed07820578a87993a9ebc07e1121c8853d45e5060eaca4d4895222afb3b69b8a8b61f9
+  data.tar.gz: 54f65f7f0d56271bacb6b67512f10135b4d22ddb64dd0a7d1fc864e6d2cd29a0d7e4579056f518cf517b5b3353715bafc489743d596cc8bd8e3e9a0812d6755b

data/.rubocop.yml

@@ -1,6 +1,7 @@
 AllCops:
   TargetRubyVersion: 2.5
   NewCops: enable
+  SuggestExtensions: false
 
 Layout/LineLength:
   Max: 100
@@ -8,7 +9,7 @@ Layout/LineLength:
     - db_fuel.gemspec
 
 Metrics/BlockLength:
-  ExcludedMethods:
+  IgnoredMethods:
     - let
     - it
     - describe

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.6

data/README.md

@@ -24,9 +24,11 @@ Refer to the [Burner](https://github.com/bluemarblepayroll/burner) library for m
 
 ### ActiveRecord Jobs
 
-* **db_fuel/active_record/find_or_insert** [table_name, attributes, debug, primary_key, register, separator, timestamps, unique_attributes]: An extension of the `db_fuel/active_record/insert` job that adds an existence check before SQL insertion. The  `unique_attributes` will be converted to WHERE clauses for performing the existence check.
-* **db_fuel/active_record/insert** [table_name, attributes, debug, primary_key, register, separator, timestamps]: This job can take the objects in a register and insert them into a database table.  If primary_key is specified then its key will be set to the primary key.  Note that composite primary keys are not supported.  Attributes defines which object properties to convert to SQL.  Refer to the class and constructor specification for more detail.
-* **db_fuel/active_record/update** [table_name, attributes, debug, register, separator, timestamps, unique_attributes]: This job can take the objects in a register and updates them within a database table.  Attributes defines which object properties to convert to SQL SET clauses while unique_attributes translate to WHERE clauses.  Refer to the class and constructor specification for more detail.
+* **db_fuel/active_record/find_or_insert** [name, table_name, attributes, debug, primary_key, register, separator, timestamps, unique_attributes]: An extension of the `db_fuel/active_record/insert` job that adds an existence check before SQL insertion. The  `unique_attributes` will be converted to WHERE clauses for performing the existence check.
+* **db_fuel/active_record/insert** [name, table_name, attributes, debug, primary_key, register, separator, timestamps]: This job can take the objects in a register and insert them into a database table.  If primary_key is specified then its key will be set to the primary key.  Note that composite primary keys are not supported.  Attributes defines which object properties to convert to SQL.  Refer to the class and constructor specification for more detail.
+* **db_fuel/active_record/update_all** [name, table_name, attributes, debug, register, separator, timestamps, unique_attributes]: This job can take the objects in a register and updates them within a database table.  Attributes defines which object properties to convert to SQL SET clauses while unique_attributes translate to WHERE clauses. One or more records may be updated at a time.  Refer to the class and constructor specification for more detail.
+* **db_fuel/active_record/update** [name, table_name, attributes, debug, register, primary_key, separator, timestamps, unique_attributes]: This job can take the unique objects in a register and updates them within a database table.  Attributes defines which object properties to convert to SQL SET clauses while unique_attributes translate to WHERE clauses to find the records to update. The primary_key is used to update the unique record. Only one record will be updated per statement.  Refer to the class and constructor specification for more detail.
+* **db_fuel/active_record/upsert** [name, table_name, attributes, debug, primary_key, register, separator, timestamps, unique_attributes]: This job can take the objects in a register and either inserts or updates them within a database table.  Attributes defines which object properties to convert to SQL SET clauses while each key in unique_attributes become a WHERE clause in order to check for the existence of a specific record. The updated record will use the primary_key specified to perform the UPDATE operation. Note that composite primary keys are not supported. Refer to the class and constructor specification for more detail.
 
 ### Dbee Jobs
 
@@ -242,7 +244,7 @@ Now only records where the chart_number does not match an existing record will b
 
 #### Updating Records
 
-Let's say we now want to update those records' last names:
+Let's say we now want to update these unique records' last names:
 
 ````ruby
 pipeline = {
@@ -264,6 +266,91 @@ pipeline = {
         { key: :last_name }
       ],
       table_name: 'patients',
+      primary_key: {
+        key: :id
+      },
+      unique_attributes: [
+        { key: :chart_number }
+      ]
+    }
+  ]
+}
+
+payload = Burner::Payload.new
+
+Burner::Pipeline.make(pipeline).execute(payload: payload)
+````
+
+Each database record should have been updated with their new respective last names based on the primary key specified.
+
+#### Updating All Records
+
+Let's say we want to update those records' midddle names:
+
+````ruby
+pipeline = {
+  jobs: [
+    {
+      name: :load_patients,
+      type: 'b/value/static',
+      register: :patients,
+      value: [
+        { chart_number: 'B0001', middle_name: 'Rabbit' },
+        { chart_number: 'C0001', middle_name: 'Elf' }
+      ]
+    },
+    {
+      name: 'update_patients',
+      type: 'db_fuel/active_record/update_all',
+      register: :patients,
+      attributes: [
+        { key: :last_name }
+      ],
+      table_name: 'patients',
+      unique_attributes: [
+        { key: :chart_number }
+      ]
+    }
+  ]
+}
+
+payload = Burner::Payload.new
+
+Burner::Pipeline.make(pipeline).execute(payload: payload)
+````
+
+Each database record should have been updated with their new respective middle names based on chart_number.
+
+#### Upserting Records
+
+Let's say we don't know if these chart_number values already exist or not. 
+So we want db_fuel to either insert a record if the chart_number doesn't exist or update the record if the chart_number already exists.
+
+````ruby
+pipeline = {
+  jobs: [
+    {
+      name: :load_patients,
+      type: 'b/value/static',
+      register: :patients,
+      value: [
+        { chart_number: 'B0002', first_name: 'Babs', last_name: 'Bunny' },
+        { chart_number: 'B0003', first_name: 'Daffy', last_name: 'Duck' }
+      ]
+    },
+    {
+      name: 'update_patients',
+      type: 'db_fuel/active_record/upsert',
+      register: :patients,
+      attributes: [
+        { key: :chart_number },
+        { key: :first_name },
+        { key: :last_name }
+      ],
+      table_name: 'patients',
+      primary_key: {
+        key: :id
+      },
       unique_attributes: [
         { key: :chart_number }
       ]
@@ -276,7 +363,8 @@ payload = Burner::Payload.new
 Burner::Pipeline.make(pipeline).execute(payload: payload)
 ````
 
-Each database record should have been updated with their new respective last names.
+Each database record should have been either inserted or updated with their corresponding values. In this case Babs' last name
+was switched back to Bunny and a new record was created for Daffy Duck.
 
 Notes:
 

data/db_fuel.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |s|
     This library adds database-centric jobs to the Burner library.  Burner does not ship with database jobs out of the box.
   DESCRIPTION
 
-  s.authors     = ['Matthew Ruggio']
-  s.email       = ['mruggio@bluemarblepayroll.com']
+  s.authors     = ['Matthew Ruggio', 'John Bosko']
+  s.email       = ['mruggio@bluemarblepayroll.com', 'jbosko@bluemarblepayroll.com']
   s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   s.bindir      = 'exe'
   s.executables = %w[]
@@ -51,7 +51,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('pry', '~>0')
   s.add_development_dependency('rake', '~> 13')
   s.add_development_dependency('rspec', '~> 3.8')
-  s.add_development_dependency('rubocop', '~>0.90.0')
+  s.add_development_dependency('rubocop', '~>1.7.0')
   s.add_development_dependency('simplecov', '~>0.18.5')
   s.add_development_dependency('simplecov-console', '~>0.7.0')
   s.add_development_dependency('sqlite3', '~>1')

data/lib/db_fuel/library.rb

@@ -10,6 +10,8 @@
 require_relative 'library/active_record/find_or_insert'
 require_relative 'library/active_record/insert'
 require_relative 'library/active_record/update'
+require_relative 'library/active_record/update_all'
+require_relative 'library/active_record/upsert'
 
 require_relative 'library/dbee/query'
 require_relative 'library/dbee/range'
@@ -20,6 +22,8 @@ module Burner
     register 'db_fuel/active_record/find_or_insert', DbFuel::Library::ActiveRecord::FindOrInsert
     register 'db_fuel/active_record/insert',         DbFuel::Library::ActiveRecord::Insert
     register 'db_fuel/active_record/update',         DbFuel::Library::ActiveRecord::Update
+    register 'db_fuel/active_record/update_all',     DbFuel::Library::ActiveRecord::UpdateAll
+    register 'db_fuel/active_record/upsert',         DbFuel::Library::ActiveRecord::Upsert
 
     register 'db_fuel/dbee/query',                   DbFuel::Library::Dbee::Query
     register 'db_fuel/dbee/range',                   DbFuel::Library::Dbee::Range

data/lib/db_fuel/library/active_record/base.rb

@@ -22,7 +22,8 @@ module DbFuel
         attr_reader :attribute_renderers,
                     :db_provider,
                     :debug,
-                    :resolver
+                    :resolver,
+                    :attribute_renderers_set
 
         def initialize(
           name:,
@@ -34,46 +35,15 @@ module DbFuel
         )
           super(name: name, register: register)
 
-          # set resolver first since make_attribute_renderers needs it.
-          @resolver            = Objectable.resolver(separator: separator)
-          @attribute_renderers = make_attribute_renderers(attributes)
-          @db_provider         = DbProvider.new(table_name)
+          @resolver = Objectable.resolver(separator: separator)
+          @attribute_renderers_set = Modeling::AttributeRendererSet.new(attributes: attributes,
+                                                                        resolver: resolver)
+          @db_provider = DbProvider.new(table_name)
           @debug = debug || false
         end
 
         private
 
-        def make_attribute_renderers(attributes)
-          Burner::Modeling::Attribute
-            .array(attributes)
-            .map { |a| Burner::Modeling::AttributeRenderer.new(a, resolver) }
-        end
-
-        def transform(attribute_renderers, row, time)
-          attribute_renderers.each_with_object({}) do |attribute_renderer, memo|
-            value = attribute_renderer.transform(row, time)
-
-            resolver.set(memo, attribute_renderer.key, value)
-          end
-        end
-
-        def created_at_timestamp_attribute
-          timestamp_attribute(CREATED_AT)
-        end
-
-        def updated_at_timestamp_attribute
-          timestamp_attribute(UPDATED_AT)
-        end
-
-        def timestamp_attribute(key)
-          Burner::Modeling::Attribute.make(
-            key: key,
-            transformers: [
-              { type: NOW_TYPE }
-            ]
-          )
-        end
-
         def debug_detail(output, message)
           return unless debug
 

data/lib/db_fuel/library/active_record/find_or_insert.rb

@@ -7,7 +7,7 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'insert'
+require_relative 'upsert'
 
 module DbFuel
   module Library
@@ -19,8 +19,8 @@ module DbFuel
       #
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
-      class FindOrInsert < Insert
-        attr_reader :unique_attribute_renderers
+      class FindOrInsert < Upsert
+        # attr_reader :unique_attribute_renderers
 
         # Arguments:
         #   name [required]: name of the job within the Burner::Pipeline.
@@ -61,6 +61,7 @@ module DbFuel
           timestamps: true,
           unique_attributes: []
         )
+
           super(
             name: name,
             table_name: table_name,
@@ -69,10 +70,9 @@ module DbFuel
             primary_key: primary_key,
             register: register,
             separator: separator,
-            timestamps: timestamps
+            timestamps: timestamps,
+            unique_attributes: unique_attributes
           )
-
-          @unique_attribute_renderers = make_attribute_renderers(unique_attributes)
         end
 
         def perform(output, payload)
@@ -82,14 +82,14 @@ module DbFuel
           payload[register] = array(payload[register])
 
           payload[register].each do |row|
-            exists = existence_check_and_mutate(output, row, payload.time)
+            exists = find_record(output, row, payload.time)
 
             if exists
               total_existed += 1
               next
             end
 
-            insert(output, row, payload.time)
+            insert_record(output, row, payload.time)
 
             total_inserted += 1
           end
@@ -97,29 +97,6 @@ module DbFuel
           output.detail("Total Existed: #{total_existed}")
           output.detail("Total Inserted: #{total_inserted}")
         end
-
-        private
-
-        def existence_check_and_mutate(output, row, time)
-          unique_row = transform(unique_attribute_renderers, row, time)
-
-          first_sql = db_provider.first_sql(unique_row)
-          debug_detail(output, "Find Statement: #{first_sql}")
-
-          first_record = db_provider.first(unique_row)
-
-          return false unless first_record
-
-          if primary_key
-            id = resolver.get(first_record, primary_key.column)
-
-            resolver.set(row, primary_key.key, id)
-          end
-
-          debug_detail(output, "Record Exists: #{first_record}")
-
-          true
-        end
       end
     end
   end

data/lib/db_fuel/library/active_record/insert.rb

@@ -7,7 +7,7 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'base'
+require_relative 'upsert'
 
 module DbFuel
   module Library
@@ -16,8 +16,8 @@ module DbFuel
       #
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
-      class Insert < Base
-        attr_reader :primary_key
+      class Insert < Upsert
+        # attr_reader :primary_key
 
         # Arguments:
         #   name [required]: name of the job within the Burner::Pipeline.
@@ -54,56 +54,25 @@ module DbFuel
           separator: '',
           timestamps: true
         )
-          explicit_attributes = Burner::Modeling::Attribute.array(attributes)
 
-          attributes = timestamps ? timestamp_attributes + explicit_attributes : explicit_attributes
+          attributes = Burner::Modeling::Attribute.array(attributes)
 
           super(
             name: name,
             table_name: table_name,
             attributes: attributes,
             debug: debug,
+            primary_key: primary_key,
             register: register,
-            separator: separator
+            separator: separator,
+            timestamps: timestamps
           )
-
-          @primary_key = Modeling::KeyedColumn.make(primary_key, nullable: true)
         end
 
         def perform(output, payload)
           payload[register] = array(payload[register])
 
-          payload[register].each { |row| insert(output, row, payload.time) }
-        end
-
-        private
-
-        def insert(output, row, time)
-          transformed_row = transform(attribute_renderers, row, time)
-
-          output_sql(output, transformed_row)
-          insert_and_mutate(output, transformed_row, row)
-        end
-
-        def output_sql(output, row)
-          sql = db_provider.insert_sql(row)
-
-          debug_detail(output, "Insert Statement: #{sql}")
-        end
-
-        def insert_and_mutate(output, row_to_insert, row_to_return)
-          id = db_provider.insert(row_to_insert)
-
-          resolver.set(row_to_return, primary_key.key, id) if primary_key
-
-          debug_detail(output, "Insert Return: #{row_to_return}")
-        end
-
-        def timestamp_attributes
-          [
-            created_at_timestamp_attribute,
-            updated_at_timestamp_attribute
-          ]
+          payload[register].each { |row| insert_record(output, row, payload.time) }
         end
       end
     end

data/lib/db_fuel/library/active_record/update.rb

@@ -7,20 +7,20 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'base'
+require_relative 'upsert'
 
 module DbFuel
   module Library
     module ActiveRecord
-      # This job can take the objects in a register and updates them within database table.
+      # This job can take the unique objects in a register and updates them within database table.
       # The attributes translate to SQL SET clauses and the unique_keys translate to
-      # WHERE clauses.
+      # WHERE clauses to find the records to update.
+      # The primary_key is used to update the unique record.
+      # Only one record will be updated per statement.
       #
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
-      class Update < Base
-        attr_reader :unique_attribute_renderers
-
+      class Update < Upsert
         # Arguments:
         #   name [required]: name of the job within the Burner::Pipeline.
         #
@@ -35,6 +35,11 @@ module DbFuel
         #          returned objects will be printed in the output.  Only use this option while
         #          debugging issues as it will fill up the output with (potentially too much) data.
         #
+        #   primary_key [required]: Primary key column for the corresponding table.
+        #                           Used as the WHERE clause for the UPDATE statement.
+        #                           Only one record will be updated at a time
+        #                           using the primary key specified.
+        #
         #   separator: Just like other jobs with a 'separator' option, if the objects require
         #              key-path notation or nested object support, you can set the separator
         #              to something non-blank (like a period for notation in the
@@ -43,33 +48,35 @@ module DbFuel
         #   timestamps: If timestamps is true (default behavior) then the updated_at column will
         #               automatically have its value set to the current UTC timestamp.
         #
-        #   unique_attributes: Each key will become a WHERE clause in order to only update specific
-        #                      records.
+        #   unique_attributes: Each key will become a WHERE clause in order to only find specific
+        #                      records. The UPDATE statement's WHERE
+        #                      clause will use the primary key specified.
         def initialize(
           name:,
           table_name:,
           attributes: [],
           debug: false,
+          primary_key: nil,
           register: Burner::DEFAULT_REGISTER,
           separator: '',
           timestamps: true,
           unique_attributes: []
         )
-          explicit_attributes = Burner::Modeling::Attribute.array(attributes)
 
-          attributes = timestamps ? timestamp_attributes + explicit_attributes : explicit_attributes
+          attributes = Burner::Modeling::Attribute.array(attributes)
 
           super(
             name: name,
             table_name: table_name,
             attributes: attributes,
             debug: debug,
+            primary_key: primary_key,
             register: register,
-            separator: separator
+            separator: separator,
+            timestamps: timestamps,
+            unique_attributes: unique_attributes
           )
 
-          @unique_attribute_renderers = make_attribute_renderers(unique_attributes)
-
           freeze
         end
 
@@ -79,14 +86,11 @@ module DbFuel
           payload[register] = array(payload[register])
 
           payload[register].each do |row|
-            set_object   = transform(attribute_renderers, row, payload.time)
-            where_object = transform(unique_attribute_renderers, row, payload.time)
-
-            sql = db_provider.update_sql(set_object, where_object)
+            rows_affected = 0
 
-            debug_detail(output, "Update Statement: #{sql}")
+            first_record = update_record(output, row, payload.time)
 
-            rows_affected = db_provider.update(set_object, where_object)
+            rows_affected = 1 if first_record
 
             debug_detail(output, "Individual Rows Affected: #{rows_affected}")
 
@@ -95,14 +99,6 @@ module DbFuel
 
           output.detail("Total Rows Affected: #{total_rows_affected}")
         end
-
-        private
-
-        def timestamp_attributes
-          [
-            updated_at_timestamp_attribute
-          ]
-        end
       end
     end
   end

data/lib/db_fuel/library/active_record/update_all.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'upsert'
+
+module DbFuel
+  module Library
+    module ActiveRecord
+      # This job can take the objects in a register and updates them within database table.
+      # The attributes translate to SQL SET clauses
+      # and the unique_keys translate to WHERE clauses.
+      # One or more records may be updated at a time.
+      #
+      # Expected Payload[register] input: array of objects
+      # Payload[register] output: array of objects.
+      class UpdateAll < Upsert
+        # Arguments:
+        #   name [required]: name of the job within the Burner::Pipeline.
+        #
+        #   table_name [required]: name of the table to use for the INSERT statements.
+        #
+        #   attributes:  Used to specify which object properties to put into the
+        #                SQL statement and also allows for one last custom transformation
+        #                pipeline, in case the data calls for SQL-specific transformers
+        #                before mutation.
+        #
+        #   debug: If debug is set to true (defaults to false) then the SQL statements and
+        #          returned objects will be printed in the output.  Only use this option while
+        #          debugging issues as it will fill up the output with (potentially too much) data.
+        #
+        #   separator: Just like other jobs with a 'separator' option, if the objects require
+        #              key-path notation or nested object support, you can set the separator
+        #              to something non-blank (like a period for notation in the
+        #              form of: name.first).
+        #
+        #   timestamps: If timestamps is true (default behavior) then the updated_at column will
+        #               automatically have its value set to the current UTC timestamp.
+        #
+        #   unique_attributes: Each key will become a WHERE clause in order to only update specific
+        #                      records.
+        def initialize(
+          name:,
+          table_name:,
+          attributes: [],
+          debug: false,
+          register: Burner::DEFAULT_REGISTER,
+          separator: '',
+          timestamps: true,
+          unique_attributes: []
+        )
+
+          attributes = Burner::Modeling::Attribute.array(attributes)
+
+          super(
+            name: name,
+            table_name: table_name,
+            attributes: attributes,
+            debug: debug,
+            primary_key: nil,
+            register: register,
+            separator: separator,
+            timestamps: timestamps,
+            unique_attributes: unique_attributes
+          )
+
+          freeze
+        end
+
+        def perform(output, payload)
+          total_rows_affected = 0
+
+          payload[register] = array(payload[register])
+
+          payload[register].each do |row|
+            where_object = attribute_renderers_set
+                           .transform(unique_attribute_renderers, row, payload.time)
+
+            rows_affected = update(output, row, payload.time, where_object)
+
+            debug_detail(output, "Individual Rows Affected: #{rows_affected}")
+
+            total_rows_affected += rows_affected
+          end
+
+          output.detail("Total Rows Affected: #{total_rows_affected}")
+        end
+      end
+    end
+  end
+end

data/lib/db_fuel/library/active_record/upsert.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'base'
+
+module DbFuel
+  module Library
+    module ActiveRecord
+      # This job will insert or update records.
+      # It will use the unique_keys to first run a query to see if it exists.
+      # Each unique_key becomes a WHERE clause. If a record is found it will then
+      # update the found record using the primary key specified.
+      # If a record is updated or created the record's id will be set to the primary_key.
+      #
+      # Expected Payload[register] input: array of objects
+      # Payload[register] output: array of objects.
+      class Upsert < Base
+        attr_reader :primary_key, :timestamps, :unique_attribute_renderers
+
+        # Arguments:
+        #   name [required]: name of the job within the Burner::Pipeline.
+        #
+        #   table_name [required]: name of the table to use for the INSERT OR UPDATE statements.
+        #
+        #   attributes:  Used to specify which object properties to put into the
+        #                SQL statement and also allows for one last custom transformation
+        #                pipeline, in case the data calls for SQL-specific transformers
+        #                before mutation.
+        #
+        #   debug:       If debug is set to true (defaults to false) then the SQL statements and
+        #                returned objects will be printed in the output.  Only use this option while
+        #                debugging issues as it will fill
+        #                up the output with (potentially too much) data.
+        #
+        #   primary_key [required]: Used to set the object's property to the returned primary key
+        #                           from the INSERT statement or used as the
+        #                           WHERE clause for the UPDATE statement.
+        #
+        #   separator: Just like other jobs with a 'separator' option, if the objects require
+        #              key-path notation or nested object support, you can set the separator
+        #              to something non-blank (like a period for notation in the
+        #              form of: name.first).
+        #
+        #   timestamps: If timestamps is true (default behavior) then the updated_at column will
+        #               automatically have its value set
+        #               to the current UTC timestamp if a record was updated.
+        #               If a record was created the
+        #               created_at and updated_at columns will be set.
+        #
+        #   unique_attributes: Each key will become a WHERE clause in
+        #                      order to check for the existence of a specific record.
+        def initialize(
+          name:,
+          table_name:,
+          primary_key:,
+          attributes: [],
+          debug: false,
+          register: Burner::DEFAULT_REGISTER,
+          separator: '',
+          timestamps: true,
+          unique_attributes: []
+        )
+          super(
+            name: name,
+            table_name: table_name,
+            attributes: attributes,
+            debug: debug,
+            register: register,
+            separator: separator
+          )
+
+          @primary_key = Modeling::KeyedColumn.make(primary_key, nullable: true)
+
+          @unique_attribute_renderers = attribute_renderers_set
+                                        .make_attribute_renderers(unique_attributes)
+
+          @timestamps = timestamps
+
+          freeze
+        end
+
+        def perform(output, payload)
+          raise ArgumentError, 'primary_key is required' unless primary_key
+
+          total_inserted = 0
+          total_updated  = 0
+
+          payload[register] = array(payload[register])
+
+          payload[register].each do |row|
+            record_updated = insert_or_update(output, row, payload.time)
+
+            if record_updated
+              total_updated += 1
+            else
+              total_inserted += 1
+            end
+          end
+
+          output.detail("Total Updated: #{total_updated}")
+          output.detail("Total Inserted: #{total_inserted}")
+        end
+
+        protected
+
+        def find_record(output, row, time)
+          unique_row = attribute_renderers_set.transform(unique_attribute_renderers, row, time)
+
+          first_sql = db_provider.first_sql(unique_row)
+
+          debug_detail(output, "Find Statement: #{first_sql}")
+
+          first_record = db_provider.first(unique_row)
+
+          id = resolver.get(first_record, primary_key.column)
+
+          resolver.set(row, primary_key.key, id)
+
+          debug_detail(output, "Record Exists: #{first_record}") if first_record
+
+          first_record
+        end
+
+        def insert_record(output, row, time)
+          dynamic_attrs = if timestamps
+                            # doing an INSERT and timestamps should be set
+                            # set the created_at and updated_at fields
+                            attribute_renderers_set.timestamp_created_attribute_renderers
+                          else
+                            attribute_renderer_set.attribute_renderers
+                          end
+
+          set_object = attribute_renderers_set.transform(dynamic_attrs, row, time)
+
+          insert_sql = db_provider.insert_sql(set_object)
+
+          debug_detail(output, "Insert Statement: #{insert_sql}")
+
+          id = db_provider.insert(set_object)
+
+          # add the primary key name and value to row if primary_key was specified
+          resolver.set(row, primary_key.key, id) if primary_key
+
+          debug_detail(output, "Insert Return: #{row}")
+        end
+
+        # Updates only a single record. Lookups primary key to update the record.
+        def update_record(output, row, time)
+          raise ArgumentError, 'primary_key is required' unless primary_key
+
+          first_record = find_record(output, row, time)
+
+          if first_record
+            debug_detail(output, "Record Exists: #{first_record}")
+
+            id = resolver.get(first_record, primary_key.column)
+
+            where_object = { primary_key.key => id }
+
+            # update record using the primary key as the WHERE clause
+            update(output, row, time, where_object)
+          end
+
+          first_record
+        end
+
+        # Updates one or many records depending on where_object passed
+        def update(output, row, time, where_object)
+          dynamic_attrs = if timestamps
+                            # doing an UPDATE and timestamps should be set,
+                            # modify the updated_at field, don't modify the created_at field
+                            attribute_renderers_set.timestamp_updated_attribute_renderers
+                          else
+                            attribute_renderer_set.attribute_renderers
+                          end
+
+          set_object = attribute_renderers_set.transform(dynamic_attrs, row, time)
+
+          update_sql = db_provider.update_sql(set_object, where_object)
+
+          debug_detail(output, "Update Statement: #{update_sql}")
+
+          debug_detail(output, "Update Return: #{row}")
+
+          db_provider.update(set_object, where_object)
+        end
+
+        private
+
+        def insert_or_update(output, row, time)
+          first_record = update_record(output, row, time)
+
+          if first_record
+            first_record
+          else
+            # create the record
+            insert_record(output, row, time)
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_fuel/modeling.rb

@@ -8,3 +8,4 @@
 #
 
 require_relative 'modeling/keyed_column'
+require_relative 'modeling/attribute_renderer_set'

data/lib/db_fuel/modeling/attribute_renderer_set.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module DbFuel
+  module Modeling
+    # Creates attribute renderers based on attributes passed.
+    # Also constains methods to transform attribute renderers
+    # and include timestamp attributes if needed.
+    class AttributeRendererSet
+      CREATED_AT = :created_at
+      NOW_TYPE   = 'r/value/now'
+      UPDATED_AT = :updated_at
+
+      attr_reader :attribute_renderers, :resolver
+
+      def initialize(attributes: [], resolver: nil)
+        raise ArgumentError, 'resolver is required' unless resolver
+
+        @resolver            = resolver
+        @attribute_renderers = make_attribute_renderers(attributes)
+
+        freeze
+      end
+
+      # Adds the attributes for created_at and updated_at to the currrent attribute renderers.
+      def timestamp_created_attribute_renderers
+        timestamp_attributes = [created_at_timestamp_attribute, updated_at_timestamp_attribute]
+
+        timestamp_attributes.map do |a|
+          Burner::Modeling::AttributeRenderer.new(a, resolver)
+        end + attribute_renderers
+      end
+
+      # Adds the attribute for updated_at to the currrent attribute renderers.
+      def timestamp_updated_attribute_renderers
+        timestamp_attributes = [updated_at_timestamp_attribute]
+
+        timestamp_attributes.map do |a|
+          Burner::Modeling::AttributeRenderer.new(a, resolver)
+        end + attribute_renderers
+      end
+
+      def make_attribute_renderers(attributes)
+        Burner::Modeling::Attribute
+          .array(attributes)
+          .map { |a| Burner::Modeling::AttributeRenderer.new(a, resolver) }
+      end
+
+      def transform(attribute_renderers, row, time)
+        attribute_renderers.each_with_object({}) do |attribute_renderer, memo|
+          value = attribute_renderer.transform(row, time)
+
+          resolver.set(memo, attribute_renderer.key, value)
+        end
+      end
+
+      private
+
+      def created_at_timestamp_attribute
+        timestamp_attribute(CREATED_AT)
+      end
+
+      def updated_at_timestamp_attribute
+        timestamp_attribute(UPDATED_AT)
+      end
+
+      def timestamp_attribute(key)
+        Burner::Modeling::Attribute.make(
+          key: key,
+          transformers: [
+            { type: NOW_TYPE }
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/db_fuel/version.rb

@@ -8,5 +8,5 @@
 #
 
 module DbFuel
-  VERSION = '1.1.0'
+  VERSION = '1.2.0-alpha'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: db_fuel
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0.pre.alpha
 platform: ruby
 authors:
 - Matthew Ruggio
+- John Bosko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-01 00:00:00.000000000 Z
+date: 2021-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -162,14 +163,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.90.0
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -216,6 +217,7 @@ description: "    This library adds database-centric jobs to the Burner library.
   does not ship with database jobs out of the box.\n"
 email:
 - mruggio@bluemarblepayroll.com
+- jbosko@bluemarblepayroll.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -224,6 +226,7 @@ files:
 - ".gitignore"
 - ".rubocop.yml"
 - ".ruby-version"
+- ".tool-versions"
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -242,10 +245,13 @@ files:
 - lib/db_fuel/library/active_record/find_or_insert.rb
 - lib/db_fuel/library/active_record/insert.rb
 - lib/db_fuel/library/active_record/update.rb
+- lib/db_fuel/library/active_record/update_all.rb
+- lib/db_fuel/library/active_record/upsert.rb
 - lib/db_fuel/library/dbee/base.rb
 - lib/db_fuel/library/dbee/query.rb
 - lib/db_fuel/library/dbee/range.rb
 - lib/db_fuel/modeling.rb
+- lib/db_fuel/modeling/attribute_renderer_set.rb
 - lib/db_fuel/modeling/keyed_column.rb
 - lib/db_fuel/version.rb
 homepage: https://github.com/bluemarblepayroll/db_fuel
@@ -268,9 +274,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: