jade-sql 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ccd6b6039a017fd7233f251784fd6275d0b889ad6dbf4a0254e8de8bab4037
-  data.tar.gz: 075edb4238edd0cd475b0d4814043801691a0a6d30ecc06486893c456c6fa7b4
+  metadata.gz: 82ae87a5571e7ef32804036dd347134fc11bcf20a66ebabe7562ac898f943262
+  data.tar.gz: c81268fa4accc4f8bb8f945a8ba164a64ac0ca629d554c9d99874ecb4fb697d5
 SHA512:
-  metadata.gz: 25c6e87aae4190eae3d94eb852ee3cd2cee2fcf3fa786e416af8b8cf4963950586cc7dcd38a1928c6fadd119b3832cd2419c4202573ac02253040952828df2c8
-  data.tar.gz: e621c02ea5a122c726583584cd41ae3fa8a98dfec34d3e11e869a9d43f9c9c30d3e576c0589aab1070328f81e8c212eadc5c93a62c2939e77d5fe799634cdb55
+  metadata.gz: c1cbadd648ec547bcd888c79504d40b630b7e808f0ef0b1e0f379d8b581816d1c3110112fbed3b597dae9987270b13082e68b0561a6ea5bfec2637e7fc81bc4d
+  data.tar.gz: 2864083ceebdd23042ddcd31a3c81d2446b1533b5a7ba8614565138899de6d8fea76bb6a485a8781d16315174cf1856f989890664157bb371ab56cfae2a4e63f

data/lib/jade-sql/runtime.rb

@@ -81,8 +81,18 @@ module JadeSql
     # numeric/decimal columns come back as ::BigDecimal; the schema generator
     # maps them to jade's stdlib Decimal, whose decoder reads the exact
     # "<coefficient>e<exponent>" wire form. Float would lose precision, so don't.
+    # Most rows have nothing to convert — Integers, plain Strings and nils
+    # all come back as themselves — so the copy only happens once a value
+    # actually changes, and each value is still only looked at once.
     def self.coerce_row(row)
-      row.transform_values { |v| coerce_value(v) }
+      out = nil
+
+      row.each_pair do |k, v|
+        coerced = coerce_value(v)
+        (out ||= row.dup)[k] = coerced unless coerced.equal?(v)
+      end
+
+      out || row
     end
 
     def self.coerce_value(v)

data/lib/jade-sql/sql/mutation.jd

@@ -9,6 +9,7 @@ module Sql.Mutation exposing (
   to_sql,
   update,
   update_all,
+  update_many,
 )
 
 import Sql exposing (
@@ -24,6 +25,7 @@ import Sql exposing (
 )
 import Sql.Query exposing (Q)
 import Decode exposing (Value)
+import Encode
 
 
 type MutationKind
@@ -38,7 +40,8 @@ struct Mutation(ret, c) = {
   cols: c,
   rows: List(List(Assignment)),
   wheres: List(Expr(Bool)),
-  returning_selector: Selector(ret)
+  returning_selector: Selector(ret),
+  from_: Maybe(Expr(Bool))
 }
 
 
@@ -50,6 +53,7 @@ def insert(value: a, t: Table(c, m)) -> Mutation(Int, c)
     [to_assigns(value)],
     [],
     Selector([], []),
+     Nothing,
   )
 end
 
@@ -62,6 +66,7 @@ def insert_all(values: List(a), t: Table(c, m)) -> Mutation(Int, c)
     List.map(values, (v) -> { to_assigns(v) }),
     [],
     Selector([], []),
+     Nothing,
   )
 end
 
@@ -76,6 +81,7 @@ def update(value: a, t: Table(c, m)) -> Mutation(Int, c)
     [to_assigns(value)],
     [pk_pred],
     Selector([], []),
+     Nothing,
   )
 end
 
@@ -90,6 +96,7 @@ def delete(value: a, t: Table(c, m)) -> Mutation(Int, c)
     [],
     [pk_pred],
     Selector([], []),
+     Nothing,
   )
 end
 
@@ -109,6 +116,91 @@ def update_all(
     [cols_ |> build],
     [pred],
     Selector([], []),
+     Nothing,
+  )
+end
+
+
+def update_many(values: List(a), t: Table(c, m)) -> Mutation(Int, c)
+  rows = List.zip(
+    values |> List.map((v) -> { pk_values(v) }),
+    values |> List.map((v) -> { to_assigns(v) }),
+  )
+    |> List.map((p) -> { RowUpdate(Tuple.first(p), Tuple.second(p)) })
+
+  Mutation(
+    UpdateK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    [source_assigns(rows)],
+    [pk_join(t.pk_columns)],
+    Selector([], []),
+    Just(source_of(t.name, t.pk_columns, rows)),
+  )
+end
+
+
+struct RowUpdate = {
+  keys: List(Value),
+  assigns: List(Assignment)
+}
+
+
+# One JSON parameter carries every row, so the statement is the same size
+# for two rows or two hundred. json_populate_recordset gives the record
+# the table's own column types, which is what makes a bare `?` legal in a
+# position Postgres cannot otherwise infer.
+def source_of(
+  name: String,
+  pk_columns: List(String),
+  rows: List(RowUpdate),
+) -> Expr(Bool)
+  Expr(
+    "json_populate_recordset(null::" ++ name ++ ", ?::json) AS jade_src",
+    [Encode.string(Encode.encode_to_string(json_rows(pk_columns, rows)))],
+  )
+end
+
+
+def json_rows(pk_columns: List(String), rows: List(RowUpdate)) -> Value
+  Encode.list(json_row(pk_columns, _), rows)
+end
+
+
+def json_row(pk_columns: List(String), r: RowUpdate) -> Value
+  Encode.object(
+    List.zip(pk_columns, r.keys)
+      ++ (r.assigns |> List.map((a) -> { Tuple.Tuple2(a.col, first_param(a)) })),
+  )
+end
+
+
+def first_param(a: Assignment) -> Value
+  a.params |> List.head |> Maybe.with_default(Encode.null)
+end
+
+
+def source_assigns(rows: List(RowUpdate)) -> List(Assignment)
+  rows
+    |> touched_cols
+    |> List.map((col) -> { Assignment(col, "jade_src." ++ col, []) })
+end
+
+
+def touched_cols(rows: List(RowUpdate)) -> List(String)
+  rows
+    |> List.and_then(.assigns)
+    |> List.map(.col)
+    |> List.fold([], (seen, c) -> { List.member?(seen, c) ? seen : seen ++ [c] })
+end
+
+
+def pk_join(pk_columns: List(String)) -> Expr(Bool)
+  Expr(
+    pk_columns
+      |> List.map((col) -> { "jade_tgt." ++ col ++ " = jade_src." ++ col })
+      |> String.join(" AND "),
+    [],
   )
 end
 
