bmg 0.23.6 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4cb86461e5f53734d08dcb3668bd2a99630680d7213bb946fa5a13cbf0f86f2
-  data.tar.gz: f9a80e014cb2769d6d8da8cea581b18c7601c2d1015db18e1eac6333f8e08876
+  metadata.gz: ff9e5fa48bb225feaeee07ddbfb15f8616e7943be2304113d727d7b8fd71dda2
+  data.tar.gz: b8924512fc6e1b4d8cdb6d86ab40e5e5f317850839ae6d8bc3f02ddd8534e578
 SHA512:
-  metadata.gz: 7621e13e58615206096b3f2d2799a79aa4e662592688b295329bf09626efe86b9a8f4f6f01aba5432513e6054c7568894f13dfccd86d8932f28fa1e9b0892a28
-  data.tar.gz: 9cfc8e393267db43d44764db894b47639d6cfc445b3e7d80e1287929e02cf8ec4d7e541432f52905002953ac727770b5c30b3c4c850ff1a039d98beba2811469
+  metadata.gz: dc7c8dde953a4792a17177abe5a3decd4a3aac156cda87c7ad8854382d2248b03a272a6d318a348fbcba255ba5302e5adbaa4f3764c6db04b61924e9d11e50f4
+  data.tar.gz: 5148e32c981959c62eedae0f8b15cd8816d9afc01f7e1e00e94cc4d7086892e22dc4b6da0a3bb07a57ec138e91060b3c2a839c9f6e4ef5b6af053df08382c20e

data/lib/bmg/sequel/translator.rb

@@ -70,13 +70,21 @@ module Bmg
         case kind = sexpr.left.first
         when :qualified_name
           left.column == right.value ? left : ::Sequel.as(left, right)
-        when :literal, :summarizer, :func_call
+        when :literal, :summarizer, :func_call, :case_when
           ::Sequel.as(left, right)
         else
           raise NotImplementedError, "Unexpected select item `#{kind}`"
         end
       end
 
+      def on_case_when(sexpr)
+        operand = apply(sexpr[1])
+        mapping = sexpr[2..-1].each_slice(2).each_with_object({}){|(w, t), h|
+          h[w.last] = t.last
+        }
+        ::Sequel.case(mapping, nil, operand)
+      end
+
       def on_func_call(sexpr)
         case sexpr.func_name
         when :cast

data/lib/bmg/sql/grammar.rb

@@ -48,3 +48,4 @@ require_relative "nodes/inner_join"
 require_relative "nodes/left_join"
 require_relative "nodes/summarizer"
 require_relative "nodes/func_call"
+require_relative "nodes/case_when"

data/lib/bmg/sql/grammar.sexp.yml

@@ -81,6 +81,9 @@ rules:
     - summarizer
     - func_call
     - literal
+    - case_when
+  case_when:
+    - [ scalar_exp, literal+ ]
   a_name:
     - qualified_name
     - column_name

data/lib/bmg/sql/nodes/case_when.rb

@@ -0,0 +1,33 @@
+module Bmg
+  module Sql
+    module CaseWhen
+      include Expr
+
+      def operand
+        self[1]
+      end
+
+      def whens
+        self[2..-1].each_slice(2).to_a
+      end
+
+      def is_computed?
+        true
+      end
+
+      def to_sql(buffer, dialect)
+        buffer << "CASE "
+        operand.to_sql(buffer, dialect)
+        whens.each do |(when_val, then_val)|
+          buffer << " WHEN "
+          when_val.to_sql(buffer, dialect)
+          buffer << " THEN "
+          then_val.to_sql(buffer, dialect)
+        end
+        buffer << " END"
+        buffer
+      end
+
+    end # module CaseWhen
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/processor/join.rb

@@ -15,7 +15,7 @@ module Bmg
         def call(sexpr)
           if unjoinable?(sexpr)
             call(builder.from_self(sexpr))
-          elsif unjoinable?(right)
+          elsif unjoinable?(right) || left_join_over_restricted_right?
             Join.new(builder.from_self(right), on, options, builder).call(sexpr)
           else
             super(sexpr)
@@ -37,6 +37,20 @@ module Bmg
           sexpr.set_operator? or sexpr.limit_or_offset? or sexpr.group_by?
         end
 
