jade-sql 0.7.0 → 0.9.0

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

@@ -1,9 +1,14 @@
 module Sql.Query exposing (
-  Q,
+  Query,
+  Select,
   field,
   field_as,
+  distinct,
+  exists,
   from,
   group,
+  in_subquery,
+  having,
   join,
   left_join,
   limit,
@@ -11,11 +16,27 @@ module Sql.Query exposing (
   order,
   order_desc,
   select,
+  fetch_at_most_one,
+  fetch_count,
+  fetch_exists,
+  fetch_many,
+  fetch_one,
+  fetch_values,
   to_sql,
+  subquery,
   where,
+  filter,
 )
 
-import Sql exposing (Expr, Renderable, Selector(..), Table, TableRef(..))
+import Sql exposing (
+  Expr(..),
+  Selector(..),
+  SqlError(..),
+  Table,
+  TableRef(..),
+  ToSql,
+  from_sql_error,
+)
 import Decode exposing (Value)
 
 
@@ -50,39 +71,71 @@ struct GroupTerm = {
 }
 
 
-struct Q(a) = {
+
+# A finished query: one you have projected columns into with `select` and
+# `field`, and can hand to `fetch_one` / `fetch_many`. A bare `Query(c)` is a
+# query mid-chain, still carrying a table's column accessors.
+#
+#   def scheduled_visits -> Select(Visit)
+type alias Select(a) = Query(Selector(a))
+
+
+struct Query(a) = {
   tables: List(TableRef),
   joins: List(Join),
   wheres: List(Expr(Bool)),
   groups: List(GroupTerm),
+  havings: List(Expr(Bool)),
   orders: List(OrderTerm),
   limit_: Maybe(Int),
   offset_: Maybe(Int),
-  result: a
+  distinct_: Bool,
+  result: a,
+  result_alias: Maybe(String)
 }
 
 
-implements Chainable(Q(a)) with
+implements Chainable(Query(a)) with
   and_then: q_and_then
 end
 
 
-def q_and_then(q: Q(a), fn: a -> Q(b)) -> Q(b)
+def q_and_then(q: Query(a), fn: a -> Query(b)) -> Query(b)
   next_ = q.result |> fn
 
-  Q(
-    q.tables ++ next_.tables,
+  Query(
+    merge_tables(q.tables, next_.tables),
     q.joins ++ next_.joins,
     q.wheres ++ next_.wheres,
     q.groups ++ next_.groups,
+    q.havings ++ next_.havings,
     q.orders ++ next_.orders,
     merge_paging(q.limit_, next_.limit_),
     merge_paging(q.offset_, next_.offset_),
+    q.distinct_ || next_.distinct_,
     next_.result,
+    next_.result_alias,
   )
 end
 
 
+# One entry per name-and-alias. Two `from`s of different tables still cross
+# join, and the same table under two aliases is still two tables; only the
+# exact repeat collapses, and that repeat was a duplicate-alias error before.
+def merge_tables(prev: List(TableRef), next_: List(TableRef)) -> List(TableRef)
+  List.fold(
+    next_,
+    prev,
+    (seen, t) -> { List.any?(seen, (s) -> { same_table?(s, t) }) ? seen : seen ++ [t] },
+  )
+end
+
+
+def same_table?(a: TableRef, b: TableRef) -> Bool
+  a.name == b.name && a.alias_ == b.alias_
+end
+
+
 def merge_paging(prev: Maybe(Int), next_: Maybe(Int)) -> Maybe(Int)
   case next_
   in Just(_) then next_
@@ -91,164 +144,156 @@ def merge_paging(prev: Maybe(Int), next_: Maybe(Int)) -> Maybe(Int)
 end
 
 
-def from(t: Table(c, m)) -> Q(c)
+def from(t: Table(c, m, k, o, r, s)) -> Query(c)
   cols_ = t.alias_ |> t.cols
 
-  Q([TableRef(t.name, t.alias_)], [], [], [], [], Nothing, Nothing, cols_)
+  Query(
+    [TableRef(t.name, t.alias_)],
+    [],
+    [],
+    [],
+    [],
+    [],
+    Nothing,
+    Nothing,
+    False,
+    cols_,
+    Just(t.alias_),
+  )
 end
 
 
-def join(t: Table(c, m), on_: c -> Expr(Bool)) -> Q(c)
+def join(t: Table(c, m, k, o, r, s), on_: c -> Expr(Bool)) -> Query(c)
   cols_ = t.alias_ |> t.cols
   pred = cols_ |> on_
 
-  Q(
+  Query(
     [],
     [Join(InnerJ, t.name, t.alias_, pred)],
     [],
     [],
     [],
+    [],
     Nothing,
     Nothing,
+    False,
     cols_,
+    Just(t.alias_),
   )
 end
 
 
-def left_join(t: Table(c, m), on_: c -> Expr(Bool)) -> Q(m)
+def left_join(t: Table(c, m, k, o, r, s), on_: c -> Expr(Bool)) -> Query(m)
   cols_strict = t.alias_ |> t.cols
-  cols_maybe = t.alias_ |> t.maybe_cols
+  cols_maybe = t.alias_ |> t.left_cols
   pred = cols_strict |> on_
 
-  Q(
+  Query(
     [],
     [Join(LeftJ, t.name, t.alias_, pred)],
     [],
     [],
     [],
+    [],
     Nothing,
     Nothing,
+    False,
     cols_maybe,
+    Just(t.alias_),
   )
 end
 
 
-def where(q: Q(a), predicate: Expr(Bool)) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres ++ [predicate],
-    q.groups,
-    q.orders,
-    q.limit_,
-    q.offset_,
-    q.result,
-  )
+def where(q: Query(a), predicate: Expr(Bool)) -> Query(a)
+  { q | wheres: q.wheres ++ [predicate] }
 end
 
 
-def group(q: Q(a), e: Expr(b)) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres,
-    q.groups ++ [GroupTerm(e.sql, e.params)],
-    q.orders,
-    q.limit_,
-    q.offset_,
-    q.result,
-  )
+def filter(q: Query(a), build: a -> Expr(Bool)) -> Query(a)
+  where(q, build(q.result))
 end
 
 
-def order(q: Q(a), e: Expr(b)) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres,
-    q.groups,
-    q.orders ++ [OrderTerm(Asc, e.sql, e.params)],
-    q.limit_,
-    q.offset_,
-    q.result,
-  )
+def group(q: Query(a), e: Expr(b)) -> Query(a)
+  { q | groups: q.groups ++ [GroupTerm(e.sql, e.params)] }
 end
 
 
-def order_desc(q: Q(a), e: Expr(b)) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres,
-    q.groups,
-    q.orders ++ [OrderTerm(Desc, e.sql, e.params)],
-    q.limit_,
-    q.offset_,
-    q.result,
-  )
+# Filters on an aggregate, after `group` has collapsed the rows. `where`
+# cannot: it runs before the grouping, so `count_all` has nothing to count
+# yet.
+#
+#   group(p.id) |> having(count_all |> Expr.gt(val(3)))
+def having(q: Query(a), predicate: Expr(Bool)) -> Query(a)
+  { q | havings: q.havings ++ [predicate] }
 end
 
 
-def limit(q: Q(a), n: Int) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres,
-    q.groups,
-    q.orders,
-    Just(n),
-    q.offset_,
-    q.result,
-  )
+# Drops duplicate rows from the result. Applies to the whole row the query
+# projects, which is `SELECT DISTINCT` rather than Postgres' `DISTINCT ON`.
+def distinct(q: Query(a)) -> Query(a)
+  { q | distinct_: True }
 end
 
 
