jade-sql 0.7.0 → 0.8.0

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

@@ -0,0 +1,625 @@
+module Sql.Write exposing (
+  Action(..),
+  Conflict(..),
+  do_nothing,
+  do_update,
+  Write,
+  on_conflict,
+  delete,
+  execute,
+  fetch_many,
+  fetch_one,
+  delete_all,
+  insert,
+  insert_all,
+  Stamped,
+  returning,
+  timestamped,
+  to_sql,
+  update,
+  filter,
+  update_all,
+  update_many,
+)
+
+import Sql exposing (
+  Assignable,
+  Assignment(..),
+  Expr(..),
+  ToSql,
+  Selector(..),
+  SqlError,
+  Pk,
+  Table,
+  Unique,
+  TableRef(..),
+  set,
+  to_assigns,
+)
+import Sql.Query exposing (Query)
+import Decode exposing (Value)
+import Encode
+
+
+type WriteKind
+  = InsertK
+  | UpdateK
+  | DeleteK
+
+
+struct Write(ret, c, s) = {
+  kind: WriteKind,
+  table: TableRef,
+  cols: c,
+  set_cols: s,
+  rows: List(List(Assignment)),
+  wheres: List(Expr(Bool)),
+  returning_selector: Selector(ret),
+  from_: Maybe(Expr(Bool)),
+  conflict: Maybe(Conflict)
+}
+
+
+# `ON CONFLICT (cols) DO NOTHING` or `DO UPDATE SET ...`. The columns are the
+# conflict target, taken from a `Unique`, so the index it names is the one the
+# database will actually use to detect the conflict.
+type Conflict
+  = DoNothing(List(String))
+  | DoUpdate(List(String), List(Assignment))
+
+
+# What to do with a row that collides, as a value: `do_nothing`, or
+# `do_update` with what to write instead. Both name the SQL they render.
+type Action(s)
+  = DoNothingA
+  | DoUpdateA(s -> List(Assignment))
+
+
+def do_nothing -> Action(s)
+  DoNothingA
+end
+
+
+# The build receives the table's `SET` columns. Reach for `set_excluded` to
+# take a value from the row that could not be inserted.
+def do_update(build: s -> List(Assignment)) -> Action(s)
+  DoUpdateA(build)
+end
+
+
+def insert(value: a, t: Table(c, m, k, o, r, s)) -> Write(Int, c, s)
+  Write(
+    InsertK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    t.set_cols,
+    [to_assigns(value)],
+    [],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+def insert_all(values: List(a), t: Table(c, m, k, o, r, s)) -> Write(Int, c, s)
+  Write(
+    InsertK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    t.set_cols,
+    List.map(values, (v) -> { to_assigns(v) }),
+    [],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+def update(value: a, t: Table(c, m, k, o, r, s), key: k) -> Write(Int, c, s)
+  Write(
+    UpdateK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    t.set_cols,
+    [without_created_at(without_key(t.pk, to_assigns(value)))],
+    [key_predicate(t.pk, key)],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+def delete(t: Table(c, m, k, o, r, s), key: k) -> Write(Int, c, s)
+  Write(
+    DeleteK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    t.set_cols,
+    [],
+    [key_predicate(t.pk, key)],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+def filter(m: Write(ret, c, s), build: c -> Expr(Bool)) -> Write(ret, c, s)
+  Write(
+    m.kind,
+    m.table,
+    m.cols,
+    m.set_cols,
+    m.rows,
+    m.wheres ++ [m.cols |> build],
+    m.returning_selector,
+    m.from_,
+    m.conflict,
+  )
+end
+
+
+def update_all(
+  t: Table(c, m, k, o, r, s),
+  pred_fn: c -> Expr(Bool),
+  build: c, s -> List(Assignment),
+) -> Write(Int, c, s)
+  cols_ = t.alias_ |> t.cols
+  pred = cols_ |> pred_fn
+
+  Write(
+    UpdateK,
+    TableRef(t.name, t.alias_),
+    cols_,
+    t.set_cols,
+    [build(cols_, t.set_cols)],
+    [pred],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+def update_many(rows_: List((k, a)), t: Table(c, m, k, o, r, s)) -> Write(Int, c, s)
+  rows = rows_ |> List.map((r) -> { keyed_assigns(t.pk, r) })
+
+  Write(
+    UpdateK,
+    TableRef(t.name, t.alias_),
+    t.alias_ |> t.cols,
+    t.set_cols,
+    [source_assigns(t.pk, rows)],
+    [pk_join(t.alias_, t.pk.columns)],
+    Selector([], []),
+    Just(source_of(t.name, rows)),
+    Nothing,
+  )
+end
+
+
+# The key travels with each row so the JSON source carries the columns the
+# join matches on, without the caller's struct having to hold them.
+def keyed_assigns(pk_: Pk(c, k), r: (k, a)) -> List(Assignment)
+  (key, value) = r
+
+  key_assigns(pk_, key) ++ without_created_at(without_key(pk_, to_assigns(value)))
+end
+
+
+def key_assigns(pk_: Pk(c, k), key: k) -> List(Assignment)
+  List.zip(pk_.columns, key |> pk_.values)
+    |> List.map((p) -> { Assignment(Tuple.first(p), "?", [Tuple.second(p)]) })
+end
+
+
+# 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, rows: List(List(Assignment))) -> Expr(Bool)
+  Expr(
+    "json_populate_recordset(null::" ++ name ++ ", ?::json) AS jade_src",
+    [Encode.string(Encode.encode_to_string(json_rows(rows)))],
+  )
+end
+
+
+def json_rows(rows: List(List(Assignment))) -> Value
+  Encode.list(json_row(_), rows)
+end
+
+
+def json_row(row: List(Assignment)) -> Value
+  Encode.object(row |> 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(pk_: Pk(c, k), rows: List(List(Assignment))) -> List(Assignment)
+  rows
+    |> touched_cols
+    |> List.filter((col) -> { List.member?(pk_.columns, col) |> Basics.not })
+    |> List.map((col) -> { Assignment(col, "jade_src." ++ col, []) })
+end
+
+
+def touched_cols(rows: List(List(Assignment))) -> List(String)
+  rows
+    |> List.concat
+    |> List.map(.col)
+    |> List.fold([], (seen, c) -> { List.member?(seen, c) ? seen : seen ++ [c] })
+end
+
+
+def pk_join(alias_: String, pk_columns: List(String)) -> Expr(Bool)
+  Expr(
+    pk_columns
+      |> List.map((col) -> { alias_ ++ "." ++ col ++ " = jade_src." ++ col })
+      |> String.join(" AND "),
+    [],
+  )
+end
+
+
+def delete_all(t: Table(c, m, k, o, r, s), pred_fn: c -> Expr(Bool)) -> Write(Int, c, s)
+  cols_ = t.alias_ |> t.cols
+  pred = cols_ |> pred_fn
+
+  Write(
+    DeleteK,
+    TableRef(t.name, t.alias_),
+    cols_,
+    t.set_cols,
+    [],
+    [pred],
+    Selector([], []),
+    Nothing,
+    Nothing,
+  )
+end
+
+
+# `ON CONFLICT (email) DO NOTHING`, or `... DO UPDATE SET ...`. The target
+# comes from a `Unique`, so the index named is one the database has, and the
+# action says which of the two it is:
+#
+#   insert(row, users) |> on_conflict(users_email_key, do_nothing)
+#   insert(row, users) |> on_conflict(users_email_key, do_update((s) -> { ... }))
+def on_conflict(m: Write(ret, c, s), u: Unique(c, uk), action: Action(s)) -> Write(ret, c, s)
+  case action
+  in DoNothingA then { m | conflict: Just(DoNothing(u.columns)) }
+
+  in DoUpdateA(build)
+  then { m | conflict: Just(DoUpdate(u.columns, build(m.set_cols))) }
+  end
+end
+
+
+def returning(m: Write(a, c, s), build: c -> Query(Selector(b))) -> Write(b, c, s)
+  Write(
+    m.kind,
+    m.table,
+    m.cols,
+    m.set_cols,
+    m.rows,
+    m.wheres,
+    build(m.cols).result,
+    m.from_,
+    m.conflict,
+  )
+end
+
+
+# A value plus `created_at` and `updated_at`, filled with the app clock at
+# execute time. A table declaring those columns NOT NULL requires them of the
+# value being written, and this is what supplies them:
+#
+#   insert(NewPatient("Ada") |> timestamped, patients)
+#   update(Patch(name) |> timestamped, patients, id)
+#
+# `update` writes only `updated_at`, since the row already has the other. The
+# struct being wrapped keeps its own `Assignable`; the stamps are appended to
+# whatever it writes.
+struct Stamped(a) = { value: a }
+
+
+def timestamped(value: a) -> Stamped(a)
+  Stamped(value)
+end
+
+
+implements Assignable(Stamped(a)) with
+  to_assigns: (s) -> {
+    to_assigns(s.value) ++ [now_assignment("created_at"), now_assignment("updated_at")]
+  },
+end
+
+
+def now_assignment(col: String) -> Assignment
+  Assignment(col, "$JADE_SQL_NOW$", [])
+end
+
+
+# Only the one `timestamped` added: it writes the clock token rather than a
+# parameter, so a `created_at` the caller wrote by hand still reaches the row.
+def without_created_at(assigns: List(Assignment)) -> List(Assignment)
+  assigns |> List.filter((a) -> { Basics.not(added_created_at?(a)) })
+end
+
+
+def added_created_at?(a: Assignment) -> Bool
+  a.col == "created_at" && a.value_sql == "$JADE_SQL_NOW$"
+end
+
+
+def without_key(pk_: Pk(c, k), assigns: List(Assignment)) -> List(Assignment)
+  assigns |> List.filter((a) -> { List.member?(pk_.columns, a.col) |> Basics.not })
+end
+
+
+# The `WHERE` that selects one row by its key: `id = ?`, or
+# `user_id = ? AND group_id = ?` for a composite key. Columns and values both
+# come from the table's `Pk`, in the order `structure.sql` declares them, so a
+# caller supplies a `k` and never a column name or an ordering.
+def key_predicate(pk_: Pk(c, k), key: k) -> Expr(Bool)
+  sql = pk_.columns
+    |> List.map((col) -> { col ++ " = ?" })
+    |> String.join(" AND ")
+
+  Expr(sql, key |> pk_.values)
+end
+
+
+def render_row(row: List(Assignment)) -> String
+  cols_part = row
+    |> List.map((a) -> { a.value_sql })
+    |> String.join(", ")
+
+  "(" ++ cols_part ++ ")"
+end
+
+
+def returning_clause(s: Selector(ret)) -> String
+  List.empty?(s.columns_sql) ? "" : " RETURNING " ++ String.join(s.columns_sql, ", ")
+end
+
+
+def insert_cols_str(rows: List(List(Assignment))) -> String
+  case rows
+  in [] then ""
+  in [first | _]
+    "(" ++ String.join(List.map(first, (a) -> { a.col }), ", ") ++ ")"
+  end
+end
+
+
+def insert_params(rows: List(List(Assignment))) -> List(Value)
+  List.fold(
+    rows,
+    [],
+    (acc, row) -> { acc ++ List.fold(row, [], (acc2, a) -> { acc2 ++ a.params }) },
+  )
+end
+
+
+def set_sqls_for(rows: List(List(Assignment))) -> List(String)
+  case rows
+  in [first | _] then List.map(first, (a) -> { a.col ++ " = " ++ a.value_sql })
+  in [] then []
+  end
+end
+
+
+def set_params_for(rows: List(List(Assignment))) -> List(Value)
+  case rows
+  in [first | _] then List.fold(first, [], (acc, a) -> { acc ++ a.params })
+  in [] then []
+  end
+end
+
+
+# The target carries the same alias the column accessors were built with, so
+# a predicate reads the same in a write as it does in a query and nothing has
+# to be rewritten after the fact. It is also what keeps `id = jade_src.id`
+# unambiguous under a FROM, since json_populate_recordset gives the source
+# every column the table has.
+def target(m: Write(ret, c, s)) -> String
+  m.table.alias_ == m.table.name
+    ? m.table.name
+    : m.table.name ++ " AS " ++ m.table.alias_
+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)
+    ? ""
+    : " WHERE " ++ String.join(List.map(wheres, (w) -> { w.sql }), " AND ")
+end
+
+
+def where_params(wheres: List(Expr(Bool))) -> List(Value)
+  List.fold(wheres, [], (acc, w) -> { acc ++ w.params })
+end
+
+
+def render_insert(m: Write(ret, c, s)) -> (String, List(Value))
+  List.empty?(m.rows) ? render_nothing : render_insert_rows(m)
+end
+
+
+def render_insert_rows(m: Write(ret, c, s)) -> (String, List(Value))
+  sql = "INSERT INTO "
+    ++ target(m)
+    ++ " "
+    ++ insert_body(m.rows)
+    ++ conflict_clause(m.conflict)
+    ++ returning_clause(m.returning_selector)
+
+  Tuple.Tuple2(
+    sql,
+    insert_params(m.rows) ++ conflict_params(m.conflict) ++ m.returning_selector.params,
+  )
+end
+
+
+def conflict_clause(c: Maybe(Conflict)) -> String
+  case c
+  in Nothing then ""
+
+  in Just(DoNothing(cols)) then
+    " ON CONFLICT (" ++ String.join(cols, ", ") ++ ") DO NOTHING"
+
+  in Just(DoUpdate(cols, assigns)) then
+    " ON CONFLICT ("
+      ++ String.join(cols, ", ")
+      ++ ") DO UPDATE SET "
+      ++ String.join(List.map(assigns, (a) -> { a.col ++ " = " ++ a.value_sql }), ", ")
+  end
+end
+
+
+def conflict_params(c: Maybe(Conflict)) -> List(Value)
+  case c
+  in Just(DoUpdate(_, assigns)) then
+    List.fold(assigns, [], (acc, a) -> { acc ++ a.params })
+
+  else []
+  end
+end
+
+
+# `DEFAULT VALUES` for the one row that names no columns: that is a row of
+# defaults, which is what was asked for, and `() VALUES ()` is not SQL. Not
+# the same as having no rows at all, which writes nothing.
+def insert_body(rows: List(List(Assignment))) -> String
+  case rows
+  in [[]] then "DEFAULT VALUES"
+
+  else insert_cols_str(rows)
+    ++ " VALUES "
+    ++ String.join(List.map(rows, render_row), ", ")
+  end
+end
+
+
+def render_update(m: Write(ret, c, s)) -> (String, List(Value))
+  sets = set_sqls_for(m.rows)
+
+  List.empty?(sets) ? render_nothing : render_update_set(m, sets)
+end
+
+
+# A write with nothing to write. A changeset whose fields all held their old
+# values, and an empty batch, are both ordinary — so this affects no rows and
+# reports so, rather than failing.
+#
+# It has to be a statement, because `to_sql` owes its caller one. `WHERE FALSE`
+# is the whole point: the previous no-op update kept the caller's predicate and
+# rendered `SELECT ... WHERE id = ?`, which `exec_update` counts as a row
+# updated. It matched, so it reported 1, took no lock, and a `returning` read
+# handed back the row as it stood before the update that never happened.
+#
+# The predicate's parameters go with it. A statement that does not bind them
+# must not carry them.
+def render_nothing -> (String, List(Value))
+  Tuple.Tuple2("SELECT 1 WHERE FALSE", [])
+end
+
+
+def render_update_set(
+  m: Write(ret, c, s),
+  sets: List(String),
+) -> (String, List(Value))
+  set_clause = "SET " ++ String.join(sets, ", ")
+  where = where_sql(m.wheres)
+  returning_ = returning_clause(m.returning_selector)
+  sql = "UPDATE "
+    ++ target(m)
+    ++ " "
+    ++ set_clause
+    ++ from_clause(m.from_)
+    ++ where
+    ++ returning_
+
+  Tuple.Tuple2(
+    sql,
+    set_params_for(m.rows)
+      ++ from_params(m.from_)
+      ++ where_params(m.wheres)
+      ++ m.returning_selector.params,
+  )
+end
+
+
+
+
+def render_delete(m: Write(ret, c, s)) -> (String, List(Value))
+  where = where_sql(m.wheres)
+  returning_ = returning_clause(m.returning_selector)
+  sql = "DELETE FROM "
+    ++ target(m)
+    ++ where
+    ++ returning_
+
+  Tuple.Tuple2(sql, where_params(m.wheres) ++ m.returning_selector.params)
+end
+
+
+def to_sql(m: Write(ret, c, s)) -> (String, List(Value))
+  case m.kind
+  in InsertK then render_insert(m)
+  in UpdateK then render_update(m)
+  in DeleteK then render_delete(m)
+  end
+end
+
+
+implements ToSql(Write(ret, c, s)) with
+  to_sql: to_sql
+end
+
+
+# The number of rows the statement affected. Any `RETURNING` clause is
+# rendered and discarded.
+def execute(m: Write(ret, c, s)) -> Task(Int, SqlError)
+  to_sql(m) |> Sql.execute_raw
+end
+
+
+# Decodes the single row a `returning` write gives back — the id of an
+# insert, the new state of an update. A write with no `returning` selects
+# nothing, so this errors with `NotFound`.
+def fetch_one(m: Write(ret, c, s)) -> Task(ret, SqlError)
+  to_sql(m) |> Sql.fetch_one_raw
+end
+
+
+# The same for a write that returns many rows, as `insert_all` and
+# `update_all` do.
+def fetch_many(m: Write(ret, c, s)) -> Task(List(ret), SqlError)
+  to_sql(m) |> Sql.fetch_many_raw
+end