db_fuel 1.2.0.pre.alpha → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4f5691edb9519be2c43b787f9eeee14d2e2e83fcf9071e21dbef2442449d3fa
-  data.tar.gz: a95cc6d63d3eba9256c022891328352662b64cf8e0391a92962609f6d3a8062c
+  metadata.gz: 532f508d6074e44c1dd4bb57dcecf343f32e035d44f6bdbfcb0405127ede5552
+  data.tar.gz: dccd390d0c15277ab9ca6c93027d12db85ebe7ad970333ebc2eadc7fc6f39b8c
 SHA512:
-  metadata.gz: 36c2477f3010bd60a7ef7a49f60f7a5302d2cec2ad8be034d83e18923eed07820578a87993a9ebc07e1121c8853d45e5060eaca4d4895222afb3b69b8a8b61f9
-  data.tar.gz: 54f65f7f0d56271bacb6b67512f10135b4d22ddb64dd0a7d1fc864e6d2cd29a0d7e4579056f518cf517b5b3353715bafc489743d596cc8bd8e3e9a0812d6755b
+  metadata.gz: b49ad96e45049b564625a2288786e26087701e84c063aa71b316fde794237006c430fb9cc101ef2704efd79117702c36427e3bdf41098622ddb747e2af01d2f0
+  data.tar.gz: 1d426794ea2045a5a6c1966352b1e9a00ae991cf4d2996315011da26c99fa652ab0ce719dc3a8cd9a495f61df350a1cc1584d7e47a3aa0317276fbea866e6f37

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 2.0.0 (March 16th, 2021)
+
+New Jobs:
+* db_fuel/active_record/upsert
+* db_fuel/active_record/update_all
+
+Changes:
+* db_fuel/active_record/update now only updates a single record. Use db_fuel/active_record/update_all to update multiple records at a time.
+
 # 1.1.0 (Decmeber 1st, 2020)
 
 New Jobs:

data/README.md

