Add support for custom selection fields

Author: renatomassaro

lib/feeb/db.ex

@@ -96,10 +96,11 @@ defmodule Feeb.DB do
 
   def one(partial_or_full_query_id, bindings \\ [], opts \\ [])
 
-  # TODO: See Feeb.DB, I also support `custom_fields`
   def one({domain, :fetch}, bindings, opts) when is_list(bindings) do
+    target_fields = opts[:select] || [:*]
+
     {get_context!(), domain, :__fetch}
-    |> Query.get_templated_query_id([], %{})
+    |> Query.get_templated_query_id(target_fields, %{})
     |> one(bindings, opts)
   end
 
@@ -127,8 +128,10 @@ defmodule Feeb.DB do
   def all(partial_or_full_query_id, bindings \\ [], opts \\ [])
 
   def all(schema, _bindings, opts) when is_atom(schema) do
+    target_fields = opts[:select] || [:*]
+
     {get_context!(), schema.__table__(), :__all}
-    |> Query.get_templated_query_id(:all, %{})
+    |> Query.get_templated_query_id(target_fields, %{})
     |> all([], opts)
   end
 
@@ -147,7 +150,7 @@ defmodule Feeb.DB do
 
   def insert(%schema{} = struct, opts \\ []) do
     {get_context!(), schema.__table__(), :__insert}
-    |> Query.get_templated_query_id(:all, %{schema: schema})
+    |> Query.get_templated_query_id([:*], %{schema: schema})
     |> insert_sql(struct, opts)
   end
 

lib/feeb/db/query.ex

@@ -58,11 +58,26 @@ defmodule Feeb.DB.Query do
 
   def get_templated_query_id(query_id, target_fields, meta \\ %{})
 
+  def get_templated_query_id({context, domain, query_name} = query_id, target_fields, _meta)
+      when query_name in [:__all, :__fetch] do
+    model = Schema.get_model_from_query_id(query_id)
+
+    real_query_id = {context, domain, :"#{query_name}$#{get_query_name_suffix(target_fields)}"}
+
+    case get(real_query_id) do
+      {_, _, _} = _compiled_query ->
+        real_query_id
+
+      nil ->
+        compile_templated_query(query_name, query_id, target_fields, model)
+    end
+  end
+
   def get_templated_query_id({context, domain, :__insert} = query_id, target_fields, _meta) do
     model = Schema.get_model_from_query_id(query_id)
 
     target_fields =
-      if target_fields == :all do
+      if target_fields == [:*] do
         model.__cols__()
       else
         raise "Not supported for now, add & test it once needed"
@@ -106,16 +121,15 @@ defmodule Feeb.DB.Query do
     end
   end
 
-  def get_templated_query_id({_context, _domain, query_name} = query_id, target_fields, _meta)
-      when query_name in [:__all, :__fetch, :__delete] do
+  def get_templated_query_id({_context, _domain, :__delete} = query_id, target_fields, _meta) do
     model = Schema.get_model_from_query_id(query_id)
 
     case get(query_id) do
       {_, _, _} = _compiled_query ->
         query_id
 
       nil ->
-        compile_templated_query(query_name, query_id, target_fields, model)
+        compile_templated_query(:__delete, query_id, target_fields, model)
     end
   end
 
@@ -139,34 +153,32 @@ defmodule Feeb.DB.Query do
     primary_keys = model.__primary_keys__()
     assert_adhoc_query!(primary_keys, query_id, model)
 
-    set_conditions =
-      target_fields
-      |> Enum.reduce([], fn field, acc ->
-        ["#{field} = ?" | acc]
-      end)
-      |> Enum.reverse()
-      |> Enum.join(", ")
+    set_clause = generate_update_set_clause(target_fields)
+    where_clause = generate_where_clause(primary_keys)
+    sql = "UPDATE #{domain} #{set_clause} #{where_clause};"
 
-    sql = "UPDATE #{domain} SET #{set_conditions} #{generate_where_clause(primary_keys)};"
     adhoc_query = {sql, {[], target_fields ++ primary_keys}, :update}
     append_runtime_query(query_id, adhoc_query)
 
     query_id
   end
 
-  defp compile_templated_query(:__all, {_, domain, _} = query_id, _target_fields, _model) do
-    sql = "SELECT * FROM #{domain};"
-    adhoc_query = {sql, {[:*], []}, :select}
+  defp compile_templated_query(:__all, {_, domain, _} = query_id, target_fields, _model) do
+    sql = "#{generate_select_clause(target_fields)} FROM #{domain};"
+    adhoc_query = {sql, {target_fields, []}, :select}
     append_runtime_query(query_id, adhoc_query)
     query_id
   end
 