-def offset(q: Q(a), n: Int) -> Q(a)
-  Q(
-    q.tables,
-    q.joins,
-    q.wheres,
-    q.groups,
-    q.orders,
-    q.limit_,
-    Just(n),
-    q.result,
-  )
+def order(q: Query(a), e: Expr(b)) -> Query(a)
+  { q | orders: q.orders ++ [OrderTerm(Asc, e.sql, e.params)] }
 end
 
 
-def select(make: a -> b) -> Q(Selector(a -> b))
-  Q([], [], [], [], [], Nothing, Nothing, Selector([], []))
+def order_desc(q: Query(a), e: Expr(b)) -> Query(a)
+  { q | orders: q.orders ++ [OrderTerm(Desc, e.sql, e.params)] }
 end
 
 
-def field(qs: Q(Selector(a -> b)), e: Expr(a)) -> Q(Selector(b))
-  Q(
+def limit(q: Query(a), n: Int) -> Query(a)
+  { q | limit_: Just(n) }
+end
+
+
+def offset(q: Query(a), n: Int) -> Query(a)
+  { q | offset_: Just(n) }
+end
+
+
+def select(make: a -> b) -> Query(Selector(a -> b))
+  Query([], [], [], [], [], [], Nothing, Nothing, False, Selector([], []), Nothing)
+end
+
+
+def field(qs: Query(Selector(a -> b)), e: Expr(a)) -> Select(b)
+  Query(
     qs.tables,
     qs.joins,
     qs.wheres,
     qs.groups,
+    qs.havings,
     qs.orders,
     qs.limit_,
     qs.offset_,
+    qs.distinct_,
     Selector(qs.result.columns_sql ++ [e.sql], qs.result.params ++ e.params),
+    qs.result_alias,
   )
 end
 
 
-def field_as(qs: Q(Selector(a -> b)), e: Expr(a), name: String) -> Q(Selector(b))
-  Q(
+def field_as(qs: Query(Selector(a -> b)), e: Expr(a), name: String) -> Select(b)
+  Query(
     qs.tables,
     qs.joins,
     qs.wheres,
     qs.groups,
+    qs.havings,
     qs.orders,
     qs.limit_,
     qs.offset_,
+    qs.distinct_,
     Selector(
       qs.result.columns_sql ++ [e.sql ++ " AS " ++ name],
       qs.result.params ++ e.params,
     ),
+    qs.result_alias,
   )
 end
 
@@ -274,10 +319,17 @@ def render_order_term(t: OrderTerm) -> String
 end
 
 
+# Every table the query was built from, which is a cross join when there is
+# more than one. Rendering only the first would leave the statement
+# disagreeing with the value: `from` twice puts two tables in `tables`, and
+# accessors for both are in scope.
 def render_from(tables: List(TableRef)) -> String
   case tables
   in [] then ""
-  in [first | _] then " FROM " ++ first.name ++ " " ++ first.alias_
+
+  in _
+  then " FROM "
+    ++ String.join(List.map(tables, (t) -> { t.name ++ " " ++ t.alias_ }), ", ")
   end
 end
 
@@ -290,13 +342,66 @@ def render_int_clause(keyword: String, m: Maybe(Int)) -> String
 end
 
 
-implements Renderable(Q(Selector(a))) with
-  render: to_sql
+implements ToSql(Query(Selector(a))) with
+  to_sql: to_sql
+end
+
+
+def to_sql(q: Select(a)) -> (String, List(Value))
+  render(q, q.result.columns_sql, q.result.params)
+end
+
+
+# `EXISTS (SELECT 1 FROM …)`, for asking whether a related row is there
+# without joining to it and without projecting anything from it. The inner
+# query may name the outer query's columns, which is what makes it correlated:
+#
+#   p <- from(patients)
+#   where(exists(from(visits) |> filter((v) -> { v.patient_id |> Expr.eq(p.id) })))
+def exists(q: Query(a)) -> Expr(Bool)
+  wrap_subquery("EXISTS (", q)
+end
+
+
+def wrap_subquery(keyword: String, q: Query(a)) -> Expr(Bool)
+  case render(q, ["1"], [])
+  in (sql, params) then Expr(keyword ++ sql ++ ")", params)
+  end
+end
+
+
+# A subquery in a value position: `(SELECT v.seen_on FROM ... LIMIT 1)`.
+# `Maybe`, because a subquery over no rows is NULL, same as `sum`.
+#
+# The column is picked rather than projected: `Select(a)` says nothing about
+# having exactly one, and a subquery with two is a runtime error.
+def subquery(q: Query(c), pick: c -> Expr(a)) -> Expr(Maybe(a))
+  picked = pick(q.result)
+
+  case render(q, [picked.sql], picked.params)
+  in (sql, params) then Expr("(" ++ sql ++ ")", params)
+  end
+end
+
+
+def in_subquery(e: Expr(a), q: Query(c), pick: c -> Expr(a)) -> Expr(Bool)
+  picked = pick(q.result)
+
+  case render(q, [picked.sql], picked.params)
+  in (sql, params) then Expr(e.sql ++ " IN (" ++ sql ++ ")", e.params ++ params)
+  end
 end
 
 
-def to_sql(q: Q(Selector(a))) -> (String, List(Value))
-  select_clause = "SELECT " ++ String.join(q.result.columns_sql, ", ")
+# Every clause but the select list, which the caller supplies: `to_sql` passes
+# the projected columns, a subquery passes `1`.
+def render(
+  q: Query(a),
+  columns_sql: List(String),
+  result_params: List(Value),
+) -> (String, List(Value))
+  select_clause = (q.distinct_ ? "SELECT DISTINCT " : "SELECT ")
+    ++ String.join(columns_sql, ", ")
   from_clause = render_from(q.tables)
   joins_clause = q.joins
     |> List.map((j) -> { " " ++ render_join(j) })
@@ -307,6 +412,9 @@ def to_sql(q: Q(Selector(a))) -> (String, List(Value))
   group_clause = List.empty?(q.groups)
     ? ""
     : " GROUP BY " ++ String.join(List.map(q.groups, (g) -> { g.sql }), ", ")
+  having_clause = List.empty?(q.havings)
+    ? ""
+    : " HAVING " ++ String.join(List.map(q.havings, (h) -> { h.sql }), " AND ")
   order_clause = List.empty?(q.orders)
     ? ""
     : " ORDER BY " ++ String.join(List.map(q.orders, render_order_term), ", ")
@@ -315,6 +423,7 @@ def to_sql(q: Q(Selector(a))) -> (String, List(Value))
   join_ps = List.fold(q.joins, [], (acc, j) -> { acc ++ j.on.params })
   where_ps = List.fold(q.wheres, [], (acc, w) -> { acc ++ w.params })
   group_ps = List.fold(q.groups, [], (acc, g) -> { acc ++ g.params })
+  having_ps = List.fold(q.havings, [], (acc, h) -> { acc ++ h.params })
   order_ps = List.fold(q.orders, [], (acc, o) -> { acc ++ o.params })
 
   Tuple.Tuple2(
@@ -323,9 +432,116 @@ def to_sql(q: Q(Selector(a))) -> (String, List(Value))
       ++ joins_clause
       ++ where_clause
       ++ group_clause
+      ++ having_clause
       ++ order_clause
       ++ limit_clause
       ++ offset_clause,
-    q.result.params ++ join_ps ++ where_ps ++ group_ps ++ order_ps,
+    result_params ++ join_ps ++ where_ps ++ group_ps ++ having_ps ++ order_ps,
   )
 end
+
+
+
+# Runs the query and decodes the single row it selected. Errors with
+# `NotFound` on none and `TooManyRows` on more than one, so "exactly one" is
+# checked rather than assumed.
+def fetch_one(q: Select(a)) -> Task(a, e)
+  to_sql(q) |> Sql.fetch_one_raw |> Task.map_error(from_sql_error)
+end
+
+
+# `fetch_one` where no row is an answer rather than an error. More than one
+# is still `TooManyRows`: nothing is dropped to make the type fit.
+def fetch_at_most_one(q: Select(a)) -> Task(Maybe(a), e)
+  to_sql(q)
+    |> Sql.fetch_one_raw
+    |> Task.map(Just)
+    |> Task.on_error(nothing_if_missing)
+    |> Task.map_error(from_sql_error)
+end
+
+
+# Before the widening, because whether a missing row is an error is a
+# question about `SqlError` and the caller's type may not be able to say.
+def nothing_if_missing(e: SqlError) -> Task(Maybe(a), SqlError)
+  case e
+  in NotFound then Task.succeed(Nothing)
+  else Task.fail(e)
+  end
+end
+
+
+# Runs the query and decodes every row it selected. No rows is an empty list,
+# not an error.
+def fetch_many(q: Select(a)) -> Task(List(a), e)
+  to_sql(q) |> Sql.fetch_many_raw |> Task.map_error(from_sql_error)
+end
+
+
+# A read with nothing to decode renders its own select list over the query's
+# clauses, so it needs no projection and carries no `Selectable`. The port
+# hands back a record either way, which is what these one-field shapes are
+# for.
+
+
+struct CountRow = { tally: Int }
+
+
+struct PresentRow = { present: Bool }
+
+
+struct ValueRow(a) = { value: a }
+
+
+def fetch_count(q: Query(a)) -> Task(Int, e)
+  render(q, ["COUNT(*) AS tally"], [])
+    |> Sql.fetch_one_raw
+    |> Task.map(count_of)
+    |> Task.map_error(from_sql_error)
+end
+
+
+def count_of(r: CountRow) -> Int
+  r.tally
+end
+
+
+# `SELECT EXISTS (...)`, which stops at the first row Postgres finds rather
+# than counting every one of them. `exists` is the `Expr(Bool)` for a `WHERE`,
+# where the keyword actually appears.
+def fetch_exists(q: Query(a)) -> Task(Bool, e)
+  present = exists(q)
+
+  Tuple.Tuple2("SELECT " ++ present.sql ++ " AS present", present.params)
+    |> Sql.fetch_one_raw
+    |> Task.map(present_of)
+    |> Task.map_error(from_sql_error)
+end
+
+
+def present_of(r: PresentRow) -> Bool
+  r.present
+end
+
+
+# One column out of every row, for the reads whose answer is a list of values
+# rather than a list of rows:
+#
+#   from(patients) |> where(p.archived |> eq(False)) |> fetch_values(p.id)
+#
+# Worth it only for a single column. Two would come back as a tuple, and a
+# tuple of two columns of the same type is the projection bug with no field
+# names to catch it — that is what `select |> field` is for.
+def fetch_values(q: Query(c), e: Expr(b)) -> Task(List(b), err)
+  render(q, [e.sql ++ " AS value"], e.params)
+    |> Sql.fetch_many_raw
+    |> Task.map((rows) -> { List.map(rows, value_of) })
+    |> Task.map_error(from_sql_error)
+end
+
+
+def value_of(r: ValueRow(a)) -> a
+  r.value
+end
+
+