Partitioning of resource

Author: morten.lund@maskon.no

lib/migration_generator/phase.ex

@@ -3,13 +3,26 @@ defmodule AshPostgres.MigrationGenerator.Phase do
 
   defmodule Create do
     @moduledoc false
-    defstruct [:table, :schema, :multitenancy, partitioning: nil, operations: [], commented?: false]
+    defstruct [
+      :table,
+      :schema,
+      :multitenancy,
+      partitioning: nil,
+      operations: [],
+      commented?: false
+    ]
 
     import AshPostgres.MigrationGenerator.Operation.Helper, only: [as_atom: 1]
 
-    def up(%{schema: schema, table: table, operations: operations, multitenancy: multitenancy, partitioning: partitioning}) do
+    def up(%{
+          schema: schema,
+          table: table,
+          operations: operations,
+          multitenancy: multitenancy,
+          partitioning: partitioning
+        }) do
       if multitenancy.strategy == :context do
-        arguments = arguments([prefix("prefix()"), options(partitioning: partitioning)])
+        arguments = arguments([prefix(true), options(partitioning: partitioning)])
 
         "create table(:#{as_atom(table)}, primary_key: false#{arguments}) do\n" <>
           Enum.map_join(operations, "\n", fn operation -> operation.__struct__.up(operation) end) <>
@@ -38,14 +51,15 @@ defmodule AshPostgres.MigrationGenerator.Phase do
       end
     end
 
-    def arguments(["",""]), do: ""
+    def arguments([nil, nil]), do: ""
     def arguments(arguments), do: ", " <> Enum.join(Enum.reject(arguments, &is_nil(&1)), ",")
 
-    def prefix(nil), do: nil
-    def prefix(schema), do: "prefix: #{schema}"
+    def prefix(true), do: "prefix: prefix()"
+    def prefix(schema) when is_binary(schema) and schema != "", do: "prefix: \"#{schema}\""
+    def prefix(_), do: nil
 
     def options(_options, _acc \\ [])
-    def options([], []), do: ""
+    def options([], []), do: nil
     def options([], acc), do: "options: \"#{Enum.join(acc, " ")}\""
 
     def options([{:partitioning, %{method: method, attribute: attribute}} | rest], acc) do
@@ -55,7 +69,7 @@ defmodule AshPostgres.MigrationGenerator.Phase do
       |> options(acc ++ [option])
     end
 
-    def options([_| rest], acc) do
+    def options([_ | rest], acc) do
       options(rest, acc)
     end
   end

lib/partitioning.ex

@@ -29,31 +29,33 @@ defmodule AshPostgres.Partitioning do
   """
   def exists?(resource, opts) do
     repo = AshPostgres.DataLayer.Info.repo(resource)
-    key = Keyword.fetch!(opts, :key)
-    table = AshPostgres.DataLayer.Info.table(resource)
-    partition_name = table <> "_" <> "#{key}"
+    partition_name = partition_name(resource, opts)
 
-    partition_exists?(repo, resource, partition_name)
+    partition_exists?(repo, resource, partition_name, opts)
   end
 
   # TBI
-  defp create_range_partition(repo, resource, opts) do
+  defp create_range_partition(_repo, _resource, _opts) do
   end
 
   defp create_list_partition(repo, resource, opts) do
     key = Keyword.fetch!(opts, :key)
     table = AshPostgres.DataLayer.Info.table(resource)
-    partition_name = table <> "_" <> "#{key}"
+    partition_name = partition_name(resource, opts)
+
+    schema =
+      Keyword.get(opts, :tenant)
+      |> tenant_schema(resource)
 
-    if partition_exists?(repo, resource, partition_name) do
+    if partition_exists?(repo, resource, partition_name, opts) do
       {:error, :allready_exists}
     else
       Ecto.Adapters.SQL.query(
         repo,
-        "CREATE TABLE #{partition_name} PARTITION OF public.#{table} FOR VALUES IN (#{key})"
+        "CREATE TABLE \"#{schema}\".\"#{partition_name}\" PARTITION OF \"#{schema}\".\"#{table}\" FOR VALUES IN ('#{key}')"
       )
 
-      if partition_exists?(repo, resource, partition_name) do
+      if partition_exists?(repo, resource, partition_name, opts) do
         :ok
       else
         {:error, "Unable to create partition"}
@@ -62,18 +64,37 @@ defmodule AshPostgres.Partitioning do
   end
 
   # TBI
-  defp create_hash_partition(repo, resource, opts) do
+  defp create_hash_partition(_repo, _resource, _opts) do
   end
 
-  defp partition_exists?(repo, resource, parition_name) do
+  defp partition_exists?(repo, resource, parition_name, opts) do
+    schema =
+      Keyword.get(opts, :tenant)
+      |> tenant_schema(resource)
+
     %Postgrex.Result{} =
       result =
       repo
       |> Ecto.Adapters.SQL.query!(
-        "select table_name from information_schema.tables t where t.table_schema = 'public' and t.table_name = $1",
-        [parition_name]
+        "select table_name from information_schema.tables t where t.table_schema = $1 and t.table_name = $2",
+        [schema, parition_name]
       )
 
     result.num_rows > 0
   end
+
+  defp partition_name(resource, opts) do
+    key = Keyword.fetch!(opts, :key)
+    table = AshPostgres.DataLayer.Info.table(resource)
+    "#{table}_#{key}"
+  end
+
+  defp tenant_schema(tenant, resource) do
+    tenant
+    |> Ash.ToTenant.to_tenant(resource)
+    |> case do
+      nil -> "public"
+      tenant -> tenant
+    end
+  end
 end