-  defp compile_templated_query(:__fetch, {_, domain, _} = query_id, _target_fields, model) do
+  defp compile_templated_query(:__fetch, {_, domain, _} = query_id, target_fields, model) do
     primary_keys = model.__primary_keys__()
     assert_adhoc_query!(primary_keys, query_id, model)
-    sql = "SELECT * FROM #{domain} #{generate_where_clause(primary_keys)};"
 
-    adhoc_query = {sql, {[:*], primary_keys}, :select}
+    select_clause = generate_select_clause(target_fields)
+    where_clause = generate_where_clause(primary_keys)
+    sql = "#{select_clause} FROM #{domain} #{where_clause};"
+
+    adhoc_query = {sql, {target_fields, primary_keys}, :select}
     append_runtime_query(query_id, adhoc_query)
     query_id
   end
@@ -232,6 +244,16 @@ defmodule Feeb.DB.Query do
     end
   end
 
+  defp get_query_name_suffix(target_fields) when is_list(target_fields) do
+    target_fields
+    |> Enum.sort()
+    |> Enum.reduce([], fn field, acc ->
+      ["#{field}" | acc]
+    end)
+    |> Enum.reverse()
+    |> Enum.join("$")
+  end
+
   defp maybe_inject_returning_clause(nil, _), do: nil
   defp maybe_inject_returning_clause(query, []), do: query
 
@@ -253,6 +275,32 @@ defmodule Feeb.DB.Query do
   defp get_returning_fields({_, _, operation}) when operation in [:update, :delete],
     do: "*"
 
+  defp generate_select_clause([]), do: "SELECT *"
+
+  defp generate_select_clause(fields) when is_list(fields) do
+    select_conditions =
+      fields
+      |> Enum.reduce([], fn field, acc ->
+        ["#{field}" | acc]
+      end)
+      |> Enum.reverse()
+      |> Enum.join(", ")
+
+    "SELECT #{select_conditions}"
+  end
+
+  defp generate_update_set_clause(fields) when is_list(fields) do
+    set_conditions =
+      fields
+      |> Enum.reduce([], fn field, acc ->
+        ["#{field} = ?" | acc]
+      end)
+      |> Enum.reverse()
+      |> Enum.join(", ")
+
+    "SET #{set_conditions}"
+  end
+
   defp generate_where_clause(primary_keys) when is_list(primary_keys) do
     where_conditions =
       primary_keys

lib/feeb/db/schema.ex

@@ -126,7 +126,8 @@ defmodule Feeb.DB.Schema do
     assert_env.(:schema)
   end
 
