Create batch executions alongside ready and scheduled executions

* Making it explicit is the easiest option, and the most in alignment with solid queue

* Fix errors around upserting across providers. SQLite and Postgres share identical syntax (at least for this use-case) and mysql works differently

Author: jpcamara

app/models/solid_queue/batch_execution.rb

@@ -18,9 +18,7 @@ def create_all_from_jobs(jobs)
           total = jobs.size
           SolidQueue::Batch.upsert(
             { batch_id:, total_jobs: total, pending_jobs: total },
-            on_duplicate: Arel.sql(
-              "total_jobs = total_jobs + #{total}, pending_jobs = pending_jobs + #{total}"
-            )
+            **provider_upsert_options
           )
         end
       end
@@ -48,6 +46,27 @@ def process_job_completion(job, status)
         batch = Batch.find_by(batch_id: batch_id)
         batch&.check_completion!
       end
+
+      private
+
+        def provider_upsert_options
+          case connection.adapter_name
+          when "PostgreSQL", "SQLite"
+            {
+              unique_by: :batch_id,
+              on_duplicate: Arel.sql(
+                "total_jobs = solid_queue_batches.total_jobs + excluded.total_jobs, " \
+                "pending_jobs = solid_queue_batches.pending_jobs + excluded.pending_jobs"
+              )
+            }
+          else
+            {
+              on_duplicate: Arel.sql(
+                "total_jobs = total_jobs + VALUES(total_jobs), pending_jobs = pending_jobs + VALUES(pending_jobs)"
+              )
+            }
+          end
+        end
     end
   end
 end

app/models/solid_queue/execution/batch_preparable.rb

@@ -9,10 +9,21 @@ module Batchable
         belongs_to :batch, foreign_key: :batch_id, primary_key: :batch_id, class_name: "SolidQueue::Batch", optional: true
         has_one :batch_execution, foreign_key: :job_id, dependent: :destroy
 
+        after_create :create_batch_execution, if: :batch_id?
         after_update :update_batch_progress, if: :batch_id?
       end
 
+      class_methods do
+        def batch_all(jobs)
+          BatchExecution.create_all_from_jobs(jobs)
+        end
+      end
+
       private
+        def create_batch_execution
+          BatchExecution.create_all_from_jobs([ self ])
+        end
+
         def update_batch_progress
           return unless saved_change_to_finished_at? && finished_at.present?
           return unless batch_id.present?

app/models/solid_queue/job/batchable.rb

@@ -19,7 +19,9 @@ module Executable
       class_methods do
         def prepare_all_for_execution(jobs)
           due, not_yet_due = jobs.partition(&:due?)
-          dispatch_all(due) + schedule_all(not_yet_due)
+          (dispatch_all(due) + schedule_all(not_yet_due)).tap do |jobs|
+            batch_all(jobs.select { |job| job.batch_id.present? })
+          end
         end
 
         def dispatch_all(jobs)

app/models/solid_queue/job/executable.rb

@@ -2,8 +2,6 @@
 
 module SolidQueue
   class ReadyExecution < Execution
-    include BatchPreparable
-
     scope :queued_as, ->(queue_name) { where(queue_name: queue_name) }
 
     assumes_attributes_from_job

app/models/solid_queue/ready_execution.rb

@@ -2,7 +2,7 @@
 
 module SolidQueue
   class ScheduledExecution < Execution
-    include Dispatching, BatchPreparable
+    include Dispatching
 
     scope :due, -> { where(scheduled_at: ..Time.current) }
     scope :ordered, -> { order(scheduled_at: :asc, priority: :asc, job_id: :asc) }

app/models/solid_queue/scheduled_execution.rb

@@ -234,6 +234,30 @@ def perform
     assert_finished_in_order(batch2.reload, batch1.reload)
   end
 
+  test "executes the same with perform_all_later as it does a normal enqueue" do
+    batch2 = nil
+    batch1 = SolidQueue::Batch.enqueue do
+      ActiveJob.perform_all_later([ FailingJob.new, FailingJob.new ])
+      batch2 = SolidQueue::Batch.enqueue do
+        ActiveJob.perform_all_later([ AddToBufferJob.new("ok"), AddToBufferJob.new("ok2") ])
+      end
+    end
+
+    @dispatcher.start
+    @worker.start
+
+    wait_for_batches_to_finish_for(3.seconds)
+    wait_for_jobs_to_finish_for(1.second)
+
+    assert_equal 6, batch1.reload.jobs.count
+    assert_equal 6, batch1.total_jobs
+    assert_equal 2, SolidQueue::Batch.finished.count
+    assert_equal "failed", batch1.status
+    assert_equal 2, batch2.reload.jobs.count
+    assert_equal 2, batch2.total_jobs
+    assert_equal "completed", batch2.status
+  end
+
   test "discarded jobs fire properly" do
     batch2 = nil
     batch1 = SolidQueue::Batch.enqueue(on_success: BatchOnSuccessJob.new("0")) do