+        # A restriction carried by the right operand of a left join may not be
+        # merged into the WHERE of the whole expression: there it would also
+        # have to hold of the tuples the left join fills with nulls, which is an
+        # inner join and loses exactly what the left join is for. Kept inside a
+        # derived table instead, where it applies to the right operand alone.
+        #
+        # The join condition would hold it just as well, and with less SQL, but
+        # it is the one place a restriction may be anything -- `>`, `IN`, a
+        # negation -- while the from clause orderer models a join condition as
+        # equalities between two qualified names.
+        def left_join_over_restricted_right?
+          left_join? && !right.select_exp.predicate.nil?
+        end
+
         def join_set_quantifiers(left, right)
           left_q, right_q = left.set_quantifier, right.set_quantifier
           left_q == right_q ? left_q : builder.distinct

data/lib/bmg/sql/processor/transform.rb

@@ -50,6 +50,14 @@ module Bmg
           SplitSupported.split_supported(*args, &bl)
         end
 
+        # An SQL-able element the transform can emit verbatim: an object that
+        # carries its own SQL (the predicate gem's `:sql`/`:sql_literal`
+        # convention) or a Sequel expression (rendered through `Sequel.expr`).
+        def self.sql_expr?(x)
+          x.respond_to?(:sql_literal) || x.respond_to?(:sql) ||
+            (defined?(::Sequel::SQL::Expression) && x.is_a?(::Sequel::SQL::Expression))
+        end
+
         def on_select_list(sexpr)
           sexpr.each_with_index.map{|child,index|
             index == 0 ? child : apply(child)
@@ -66,8 +74,17 @@ module Bmg
               func_call_node(sexpr, Array(t).reverse),
               sexpr[2]
             ])
+          when Hash
+            sexpr([:select_item,
+              case_when_node(sexpr, t),
+              sexpr[2]
+            ])
           else
-            raise NotSupportedError
+            # An SQL-able value (e.g. a Sequel expression) carries its own SQL
+            # — including the column reference — so it rides through as a
+            # literal, which the Sequel translator emits verbatim.
+            raise NotSupportedError unless Transform.sql_expr?(t)
+            sexpr([:select_item, [:literal, t], sexpr[2]])
           end
         end
 
@@ -89,6 +106,15 @@ module Bmg
             [ :literal, head ] ]
         end
 
+        def case_when_node(sexpr, mapping)
+          node = [:case_when, sexpr[1]]
+          mapping.each do |when_val, then_val|
+            node << [:literal, when_val]
+            node << [:literal, then_val]
+          end
+          node
+        end
+
         def transformation_for(as)
           case t = transformation
           when Class then t

data/lib/bmg/sql/relation.rb

@@ -167,7 +167,8 @@ module Bmg
       def _transform(type, transformation, options)
         expr = before_use(self.expr)
         sup, unsup = Processor::Transform.split_supported(transformation){|x|
-          [String, Integer, Float, Date, DateTime].include?(x)
+          [String, Integer, Float, Date, DateTime].include?(x) || x.is_a?(Hash) ||
+            Processor::Transform.sql_expr?(x)
         }
         return super if sup.nil?
         expr = Processor::Transform.new(sup, options, builder).call(expr)

data/lib/bmg/version.rb

@@ -1,8 +1,8 @@
 module Bmg
   module Version
     MAJOR = 0
-    MINOR = 23
-    TINY  = 6
+    MINOR = 24
+    TINY  = 1
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.23.6
+  version: 0.24.1
 platform: ruby
 authors:
 - Bernard Lambeau
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-04 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -233,6 +232,7 @@ files:
 - lib/bmg/sql/ext/predicate/tautology.rb
 - lib/bmg/sql/grammar.rb
 - lib/bmg/sql/grammar.sexp.yml
+- lib/bmg/sql/nodes/case_when.rb
 - lib/bmg/sql/nodes/column_name.rb
 - lib/bmg/sql/nodes/cross_join.rb
 - lib/bmg/sql/nodes/except.rb
@@ -332,7 +332,6 @@ homepage: http://github.com/enspirit/bmg
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -347,8 +346,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Bmg is Alf's successor.
 test_files: []