Merge pull request #1118 from noaccOS/refactor/centralize-insert-sql

refactor(appengine): centralize insert to sql definition

Author: davidebriani

apps/astarte_appengine_api/lib/astarte_appengine_api/device/queries.ex

@@ -575,16 +575,14 @@ defmodule Astarte.AppEngine.API.Device.Queries do
 
   def insert_alias(realm_name, device_id, alias_tag, alias_value) do
     keyspace = keyspace_name(realm_name)
-    names_table = Name.__schema__(:source)
 
-    insert_alias_to_names_statement = """
-    INSERT INTO #{keyspace}.#{names_table}
-    (object_name, object_type, object_uuid)
-    VALUES (?, 1, ?)
-    """
+    name = %Name{
+      object_name: alias_value,
+      object_type: 1,
+      object_uuid: device_id
+    }
 
-    insert_alias_to_names_params = [alias_value, device_id]
-    insert_alias_to_names_query = {insert_alias_to_names_statement, insert_alias_to_names_params}
+    insert_alias_to_names_query = Repo.insert_to_sql(name, prefix: keyspace)
 
     new_alias = %{alias_tag => alias_value}
 

apps/astarte_appengine_api/lib/astarte_appengine_api/kv_store.ex

@@ -54,12 +54,6 @@ defmodule Astarte.AppEngine.API.KvStore do
           Keyword.t()
         ) :: :ok | {:error, Exception.t()}
   def insert(kv_store_map, opts \\ []) do
-    %{
-      group: group,
-      key: key,
-      value: value
-    } = kv_store_map
-
     value_type = Map.get(kv_store_map, :value_type, :binary)
 
     value_expr =
@@ -70,15 +64,13 @@ defmodule Astarte.AppEngine.API.KvStore do
         :string -> "varcharAsBlob(?)"
       end
 
-    {keyspace, opts} = Keyword.pop!(opts, :prefix)
-
-    sql =
-      """
-        INSERT INTO #{keyspace}.#{@source} (group, key, value)
-        VALUES (?, ?, #{value_expr})
-      """
+    kv_store = %__MODULE__{
+      group: kv_store_map.group,
+      key: kv_store_map.key,
+      value: {:custom, value_expr, kv_store_map.value}
+    }
 
-    params = [group, key, value]
+    {sql, params} = Repo.insert_to_sql(kv_store, opts)
 
     with {:ok, _} <- Repo.query(sql, params, opts) do
       :ok

apps/astarte_appengine_api/lib/astarte_appengine_api/repo.ex

@@ -35,6 +35,42 @@ defmodule Astarte.AppEngine.API.Repo do
     {:ok, config}
   end
 
+  def insert_to_sql(struct, opts) when is_struct(struct) do
+    table = struct.__meta__.source
+    insert_to_sql(table, struct, opts)
+  end
+
+  def insert_to_sql(table, value, opts) do
+    {exandra_opts, opts} = Keyword.split(opts, [:ttl, :overwrite, :timestamp])
+    {prefix, _opts} = Keyword.pop(opts, :prefix)
+
+    {keys, values} =
+      value
+      |> Map.drop([:__struct__, :__meta__])
+      |> Enum.unzip()
+
+    keys = Enum.join(keys, ", ")
+
+    {values, params} =
+      values
+      |> Enum.map(fn
+        {:custom, string, values} when is_list(values) -> {string, values}
+        {:custom, string, value} -> {string, [value]}
+        value -> {"?", [value]}
+      end)
+      |> Enum.unzip()
+
+    values = Enum.join(values, ", ")
+
+    # We need to get rid of one level of wrapping
+    params = Enum.flat_map(params, & &1)
+
+    sql =
+      "INSERT INTO #{quote_table(prefix, table)} (#{keys}) VALUES (#{values}) #{insert_suffix(exandra_opts)}"
+
+    {sql, params}
+  end
+
   def fetch(queryable, id, opts \\ []) do
     queryable
     |> query_for_get(id)
@@ -87,4 +123,36 @@ defmodule Astarte.AppEngine.API.Repo do
       query: query,
       message: "expected a from expression with a schema"
   end
+
+  # source: exandra lib/exandra/connection.ex
+  defp quote_table(nil, name), do: quote_table(name)
+  defp quote_table(prefix, name), do: [quote_table(prefix), ?., quote_table(name)]
+  defp quote_table(name) when is_atom(name), do: quote_table(Atom.to_string(name))
+  defp quote_table(name), do: [name]
+
+  # source: exandra lib/exandra/connection.ex
+  defp insert_suffix(opts) do
+    suffix =
+      case Keyword.get(opts, :overwrite, true) do
+        true ->
+          []
+
+        _ ->
+          [" IF NOT EXISTS"]
+      end
+
+    suffix =
+      case Keyword.get(opts, :ttl, nil) do
+        nil -> suffix
+        seconds when is_number(seconds) -> suffix ++ [" USING TTL #{seconds}"]
+      end
+
+    case Keyword.get(opts, :timestamp, nil) do
+      nil ->
+        suffix
+
+      epoch_in_microseconds when is_number(epoch_in_microseconds) ->
+        suffix ++ [" AND TIMESTAMP #{epoch_in_microseconds}"]
+    end
+  end
 end