better_batch 0.1.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cc3b9f2cc9e37f55a2c78f05c4c6e5b97a9d08030b0fc791d68286c76301a3a
-  data.tar.gz: e29d0257f1656ff93375ddbd6b3928256a90f9a5dc3d499fd7360acc626eac24
+  metadata.gz: 13c31343ab529bbd8df1009f601778fb504897bdfdb8b4d77f7165bad88620a1
+  data.tar.gz: 571f51a6631cdac4d47aca08dba3964b281b8831fb5ec7820bcd97c669814116
 SHA512:
-  metadata.gz: a1dfea45b6940be0add55d6f4f7567dbc3c57f30e8db76d22032b12190050a26aab7b59dc1b18e91f0455ed1300850079a3fd249af3857d269366f774848f749
-  data.tar.gz: cefa7b0d4d121ed2c7bfcc74dcaa0dd77313076a3667ad07cade336c8a9bf10af53b868995112b8b9c9148bc6f4708571b97085106eaa97442269f531acc3b67
+  metadata.gz: 38ccffb6de7831944d5c2eb7de2ea93f7ea56c7a9b392ee74fc148d4378795a3f33fdcb55e9e0f3912e7618fa6ecd26a561959c60a1d2fd4e1fd900eb59bd1f8
+  data.tar.gz: e2c9efca1a99bb78aabe321a5f5b5eb322743e5463e8925574512ebc2855a18572b3008570699b396ee99d6569e6ee2670fe9dd7cb5c38d41382e96c3e8145b1

data/.rubocop.yml

@@ -3,7 +3,7 @@ plugins:
   - rubocop-rspec
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.2
 
 RSpec/ContextWording:
   Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.4.2

data/CHANGELOG.md

@@ -1,4 +1,14 @@
-## [Unreleased]
+## [1.0.2] - 2025-04-15
+
+- Test version to excercise deployment updates
+
+## [1.0.1] - 2025-04-15
+
+- Fix dependency definition
+
+## [1.0.0] - 2025-04-15
+
+- Initial feature set
 
 ## [0.1.0] - 2025-04-04
 

data/README.md

@@ -11,30 +11,37 @@ For now, only Postgres is supported.
 In your Gemfile:
 ```ruby
 source 'https://rubygems.org'
-gem 'lazier_data'
+gem 'better_batch'
 ```
 Then:
 `bundle`
 
 ## Usage
 