@@ -124,12 +216,21 @@ def delete_all(t: Table(c, m), pred_fn: c -> Expr(Bool)) -> Mutation(Int, c)
     [],
     [pred],
     Selector([], []),
+     Nothing,
   )
 end
 
 
 def returning(m: Mutation(a, c), build: c -> Q(Selector(b))) -> Mutation(b, c)
-  Mutation(m.kind, m.table, m.cols, m.rows, m.wheres, build(m.cols).result)
+  Mutation(
+    m.kind,
+    m.table,
+    m.cols,
+    m.rows,
+    m.wheres,
+    build(m.cols).result,
+    m.from_,
+  )
 end
 
 
@@ -163,7 +264,7 @@ end
 
 
 def with_rows(m: Mutation(ret, c), rows: List(List(Assignment))) -> Mutation(ret, c)
-  Mutation(m.kind, m.table, m.cols, rows, m.wheres, m.returning_selector)
+  { m | rows: rows }
 end
 
 
@@ -224,6 +325,33 @@ def set_params_for(rows: List(List(Assignment))) -> List(Value)
 end
 
 
+# A FROM'd UPDATE needs the target aliased: json_populate_recordset gives
+# the source every column the table has, so a bare `id = jade_src.id` is
+# ambiguous.
+def target_ref(m: Mutation(ret, c)) -> String
+  case m.from_
+  in Nothing then m.table.name
+  in Just(_) then m.table.name ++ " AS jade_tgt"
+  end
+end
+
+
+def from_clause(from_: Maybe(Expr(Bool))) -> String
+  case from_
+  in Nothing then ""
+  in Just(e) then " FROM " ++ e.sql
+  end
+end
+
+
+def from_params(from_: Maybe(Expr(Bool))) -> List(Value)
+  case from_
+  in Nothing then []
+  in Just(e) then e.params
+  end
+end
+
+
 def where_sql(wheres: List(Expr(Bool))) -> String
   List.empty?(wheres)
     ? ""
@@ -284,19 +412,26 @@ def render_update_set(
   m: Mutation(ret, c),
   sets: List(String),
 ) -> (String, List(Value))
-  set_clause = "SET " ++ String.join(sets, ", ")
+  set_clause = strip_table_alias(
+    "SET " ++ String.join(sets, ", "),
+    m.table.alias_,
+  )
   where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
   returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
   sql = "UPDATE "
-    ++ m.table.name
+    ++ target_ref(m)
     ++ " "
     ++ set_clause
+    ++ from_clause(m.from_)
     ++ where
     ++ returning_
 
   Tuple.Tuple2(
     sql,
-    set_params_for(m.rows) ++ where_params(m.wheres) ++ m.returning_selector.params,
+    set_params_for(m.rows)
+      ++ from_params(m.from_)
+      ++ where_params(m.wheres)
+      ++ m.returning_selector.params,
   )
 end
 

data/lib/jade-sql/sql.jd

@@ -44,6 +44,7 @@ module Sql exposing (
   maybe_columns,
   neg,
   now,
+  or,
   nullable,
   pk_values,
   render,
@@ -202,6 +203,17 @@ def and(left: Expr(Bool), right: Expr(Bool)) -> Expr(Bool)
 end
 
 
+# Parenthesised where `and` is not, because `where` joins its predicates with
+# AND: without them `x = 1 AND a OR b` binds as `(x = 1 AND a) OR b`, which is
+# not what anyone writing `or` meant.
+def or(left: Expr(Bool), right: Expr(Bool)) -> Expr(Bool)
+  Expr(
+    "(" ++ left.sql ++ " OR " ++ right.sql ++ ")",
+    left.params ++ right.params,
+  )
+end
+
+
 # SUM may return NULL on an empty group, so the result is Expr(Maybe(Int)).
 # Wrap with `coalesce(sum(x), to_expr(0))` for a strict total.
 def sum(e: Expr(Int)) -> Expr(Maybe(Int))

data/lib/jade-sql/version.rb

@@ -1,3 +1,3 @@
 module JadeSql
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-sql
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - agustin
 bindir: exe
 cert_chain: []
-date: 2026-08-03 00:00:00.000000000 Z
+date: 2026-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jade-lang
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.6.0
 description: Query and mutation builders, schema generation from db/structure.sql,
   and an ActiveRecord-backed runtime for the Jade language. Renders typed queries
   to (String, List(Value)) and decodes rows into Jade structs.