@@ -24,16 +24,16 @@ Refer to the [Burner](https://github.com/bluemarblepayroll/burner) library for m
 
 ### ActiveRecord Jobs
 
-* **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/find_or_insert** [name, table_name, attributes, debug, primary_keyed_column, 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_keyed_column, register, separator, timestamps]: This job can take the objects in a register and insert them into a database table.  If primary_keyed_column 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.
+* **db_fuel/active_record/update** [name, table_name, attributes, debug, register, primary_keyed_column, 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_keyed_column is used to update the unique record. Only one record will be updated per statement. Note that composite primary keys are not supported.  Refer to the class and constructor specification for more detail.
+* **db_fuel/active_record/upsert** [name, table_name, attributes, debug, primary_keyed_column, 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_keyed_column 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
 
-* **db_fuel/dbee/query** [model, query, register]:  Pass in a [Dbee](https://github.com/bluemarblepayroll/dbee) model and query and store the results in the specified register.  Refer to the [Dbee](https://github.com/bluemarblepayroll/dbee) library directly on how to craft a model or query.
-* **db_fuel/dbee/range** [key, key_path, model, query, register, separator]: Similar to `db_fuel/dbee/query` with the addition of being able to grab a list of values from the register to use as a Dbee EQUALS/IN filter.  This helps to dynamically limit the resulting record set.  The key is used to specify where to grab the list of values, while the key_path will be used to craft the [Dbee equal's filter](https://github.com/bluemarblepayroll/dbee/blob/master/lib/dbee/query/filters/equals.rb).  Separator is exposed in case nested object support is necessary.
+* **db_fuel/dbee/query** [model, query, register, debug]:  Pass in a [Dbee](https://github.com/bluemarblepayroll/dbee) model and query and store the results in the specified register.  Refer to the [Dbee](https://github.com/bluemarblepayroll/dbee) library directly on how to craft a model or query.
+* **db_fuel/dbee/range** [key, key_path, model, query, register, separator, debug]: Similar to `db_fuel/dbee/query` with the addition of being able to grab a list of values from the register to use as a Dbee EQUALS/IN filter.  This helps to dynamically limit the resulting record set.  The key is used to specify where to grab the list of values, while the key_path will be used to craft the [Dbee equal's filter](https://github.com/bluemarblepayroll/dbee/blob/master/lib/dbee/query/filters/equals.rb).  Separator is exposed in case nested object support is necessary.
 
 ## Examples
 
@@ -98,6 +98,10 @@ If we were to inspect the contents of `payload` we should see the patient's resu
 payload['patients'] # array in form of: [ { "id" => 1, "first_name" => "Something" }, ... ]
 ````
 
+Notes
+
+* Set `debug: true` to print out SQL statement in the output (not for production use.)
+
 ### Limiting Result Sets
 
 The `db_fuel/dbee/query` does not provide a way to dynamically connect the query to existing data.  You are free to put any Dbee query filters in the query declaration, but what if you would like to further limit this based on the knowledge of a range of values?  The `db_fuel/dbee/range` job is meant to do exactly this.  On the surface it is mainly an extension of the `db_fuel/dbee/query` job.
@@ -151,6 +155,10 @@ payload['patients'] # array in form of: [ { "id" => 1, "first_name" => "Somethin
 
 The only difference between the query and range jobs should be the latter is limited based on the incoming first names.
 
+Notes
+
+* Set `debug: true` to print out SQL statement in the output (not for production use.)
+
 ### Updating the Database
 
 #### Inserting Records
@@ -179,7 +187,7 @@ pipeline = {
         { key: :last_name }
       ],
       table_name: 'patients',
-      primary_key: {
+      primary_keyed_column: {
         key: :id
       }
     }
@@ -195,13 +203,13 @@ There should now be two new patients, AB0 and AB1, present in the table `patient
 
 Notes:
 
-* Since we specified the `primary_key`, the records' `id` attributes should be set to their respective primary key values.
+* Since we specified the `primary_keyed_column`, the records' `id` attributes should be set to their respective primary key values.
 * Composite primary keys are not currently supported.
 * Set `debug: true` to print out each INSERT statement in the output (not for production use.)
 
 #### Inserting Only New Records
 
-Another job `db_fuel/active_record/find_or_insert` allows for an existence check to performed each insertion.  If a record is found then it will not insert the record.  If `primary_key` is set then the existence check will also still set the primary key on the payload's respective object.  Note that composite primary keys are not currently supported. We can build on the above insert example for only inserting new patients if their chart_number is unique:
+Another job `db_fuel/active_record/find_or_insert` allows for an existence check to performed each insertion.  If a record is found then it will not insert the record.  If `primary_keyed_column` is set then the existence check will also still set the primary key on the payload's respective object.  Note that composite primary keys are not currently supported. We can build on the above insert example for only inserting new patients if their chart_number is unique:
 
 ````ruby
 pipeline = {
@@ -225,7 +233,7 @@ pipeline = {
         { key: :last_name }
       ],
       table_name: 'patients',
-      primary_key: {
+      primary_keyed_column: {
         key: :id
       },
       unique_attributes: [
@@ -266,7 +274,7 @@ pipeline = {
         { key: :last_name }
       ],
       table_name: 'patients',
-      primary_key: {
+      primary_keyed_column: {
         key: :id
       },
       unique_attributes: [
@@ -348,7 +356,7 @@ pipeline = {
         { key: :last_name }
       ],
       table_name: 'patients',
-      primary_key: {
+      primary_keyed_column: {
         key: :id
       },
       unique_attributes: [

data/db_fuel.gemspec

@@ -42,7 +42,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency('activerecord', activerecord_version)
   s.add_dependency('acts_as_hashable', '~>1.2')
-  s.add_dependency('burner', '~>1.2')
+  s.add_dependency('burner', '~>1.7')
   s.add_dependency('dbee', '~>2.1')
   s.add_dependency('dbee-active_record', '~>2.1')
   s.add_dependency('objectable', '~>1.0')

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

@@ -26,8 +26,8 @@ module DbFuel
                     :attribute_renderers_set
 
         def initialize(
-          name:,
           table_name:,
+          name: '',
           attributes: [],
           debug: false,
           register: Burner::DEFAULT_REGISTER,
@@ -36,13 +36,13 @@ module DbFuel
           super(name: name, register: register)
 
           @resolver = Objectable.resolver(separator: separator)
-          @attribute_renderers_set = Modeling::AttributeRendererSet.new(attributes: attributes,
-                                                                        resolver: resolver)
+          @attribute_renderers_set = Modeling::AttributeRendererSet.new(resolver: resolver,
+                                                                        attributes: attributes)
           @db_provider = DbProvider.new(table_name)
           @debug = debug || false
         end
 
-        private
+        protected
 
         def debug_detail(output, message)
           return unless debug

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

@@ -14,8 +14,9 @@ module DbFuel
     module ActiveRecord
       # This job is a slight enhancement to the insert job, in that it will only insert new
       # 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 primary_key is specified and a record is
-      # found then the first record's id will be set to the primary_key.
+      # Each unique_key becomes a WHERE clause.  If primary_keyed_column is specified
+      # and a record is found then the first record's id will be set to
+      # the primary_keyed_column.
       #
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
@@ -23,7 +24,7 @@ module DbFuel
         # attr_reader :unique_attribute_renderers
 
         # Arguments:
-        #   name [required]: name of the job within the Burner::Pipeline.
+        #   name: name of the job within the Burner::Pipeline.
         #
         #   table_name [required]: name of the table to use for the INSERT statements.
         #
@@ -36,8 +37,9 @@ 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: If primary_key is present then it will be used to set the object's
-        #                property to the returned primary key from the INSERT statement.
+        #   primary_keyed_column: If primary_keyed_column is present then it will be used to set
+        #                     the object's property to the returned primary key
+        #                       from the INSERT 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
@@ -51,11 +53,11 @@ module DbFuel
         #   unique_attributes: Each key will become a WHERE clause in order check for record
         #                      existence before insertion attempt.
         def initialize(
-          name:,
           table_name:,
+          name: '',
           attributes: [],
           debug: false,
-          primary_key: nil,
+          primary_keyed_column: nil,
           register: Burner::DEFAULT_REGISTER,
           separator: '',
           timestamps: true,
@@ -67,7 +69,7 @@ module DbFuel
             table_name: table_name,
             attributes: attributes,
             debug: debug,
-            primary_key: primary_key,
+            primary_keyed_column: primary_keyed_column,
             register: register,
             separator: separator,
             timestamps: timestamps,

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

@@ -17,10 +17,8 @@ module DbFuel
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
       class Insert < Upsert
-        # attr_reader :primary_key
-
         # Arguments:
-        #   name [required]: name of the job within the Burner::Pipeline.
+        #   name: name of the job within the Burner::Pipeline.
         #
         #   table_name [required]: name of the table to use for the INSERT statements.
         #
@@ -33,8 +31,9 @@ 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: If primary_key is present then it will be used to set the object's
-        #                property to the returned primary key from the INSERT statement.
+        #   primary_keyed_column: If primary_keyed_column is present then it will be used to
+        #                     set the object's property to the returned primary key
+        #                     from the INSERT 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
@@ -45,11 +44,11 @@ module DbFuel
         #               and updated_at columns will automatically have their values set
         #               to the current UTC timestamp.
         def initialize(
-          name:,
           table_name:,
+          name: '',
           attributes: [],
           debug: false,
-          primary_key: nil,
+          primary_keyed_column: nil,
           register: Burner::DEFAULT_REGISTER,
           separator: '',
           timestamps: true
@@ -62,7 +61,7 @@ module DbFuel
             table_name: table_name,
             attributes: attributes,
             debug: debug,
-            primary_key: primary_key,
+            primary_keyed_column: primary_keyed_column,
             register: register,
             separator: separator,
             timestamps: timestamps

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

@@ -15,14 +15,14 @@ module DbFuel
       # 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 to find the records to update.
-      # The primary_key is used to update the unique record.
+      # The primary_keyed_column 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 < Upsert
         # Arguments:
-        #   name [required]: name of the job within the Burner::Pipeline.
+        #   name: name of the job within the Burner::Pipeline.
         #
         #   table_name [required]: name of the table to use for the INSERT statements.
         #
@@ -35,7 +35,7 @@ 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.
+        #   primary_keyed_column [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.
@@ -52,11 +52,11 @@ module DbFuel
         #                      records. The UPDATE statement's WHERE
         #                      clause will use the primary key specified.
         def initialize(
-          name:,
           table_name:,
+          name: '',
           attributes: [],
           debug: false,
-          primary_key: nil,
+          primary_keyed_column: nil,
           register: Burner::DEFAULT_REGISTER,
           separator: '',
           timestamps: true,
@@ -70,7 +70,7 @@ module DbFuel
             table_name: table_name,
             attributes: attributes,
             debug: debug,
-            primary_key: primary_key,
+            primary_keyed_column: primary_keyed_column,
             register: register,
             separator: separator,
             timestamps: timestamps,

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

@@ -21,7 +21,7 @@ module DbFuel
       # Payload[register] output: array of objects.
       class UpdateAll < Upsert
         # Arguments:
-        #   name [required]: name of the job within the Burner::Pipeline.
+        #   name: name of the job within the Burner::Pipeline.
         #
         #   table_name [required]: name of the table to use for the INSERT statements.
         #
@@ -45,8 +45,8 @@ module DbFuel
         #   unique_attributes: Each key will become a WHERE clause in order to only update specific
         #                      records.
         def initialize(
-          name:,
           table_name:,
+          name: '',
           attributes: [],
           debug: false,
           register: Burner::DEFAULT_REGISTER,
@@ -62,7 +62,7 @@ module DbFuel
             table_name: table_name,
             attributes: attributes,
             debug: debug,
-            primary_key: nil,
+            primary_keyed_column: nil,
             register: register,
             separator: separator,
             timestamps: timestamps,

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

@@ -16,15 +16,15 @@ module DbFuel
       # 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.
+      # If a record is updated or created the record's id will be set to the primary_keyed_column.
       #
       # Expected Payload[register] input: array of objects
       # Payload[register] output: array of objects.
       class Upsert < Base
-        attr_reader :primary_key, :timestamps, :unique_attribute_renderers
+        attr_reader :primary_keyed_column, :timestamps, :unique_attribute_renderers
 
         # Arguments:
-        #   name [required]: name of the job within the Burner::Pipeline.
+        #   name: name of the job within the Burner::Pipeline.
         #
         #   table_name [required]: name of the table to use for the INSERT OR UPDATE statements.
         #
@@ -38,9 +38,10 @@ module DbFuel
         #                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.
+        #   primary_keyed_column [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
@@ -56,9 +57,9 @@ module DbFuel
         #   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:,
+          primary_keyed_column:,
+          name: '',
           attributes: [],
           debug: false,
           register: Burner::DEFAULT_REGISTER,
@@ -75,10 +76,10 @@ module DbFuel
             separator: separator
           )
 
-          @primary_key = Modeling::KeyedColumn.make(primary_key, nullable: true)
+          @primary_keyed_column = Modeling::KeyedColumn.make(primary_keyed_column, nullable: true)
 
           @unique_attribute_renderers = attribute_renderers_set
-                                        .make_attribute_renderers(unique_attributes)
+                                        .make_renderers(unique_attributes)
 
           @timestamps = timestamps
 
@@ -86,7 +87,7 @@ module DbFuel
         end
 
         def perform(output, payload)
-          raise ArgumentError, 'primary_key is required' unless primary_key
+          raise ArgumentError, 'primary_keyed_column is required' unless primary_keyed_column
 
           total_inserted = 0
           total_updated  = 0
@@ -118,9 +119,9 @@ module DbFuel
 
           first_record = db_provider.first(unique_row)
 
-          id = resolver.get(first_record, primary_key.column)
+          id = resolver.get(first_record, primary_keyed_column.column)
 
-          resolver.set(row, primary_key.key, id)
+          resolver.set(row, primary_keyed_column.key, id)
 
           debug_detail(output, "Record Exists: #{first_record}") if first_record
 
@@ -133,7 +134,7 @@ module DbFuel
                             # set the created_at and updated_at fields
                             attribute_renderers_set.timestamp_created_attribute_renderers
                           else
-                            attribute_renderer_set.attribute_renderers
+                            attribute_renderers_set.attribute_renderers
                           end
 
           set_object = attribute_renderers_set.transform(dynamic_attrs, row, time)
@@ -144,24 +145,24 @@ module DbFuel
 
           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
+          # add the primary key name and value to row if primary_keyed_column was specified
+          resolver.set(row, primary_keyed_column.key, id) if primary_keyed_column
 
           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
+          raise ArgumentError, 'primary_keyed_column is required' unless primary_keyed_column
 
           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)
+            id = resolver.get(first_record, primary_keyed_column.column)
 
-            where_object = { primary_key.key => id }
+            where_object = { primary_keyed_column.column => id }
 
             # update record using the primary key as the WHERE clause
             update(output, row, time, where_object)
@@ -177,7 +178,7 @@ module DbFuel
                             # 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
+                            attribute_renderers_set.attribute_renderers
                           end
 
           set_object = attribute_renderers_set.transform(dynamic_attrs, row, time)

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

@@ -14,7 +14,8 @@ module DbFuel
       class Base < Burner::JobWithRegister
         attr_reader :model,
                     :provider,
-                    :query
+                    :query,
+                    :debug
 
         # Arguments:
         # - model:    Dbee Model configuration
@@ -22,16 +23,18 @@ module DbFuel
         # - register: Name of the register to use for gathering the IN clause values and where
         #             to store the resulting recordset.
         def initialize(
-          name:,
+          name: '',
           model: {},
           query: {},
-          register: Burner::DEFAULT_REGISTER
+          register: Burner::DEFAULT_REGISTER,
+          debug: false
         )
           super(name: name, register: register)
 
           @model    = ::Dbee::Model.make(model)
           @provider = ::Dbee::Providers::ActiveRecordProvider.new
           @query    = ::Dbee::Query.make(query)
+          @debug    = debug || false
 
           freeze
         end
@@ -47,6 +50,12 @@ module DbFuel
 
           payload[register] = records
         end
+
+        def debug_detail(output, message)
+          return unless debug
+
+          output.detail(message)
+        end
       end
     end
   end

data/lib/db_fuel/library/dbee/query.rb

@@ -18,16 +18,48 @@ module DbFuel
       # Expected Payload[register] input: nothing
       # Payload[register] output: array of objects.
       class Query < Base
+        # Arguments:
+        # - name:      Name of job.
+        # - model:     Dbee Model configuration
+        # - query:     Dbee Query configuration
+        #
+        # - register:  Name of the register to use for gathering the IN clause values and where
+        #              to store the resulting recordset.
+        #
+        # - debug:     If debug is set to true (defaults to false) then the SQL statements
+        #              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.
+        def initialize(
+          name: '',
+          model: {},
+          query: {},
+          register: Burner::DEFAULT_REGISTER,
+          debug: false
+        )
+          super(
+            model: model,
+            name: name,
+            query: query,
+            register: register,
+            debug: debug
+          )
+        end
+
         def perform(output, payload)
-          records = execute(sql)
+          records = execute(sql(output))
 
           load_register(records, output, payload)
         end
 
         private
 
-        def sql
-          ::Dbee.sql(model, query, provider)
+        def sql(output)
+          sql_statement = ::Dbee.sql(model, query, provider)
+
+          debug_detail(output, "Query SQL: #{sql_statement}")
+
+          sql_statement
         end
       end
     end

data/lib/db_fuel/library/dbee/range.rb

@@ -32,14 +32,20 @@ module DbFuel
         # - register:  Name of the register to use for gathering the IN clause values and where
         #              to store the resulting recordset.
         # - separator: Character to use to split the key-path for nested object support.
+        #
+        # - debug:     If debug is set to true (defaults to false) then the SQL statements
+        #              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.
         def initialize(
-          name:,
           key:,
+          name: '',
           key_path: '',
           model: {},
           query: {},
           register: Burner::DEFAULT_REGISTER,
-          separator: ''
+          separator: '',
+          debug: false
         )
           raise ArgumentError, 'key is required' if key.to_s.empty?
 
@@ -51,12 +57,13 @@ module DbFuel
             model: model,
             name: name,
             query: query,
-            register: register
+            register: register,
+            debug: debug
           )
         end
 
         def perform(output, payload)
-          records = execute(sql(payload))
+          records = execute(sql(output, payload))
 
           load_register(records, output, payload)
         end
@@ -90,8 +97,13 @@ module DbFuel
           )
         end
 
-        def sql(payload)
-          ::Dbee.sql(model, compile_dbee_query(payload), provider)
+        def sql(output, payload)
+          dbee_query = compile_dbee_query(payload)
+          sql_statement = ::Dbee.sql(model, dbee_query, provider)
+
+          debug_detail(output, "Range SQL: #{sql_statement}")
+
+          sql_statement
         end
       end
     end

data/lib/db_fuel/modeling/attribute_renderer_set.rb

@@ -12,25 +12,31 @@ module DbFuel
     # 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
+    class AttributeRendererSet # :nodoc:
       NOW_TYPE   = 'r/value/now'
-      UPDATED_AT = :updated_at
+
+      CREATED_AT = Burner::Modeling::Attribute.make(
+        key: :created_at, transformers: [{ type: NOW_TYPE }]
+      )
+
+      UPDATED_AT = Burner::Modeling::Attribute.make(
+        key: :updated_at, transformers: [{ type: NOW_TYPE }]
+      )
 
       attr_reader :attribute_renderers, :resolver
 
-      def initialize(attributes: [], resolver: nil)
+      def initialize(resolver:, attributes: [])
         raise ArgumentError, 'resolver is required' unless resolver
 
         @resolver            = resolver
-        @attribute_renderers = make_attribute_renderers(attributes)
+        @attribute_renderers = make_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 = [CREATED_AT, UPDATED_AT]
 
         timestamp_attributes.map do |a|
           Burner::Modeling::AttributeRenderer.new(a, resolver)
@@ -39,14 +45,14 @@ module DbFuel
 
       # Adds the attribute for updated_at to the currrent attribute renderers.
       def timestamp_updated_attribute_renderers
-        timestamp_attributes = [updated_at_timestamp_attribute]
+        timestamp_attributes = [UPDATED_AT]
 
         timestamp_attributes.map do |a|
           Burner::Modeling::AttributeRenderer.new(a, resolver)
         end + attribute_renderers
       end
 
-      def make_attribute_renderers(attributes)
+      def make_renderers(attributes)
         Burner::Modeling::Attribute
           .array(attributes)
           .map { |a| Burner::Modeling::AttributeRenderer.new(a, resolver) }
@@ -59,25 +65,6 @@ module DbFuel
           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.2.0-alpha'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: db_fuel
 version: !ruby/object:Gem::Version
-  version: 1.2.0.pre.alpha
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthew Ruggio
 - John Bosko
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-13 00:00:00.000000000 Z
+date: 2021-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -51,14 +51,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: dbee
   requirement: !ruby/object:Gem::Requirement
@@ -263,7 +263,7 @@ metadata:
   documentation_uri: https://www.rubydoc.info/gems/db_fuel
   homepage_uri: https://github.com/bluemarblepayroll/db_fuel
   source_code_uri: https://github.com/bluemarblepayroll/db_fuel
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -274,12 +274,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Dbee and ActiveRecord jobs for Burner
 test_files: []