jade-sql 0.7.0 → 0.9.0

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

@@ -1,464 +0,0 @@
-module Sql.Mutation exposing (
-  Mutation,
-  delete,
-  delete_all,
-  insert,
-  insert_all,
-  returning,
-  timestamped,
-  to_sql,
-  update,
-  update_all,
-  update_many,
-)
-
-import Sql exposing (
-  Assignment(..),
-  Expr(..),
-  Renderable,
-  Selector(..),
-  Table,
-  TableRef(..),
-  pk_values,
-  set_,
-  to_assigns,
-)
-import Sql.Query exposing (Q)
-import Decode exposing (Value)
-import Encode
-
-
-type MutationKind
-  = InsertK
-  | UpdateK
-  | DeleteK
-
-
-struct Mutation(ret, c) = {
-  kind: MutationKind,
-  table: TableRef,
-  cols: c,
-  rows: List(List(Assignment)),
-  wheres: List(Expr(Bool)),
-  returning_selector: Selector(ret),
-  from_: Maybe(Expr(Bool))
-}
-
-
-def insert(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  Mutation(
-    InsertK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [to_assigns(value)],
-    [],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def insert_all(values: List(a), t: Table(c, m)) -> Mutation(Int, c)
-  Mutation(
-    InsertK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    List.map(values, (v) -> { to_assigns(v) }),
-    [],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def update(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  pk_pred = pk_predicate(t.pk_columns, pk_values(value))
-
-  Mutation(
-    UpdateK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [to_assigns(value)],
-    [pk_pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def delete(value: a, t: Table(c, m)) -> Mutation(Int, c)
-  pk_pred = pk_predicate(t.pk_columns, pk_values(value))
-
-  Mutation(
-    DeleteK,
-    TableRef(t.name, t.alias_),
-    t.alias_ |> t.cols,
-    [],
-    [pk_pred],
-    Selector([], []),
-     Nothing,
-  )
-end
-
-
-def update_all(
-  t: Table(c, m),
-  pred_fn: c -> Expr(Bool),
-  build: c -> List(Assignment),
-) -> Mutation(Int, c)
-  cols_ = t.alias_ |> t.cols
-  pred = cols_ |> pred_fn
-
-  Mutation(
-    UpdateK,
-    TableRef(t.name, t.alias_),
-    cols_,
-    [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
-
-
-def delete_all(t: Table(c, m), pred_fn: c -> Expr(Bool)) -> Mutation(Int, c)
-  cols_ = t.alias_ |> t.cols
-  pred = cols_ |> pred_fn
-
-  Mutation(
-    DeleteK,
-    TableRef(t.name, t.alias_),
-    cols_,
-    [],
-    [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,
-    m.from_,
-  )
-end
-
-
-# Opt-in ActiveRecord-style timestamps: fills created_at + updated_at on
-# insert and updated_at on update, with the app clock at execute time.
-# The "$JADE_SQL_NOW$" token carries no param; the runtime swaps it for a
-# single UTC timestamp literal per statement (so created_at == updated_at).
-# A plain `insert`/`update` without this stays timestamp-free.
-def timestamped(m: Mutation(ret, c)) -> Mutation(ret, c)
-  case m.kind
-  in InsertK then with_rows(m, List.map(m.rows, append_insert_stamps))
-  in UpdateK then with_rows(m, List.map(m.rows, append_update_stamps))
-  in DeleteK then m
-  end
-end
-
-
-def append_insert_stamps(row: List(Assignment)) -> List(Assignment)
-  row ++ [now_assignment("created_at"), now_assignment("updated_at")]
-end
-
-
-def append_update_stamps(row: List(Assignment)) -> List(Assignment)
-  row ++ [now_assignment("updated_at")]
-end
-
-
-def now_assignment(col: String) -> Assignment
-  Assignment(col, "$JADE_SQL_NOW$", [])
-end
-
-
-def with_rows(m: Mutation(ret, c), rows: List(List(Assignment))) -> Mutation(ret, c)
-  { m | rows: rows }
-end
-
-
-def pk_predicate(cols: List(String), values: List(Value)) -> Expr(Bool)
-  sql = cols
-    |> List.map((col) -> { col ++ " = ?" })
-    |> String.join(" AND ")
-
-  Expr(sql, 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
-
-
-# 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)
-    ? ""
-    : " 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 strip_table_alias(sql: String, alias_: String) -> String
-  String.replace(sql, alias_ ++ ".", "")
-end
-
-
-def render_insert(m: Mutation(ret, c)) -> (String, List(Value))
-  cols_str = insert_cols_str(m.rows)
-  values_str = m.rows
-    |> List.map(render_row)
-    |> String.join(", ")
-  returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
-  sql = "INSERT INTO "
-    ++ m.table.name
-    ++ " "
-    ++ cols_str
-    ++ " VALUES "
-    ++ values_str
-    ++ returning_
-
-  Tuple.Tuple2(sql, insert_params(m.rows) ++ m.returning_selector.params)
-end
-
-
-def render_update(m: Mutation(ret, c)) -> (String, List(Value))
-  sets = set_sqls_for(m.rows)
-
-  List.empty?(sets) ? render_no_op_update(m) : render_update_set(m, sets)
-end
-
-
-def render_no_op_update(m: Mutation(ret, c)) -> (String, List(Value))
-  where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
-  cols = List.empty?(m.returning_selector.columns_sql)
-    ? "1"
-    : strip_table_alias(
-        String.join(m.returning_selector.columns_sql, ", "),
-        m.table.alias_,
-      )
-  sql = "SELECT " ++ cols ++ " FROM " ++ m.table.name ++ where
-
-  Tuple.Tuple2(sql, m.returning_selector.params ++ where_params(m.wheres))
-end
-
-
-def render_update_set(
-  m: Mutation(ret, c),
-  sets: List(String),
-) -> (String, List(Value))
-  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 "
-    ++ target_ref(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: Mutation(ret, c)) -> (String, List(Value))
-  where = strip_table_alias(where_sql(m.wheres), m.table.alias_)
-  returning_ = strip_table_alias(returning_clause(m.returning_selector), m.table.alias_)
-  sql = "DELETE FROM "
-    ++ m.table.name
-    ++ where
-    ++ returning_
-
-  Tuple.Tuple2(sql, where_params(m.wheres) ++ m.returning_selector.params)
-end
-
-
-def to_sql(m: Mutation(ret, c)) -> (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 Renderable(Mutation(ret, c)) with
-  render: to_sql
-end