+If you're using ActiveRecord, you'll want to use [better_batch-active_record](https://github.com/th7/better_batch-active_record).
+
 ```ruby
 table_name = :the_table
 primary_key = :the_primary_key
-columns = %i[column_a column_b column_c]
+input_columns = %i[column_a column_b column_c]
 column_types = {
   column_a: 'character varying(200)',
   column_b: 'bigint',
   column_c: 'text'
 }
 unique_columns = %i[column_b column_c]
-
+now_on_insert = %i[created_at updated_at]
+now_on_update = %i[updated_at]
+returning = %i[id]
 query = BetterBatch::Query.new(
   table_name:,
   primary_key:,
-  columns:,
+  input_columns:,
   column_types:,
-  unique_columns:
+  unique_columns:,
+  now_on_insert:,
+  now_on_update:,
+  returning:
 )
 
 data = [

data/Rakefile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'English'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
@@ -10,3 +11,81 @@ require 'rubocop/rake_task'
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
+
+module Tasks
+  BUILD_FILENAME = 'better_batch.gem'
+
+  class << self
+    include Rake::DSL
+
+    def install
+      install_release_if
+    end
+
+    private
+
+    def install_release_if # rubocop:disable Metrics/MethodLength
+      namespace :release do
+        desc 'release if current version is later than last published version'
+        task if: :default do
+          assert_correct_branch!
+          if current_version > published_version
+            assert_ci!
+            # from bundler, asserts working directory is clean
+            Rake::Task['release'].invoke
+          end
+          assert_version_sane!
+        end
+      end
+    end
+
+    def published_version
+      @published_version ||= build_published_version
+    end
+
+    def build_published_version
+      raw = shr('gem search --remote --exact better_batch')
+      Gem::Version.new(raw.split('(').last.sub(')', ''))
+    end
+
+    def current_version
+      @current_version ||= Gem::Version.new(BetterBatch::VERSION)
+    end
+
+    def assert_version_sane!
+      return unless current_version < published_version
+
+      raise "BetterBatch::VERSION (#{current_version}) " \
+            "is less than the current published (#{published_version}). " \
+            'Was it edited incorrectly?'
+    end
+
+    def current_branch
+      @current_branch ||= shr('git rev-parse --abbrev-ref HEAD').chomp
+    end
+
+    def default_branch
+      @default_branch ||= shr('git remote show origin').match(/HEAD branch: (\S+)$/)[1]
+    end
+
+    def assert_correct_branch!
+      return unless current_branch != default_branch
+
+      raise "On branch (#{current_branch}) instead of default #{default_branch}."
+    end
+
+    def assert_ci!
+      raise 'Not in CI.' unless ENV['CI'] == 'true'
+    end
+
+    def shr(cmd)
+      puts cmd
+      result = `#{cmd}`
+      raise cmd unless $CHILD_STATUS == 0
+
+      result
+    end
+  end
+end
+
+Tasks.install

data/lib/better_batch/inputs.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BetterBatch
+  Inputs = Struct.new(
+    :table_name,
+    :primary_key,
+    :input_columns,
+    :column_types,
+    :unique_columns,
+    :now_on_insert,
+    :now_on_update,
+    :returning,
+    keyword_init: true
+  )
+
+  # this strange (to me) setup avoids method redefinition warnings
+  module InstanceOverrides
+    def returning
+      case self[:returning]
+      when nil
+        []
+      when '*', ['*']
+        column_types.keys
+      else
+        self[:returning]
+      end
+    end
+
+    def now_on_insert
+      return Array(self[:now_on_insert]) unless self[:now_on_insert].is_a?(Array)
+
+      self[:now_on_insert]
+    end
+
+    def now_on_update
+      return Array(self[:now_on_update]) unless self[:now_on_update].is_a?(Array)
+
+      self[:now_on_update]
+    end
+  end
+
+  class Inputs
+    prepend InstanceOverrides
+  end
+end

data/lib/better_batch/inserted.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module BetterBatch
+  class Inserted
+    extend Forwardable
+    def_delegators :@inputs, :table_name, :input_columns, :unique_columns, :primary_key, :now_on_insert, :returning
+
+    TEMPLATE = <<~SQL
+      insert into %<table_name>s (%<input_columns_sql>s)
+        select distinct on (%<query_columns_sql>s)
+          %<select_columns_sql>s
+        from selected
+        where %<primary_key>s is null
+        %<returning_sql>s
+    SQL
+
+    def initialize(inputs)
+      @inputs = inputs
+    end
+
+    def sql
+      format(TEMPLATE, table_name:, primary_key:, input_columns_sql:, query_columns_sql:, select_columns_sql:,
+                       returning_sql:)
+    end
+
+    private
+
+    def input_columns_sql
+      @input_columns_sql ||= (input_columns + now_on_insert).join(', ')
+    end
+
+    def select_columns_sql
+      @select_columns_sql ||= (input_columns + now_as).join(', ')
+    end
+
+    def query_columns_sql
+      @query_columns_sql ||= unique_columns.join(', ')
+    end
+
+    def returning_sql
+      @returning_sql ||= build_returning_sql
+    end
+
+    def build_returning_sql
+      return '' if returning.empty?
+
+      "returning #{((returning - input_columns) + unique_columns).join(', ')}"
+    end
+
+    def now_as
+      @now_as ||= now_on_insert.map { |c| "now() as #{c}" }
+    end
+  end
+end

data/lib/better_batch/query.rb

@@ -1,124 +1,157 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
+require 'anbt-sql-formatter/formatter'
+
+require 'better_batch'
+require 'better_batch/inputs'
+require 'better_batch/selected'
+require 'better_batch/inserted'
+require 'better_batch/updated'
+
 module BetterBatch
   class Query # rubocop:disable Metrics/ClassLength
+    extend Forwardable
+    def_delegators :@inputs, :table_name, :input_columns, :column_types, :unique_columns, :primary_key, :now_on_insert,
+                   :now_on_update, :returning
+
     SELECT_TEMPLATE = <<~SQL
-      select id from (%<selected_inner>s)
-      order by ordinal
+      select %<selected_returning>s
+      from (%<selected_sql>s) selected
+      order by %<ordinal>s
     SQL
 
     UPSERT_TEMPLATE = <<~SQL
-      with selected as (
-        %<selected_inner>s
-      )
-      ,inserted as (
-        %<inserted_inner>s
-      )
-      %<updated_clause>s
-      select coalesce(selected.id, inserted.id) as id
-      from selected left join inserted using(%<query_columns_text>s)
-      order by selected.ordinal
+      with %<with_sql>s
+      select %<upsert_returning>s
+      from selected
+      %<join_sql>s
+      order by selected.%<ordinal>s
     SQL
 
-    SELECTED_INNER_TEMPLATE = <<~SQL
-      select %<table_name>s.%<primary_key>s as id, %<input_columns_text>s, ordinal
-       from rows from (
-         jsonb_to_recordset($1)
-         as (%<typed_columns_text>s)
-       ) with ordinality as input(%<columns_text>s, ordinal)
-       left join %<table_name>s
-       using(%<query_columns_text>s)
+    UPSERT_NO_RETURN_TEMPLATE = <<~SQL
+      with %<with_sql>s
+      select true as done
     SQL
 
-    INSERTED_INNER_TEMPLATE = <<~SQL
-      insert into %<table_name>s (%<columns_text>s, created_at, updated_at)
-        select distinct on (%<query_columns_text>s)
-          %<columns_text>s, now() as created_at, now() as updated_at
-        from selected
-        where id is null
-        returning id, %<query_columns_text>s
-    SQL
+    def initialize(**)
+      @inputs = Inputs.new(**)
+    end
 
-    UPDATED_INNER_TEMPLATE = <<~SQL
-      update %<table_name>s
-      set %<update_columns_text>s, updated_at = now()
-      from selected where %<table_name>s.id = selected.id
-    SQL
+    def select
+      raise Error, 'Select query returning nothing is invalid.' if returning.empty?
 
-    def initialize(table_name:, primary_key:, columns:, column_types:, unique_columns:)
-      @table_name = table_name
-      @primary_key = primary_key
-      @columns = columns
-      @column_types = column_types
-      @unique_columns = unique_columns
+      format(SELECT_TEMPLATE, selected_returning:, selected_sql: selected.sql, ordinal: Selected::ORDINAL)
     end
 
-    def select
-      format(SELECT_TEMPLATE, selected_inner:)
+    def select_formatted
+      format_sql(select)
     end
 
     def upsert
-      params = { selected_inner:, inserted_inner:, updated_clause:, query_columns_text: }
-      format(UPSERT_TEMPLATE, **params)
+      if returning.empty?
+        upsert_no_return
+      else
+        upsert_normal
+      end
+    end
+
+    def upsert_formatted
+      format_sql(upsert)
+    end
+
+    def inspect
+      @inputs.inspect
     end
 
     private
 
-    attr_reader :table_name, :columns, :column_types, :unique_columns, :primary_key
+    def upsert_no_return
+      format(UPSERT_NO_RETURN_TEMPLATE, with_sql:)
+    end
+
+    def upsert_normal
+      params = { with_sql:, upsert_returning:, join_sql:, ordinal: Selected::ORDINAL }
+      format(UPSERT_TEMPLATE, **params)
+    end
 
-    def selected_inner
-      @selected_inner ||= build_selected_inner
+    def with_sql
+      @with_sql ||= build_with_sql
     end
 
-    def build_selected_inner
-      params = { table_name:, primary_key:, input_columns_text:, typed_columns_text:, columns_text:,
-                 query_columns_text: }
-      format(SELECTED_INNER_TEMPLATE, **params)
+    def build_with_sql
+      with_parts.map { |name, sql| "#{name} as (#{sql})" }.join(', ')
     end
 
-    def inserted_inner
-      @inserted_inner ||= build_inserted_inner
+    def with_parts
+      if update_columns.empty?
+        { selected: selected.sql, inserted: inserted.sql }
+      else
+        { selected: selected.sql, inserted: inserted.sql, updated: updated.sql }
+      end
     end
 
-    def build_inserted_inner
-      format(INSERTED_INNER_TEMPLATE, table_name:, columns_text:, query_columns_text:)
+    def selected
+      @selected ||= Selected.new(@inputs)
     end
 
-    def updated_clause
-      @updated_clause ||= build_updated_clause
+    def inserted
+      @inserted ||= Inserted.new(@inputs)
     end
 
-    def build_updated_clause
-      if update_columns.empty?
-        "\n"
+    def updated
+      @updated ||= Updated.new(@inputs)
+    end
+
+    def selected_returning
+      @selected_returning ||= returning.join(', ')
+    end
+
+    def upsert_returning
+      returning.map do |col|
+        qualify_column(col)
+      end.join(', ')
+    end
+
+    def qualify_column(col)
+      if (parts = coalesce_parts(col))
+        "coalesce(#{parts.map { |p| "#{p}.#{col}" }.join(', ')}) as #{col}"
       else
-        updated_clause_template = <<~SQL
-          ,updated as (
-            %<updated_inner>s
-          )
-        SQL
-        format(updated_clause_template, updated_inner:)
+        "selected.#{col}"
       end
     end
 
-    def updated_inner
-      @updated_inner ||= build_updated_inner
+    def coalesce_parts(col)
+      if col == primary_key || now_on_insert_only?(col)
+        %i[selected inserted]
+      elsif now_on_insert.include?(col) && now_on_update.include?(col)
+        %i[inserted updated selected]
+      end
     end
 
-    def build_updated_inner
-      format(UPDATED_INNER_TEMPLATE, table_name:, update_columns_text:)
+    def now_on_insert_only?(col)
+      now_on_insert.include?(col) && !now_on_update.include?(col)
     end
 
-    def input_columns_text
-      @input_columns_text ||= columns.map { |c| "input.#{c}" }.join(', ')
+    def join_sql
+      @join_sql ||= build_join_sql
     end
 
-    def typed_columns_text
-      @typed_columns_text ||= column_types.map { |pair| pair.join(' ') }.join(', ')
+    def build_join_sql
+      join_parts.map { |name| "left join #{name} #{using_sql}" }.join(' ')
+    end
+
+    def join_parts
+      if update_columns.empty?
+        [:inserted]
+      else
+        %i[inserted updated]
+      end
     end
 
-    def columns_text
-      @columns_text ||= columns.join(', ')
+    def using_sql
+      "using (#{query_columns_text})"
     end
 
     def query_columns_text
@@ -126,11 +159,17 @@ module BetterBatch
     end
 
     def update_columns
-      @update_columns ||= columns - unique_columns
+      @update_columns ||= input_columns - unique_columns
     end
 
-    def update_columns_text
-      @update_columns_text ||= update_columns.map { |c| "#{c} = selected.#{c}" }.join(', ')
+    # modified from
+    # https://github.com/sonota88/anbt-sql-formatter/blob/main/bin/anbt-sql-formatter
+    def format_sql(src)
+      rule = AnbtSql::Rule.new
+      rule.keyword = AnbtSql::Rule::KEYWORD_LOWER_CASE
+      rule.indent_string = '  '
+      formatter = AnbtSql::Formatter.new(rule)
+      formatter.format(src)
     end
   end
 end

data/lib/better_batch/selected.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module BetterBatch
+  class Selected
+    extend Forwardable
+    def_delegators :@inputs, :table_name, :input_columns, :column_types, :unique_columns, :primary_key, :returning
+
+    ORDINAL = :better_batch_ordinal
+
+    TEMPLATE = <<~SQL
+      select %<selected_returning>s
+       from rows from (
+         jsonb_to_recordset($1)
+         as (%<typed_columns_sql>s)
+       ) with ordinality as input(%<input_columns_sql>s, %<ordinal>s)
+       left join %<table_name>s
+       using(%<query_columns_sql>s)
+    SQL
+
+    def initialize(inputs)
+      @inputs = inputs
+    end
+
+    def sql
+      params = { table_name:, primary_key:, selected_returning:, typed_columns_sql:, input_columns_sql:,
+                 ordinal: ORDINAL, query_columns_sql: }
+      format(TEMPLATE, **params)
+    end
+
+    private
+
+    def selected_returning
+      @selected_returning ||= qualified_columns.join(', ')
+    end
+
+    def remaining_columns
+      @remaining_columns ||= returning - input_columns
+    end
+
+    def typed_columns_sql
+      @typed_columns_sql ||= input_columns.map { |c| "#{c} #{column_types[c]}" }.join(', ')
+    end
+
+    def input_columns_sql
+      @input_columns_sql ||= input_columns.join(', ')
+    end
+
+    def query_columns_sql
+      @query_columns_sql ||= unique_columns.join(', ')
+    end
+
+    def prefix_table(parts)
+      parts.map { |part| "#{table_name}.#{part}" }
+    end
+
+    def prefix_input(parts)
+      parts.map { |part| "input.#{part}" }
+    end
+
+    def columns
+      @columns ||= {
+        primary_key: [primary_key],
+        input_columns: input_columns - [primary_key],
+        remaining_columns: returning - [primary_key] - input_columns,
+        ordinal: ORDINAL
+      }
+    end
+
+    def qualified_columns
+      @qualified_columns ||= \
+        prefix_table(columns.fetch(:primary_key)) +
+        prefix_table(columns.fetch(:remaining_columns)) +
+        prefix_input(columns.fetch(:input_columns)) +
+        [columns.fetch(:ordinal)]
+    end
+  end
+end

data/lib/better_batch/updated.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module BetterBatch
+  class Updated
+    extend Forwardable
+    def_delegators :@inputs, :table_name, :input_columns, :column_types, :unique_columns, :primary_key, :now_on_update,
+                   :returning
+
+    TEMPLATE = <<~SQL
+      update %<table_name>s
+      set %<set_sql>s
+      from selected where %<table_name>s.%<primary_key>s = selected.%<primary_key>s
+      returning %<returning_sql>s
+    SQL
+
+    def initialize(inputs)
+      @inputs = inputs
+    end
+
+    def sql
+      format(TEMPLATE, table_name:, primary_key:, set_sql:, returning_sql:)
+    end
+
+    private
+
+    def set_sql
+      (update_columns_sql + now_as_sql).join(', ')
+    end
+
+    def update_columns_sql
+      @update_columns_sql ||= update_columns.map { |c| "#{c} = selected.#{c}" }
+    end
+
+    def update_columns
+      @update_columns ||= input_columns - unique_columns
+    end
+
+    def now_as_sql
+      @now_as_sql ||= now_on_update.map { |c| "#{c} = now()" }
+    end
+
+    def returning_sql
+      @returning_sql ||= returning_cols.map { |c| "#{table_name}.#{c}" }.join(', ')
+    end
+
+    def returning_cols
+      (returning - input_columns - now_on_update) + unique_columns + now_on_update
+    end
+  end
+end

data/lib/better_batch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterBatch
-  VERSION = '0.1.0'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: better_batch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Tyler Hartland
 bindir: exe
 cert_chain: []
-date: 2025-04-12 00:00:00.000000000 Z
-dependencies: []
+date: 2025-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anbt-sql-formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 email:
 - tylerhartland7@gmail.com
 executables: []
@@ -17,13 +31,19 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/better_batch.rb
+- lib/better_batch/.DS_Store
+- lib/better_batch/inputs.rb
+- lib/better_batch/inserted.rb
 - lib/better_batch/query.rb
+- lib/better_batch/selected.rb
+- lib/better_batch/updated.rb
 - lib/better_batch/version.rb
 - sig/better_batch.rbs
 homepage: https://github.com/th7/better_batch
@@ -41,7 +61,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="