-  defmacro cast(args, target_fields \\ unquote(:all)) do
+  # TODO: Why is this a macro?
+  defmacro cast(args, target_fields \\ unquote([:*])) do
     quote do
       meta = %{
         valid?: true,

test/db/db_test.exs

@@ -2,6 +2,7 @@ defmodule Feeb.DBTest do
   use Test.Feeb.DBCase, async: true
   alias Feeb.DB, as: DB
   alias Feeb.DB.LocalState
+  alias Feeb.DB.Value.NotLoaded
   alias Sample.{AllTypes, CustomTypes, Friend, OrderItems, Post}
   alias Sample.Types.TypedID
 
@@ -398,22 +399,29 @@ defmodule Feeb.DBTest do
     end
   end
 
-  describe "one/1" do
+  describe "one/3" do
     test "returns the expected result", %{shard_id: shard_id} do
       DB.begin(@context, shard_id, :read)
       assert %{id: 1, name: "Phoebe"} = DB.one({:friends, :get_by_id}, [1])
       assert [_] = DB.one({:pragma, :user_version})
       assert nil == DB.one({:friends, :get_by_id}, [0])
     end
 
-    test ":fetch templated query works", %{shard_id: shard_id} do
+    test ":__fetch templated query works", %{shard_id: shard_id} do
       DB.begin(@context, shard_id, :write)
 
       assert %{id: 1, name: "Phoebe"} = DB.one({:friends, :fetch}, [1])
       assert nil == DB.one({:friends, :fetch}, [500])
     end
 
-    test ":fetch templated query works on schema with composite PKs", %{shard_id: shard_id} do
+    test ":__fetch templated query with custom selection", %{shard_id: shard_id} do
+      DB.begin(@context, shard_id, :write)
+
+      assert %{id: %NotLoaded{}, name: "Phoebe"} = DB.one({:friends, :fetch}, [1], select: [:name])
+      assert nil == DB.one({:friends, :fetch}, [500], select: [:name])
+    end
+
+    test ":__fetch templated query works on schema with composite PKs", %{shard_id: shard_id} do
       DB.begin(@context, shard_id, :write)
 
       %{order_id: 1, product_id: 2, quantity: 10, price: 50}
@@ -505,6 +513,29 @@ defmodule Feeb.DBTest do
   end
 
   describe "all/3" do
+    test ":__all templated query works", %{shard_id: shard_id} do
+      DB.begin(@context, shard_id, :write)
+
+      # There are 6 friends
+      assert [_, _, _, _, _, _] = DB.all(Friend)
+
+      %{id: 1, title: "My Post", body: "My Body"}
+      |> Post.new()
+      |> DB.insert!()
+
+      assert [%{id: 1, title: "My Post", body: "My Body"}] = DB.all(Post)
+    end
+
+    test ":__all templated query works with custom selection", %{shard_id: shard_id} do
+      DB.begin(@context, shard_id, :write)
+
+      %{id: 1, title: "Post", body: "My Body"}
+      |> Post.new()
+      |> DB.insert!()
+
+      assert [%{id: 1, title: "Post", body: %NotLoaded{}}] = DB.all(Post, [], select: [:id, :title])
+    end
+
     test "supports the :format flag", %{shard_id: shard_id} do
       DB.begin(@context, shard_id, :write)
 

test/db/query_test.exs

@@ -54,7 +54,7 @@ defmodule Feeb.DB.QueryTest do
 
       # Ensures the :__fetch is compiled (due to it being an "ad-hoc" query)
       query_id = {:test, :friends, :__all}
-      Query.get_templated_query_id(query_id, [])
+      Query.get_templated_query_id(query_id, [:*])
 
       assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
       assert query_type == :select
@@ -63,11 +63,23 @@ defmodule Feeb.DB.QueryTest do
       assert sql == "SELECT * FROM friends;"
     end
 
+    test ":__all - with custom target fields" do
+      Query.compile(@friends_path, {:test, :friends})
+
+      query_id = Query.get_templated_query_id({:test, :friends, :__all}, [:name])
+
+      assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
+      assert query_type == :select
+      assert target_fields == [:name]
+      assert bindings == []
+      assert sql == "SELECT name FROM friends;"
+    end
+
     test ":__fetch" do
       Query.compile(@friends_path, {:test, :friends})
 
       query_id = {:test, :friends, :__fetch}
-      Query.get_templated_query_id(query_id, [])
+      Query.get_templated_query_id(query_id, [:*])
 
       assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
       assert query_type == :select
@@ -80,7 +92,7 @@ defmodule Feeb.DB.QueryTest do
       Query.compile(@order_items_path, {:test, :order_items})
 
       query_id = {:test, :order_items, :__fetch}
-      Query.get_templated_query_id(query_id, [])
+      Query.get_templated_query_id(query_id, [:*])
 
       assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
       assert query_type == :select
@@ -89,14 +101,26 @@ defmodule Feeb.DB.QueryTest do
       assert sql == "SELECT * FROM order_items WHERE order_id = ? AND product_id = ?;"
     end
 
+    test ":__fetch - with custom target fields" do
+      Query.compile(@order_items_path, {:test, :order_items})
+
+      query_id = Query.get_templated_query_id({:test, :order_items, :__fetch}, [:quantity, :price])
+
+      assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
+      assert sql == "SELECT quantity, price FROM order_items WHERE order_id = ? AND product_id = ?;"
+      assert target_fields == [:quantity, :price]
+      assert bindings == [:order_id, :product_id]
+      assert query_type == :select
+    end
+
     test ":__fetch - raises when schema has no PK" do
       Query.compile(@all_types_path, {:test, :all_types})
 
       query_id = {:test, :all_types, :__fetch}
 
       %{message: error} =
         assert_raise RuntimeError, fn ->
-          Query.get_templated_query_id(query_id, [])
+          Query.get_templated_query_id(query_id, [:*])
         end
 
       assert error =~ "Can't generate adhoc query"
@@ -108,7 +132,7 @@ defmodule Feeb.DB.QueryTest do
       Query.compile(@friends_path, {:test, :friends})
 
       query_id = {:test, :friends, :__insert}
-      Query.get_templated_query_id(query_id, :all)
+      Query.get_templated_query_id(query_id, [:*])
 
       assert {sql, {target_fields, bindings}, query_type} = Query.fetch!(query_id)
       assert query_type == :insert