Refactor generated handling in column_type

Author: josevalim

lib/ecto/adapters/postgres/connection.ex

@@ -90,9 +90,7 @@ if Code.ensure_loaded?(Postgrex) do
       do: []
 
     defp strip_quotes(quoted) do
-      size = byte_size(quoted) - 2
-      <<_, unquoted::binary-size(size), _>> = quoted
-      unquoted
+      binary_part(quoted, 1, byte_size(quoted) - 2)
     end
 
     ## Query
@@ -1760,104 +1758,85 @@ if Code.ensure_loaded?(Postgrex) do
     defp options_expr(options),
       do: [?\s, options]
 
-    defp column_type({:array, type}, opts) do
-      [type, opts] = column_type(type, opts)
-      [[type, "[]"], opts]
-    end
+    defp column_type(type, opts) do
+      type_name = column_type_name(type, opts)
 
-    defp column_type(type, opts) when type in ~w(time utc_datetime naive_datetime)a do
-      generated = Keyword.get(opts, :generated)
-      [[ecto_to_db(type), "(0)"], generated_expr(generated)]
-    end
+      case Keyword.get(opts, :generated) do
+        nil when type == :identity ->
+          cleanup = fn v -> is_integer(v) and v > 0 end
 
-    defp column_type(type, opts)
-         when type in ~w(time_usec utc_datetime_usec naive_datetime_usec)a do
-      precision = Keyword.get(opts, :precision)
-      generated = Keyword.get(opts, :generated)
-      type_name = ecto_to_db(type)
+          sequence =
+            [Keyword.get(opts, :start_value)]
+            |> Enum.filter(cleanup)
+            |> Enum.map(&"START WITH #{&1}")
+            |> Kernel.++(
+              [Keyword.get(opts, :increment)]
+              |> Enum.filter(cleanup)
+              |> Enum.map(&"INCREMENT BY #{&1}")
+            )
+
+          case sequence do
+            [] -> [type_name, " GENERATED BY DEFAULT AS IDENTITY"]
+            _ -> [type_name, " GENERATED BY DEFAULT AS IDENTITY(", Enum.join(sequence, " "), ") "]
+          end
 
-      type =
-        if precision do
-          [type_name, ?(, to_string(precision), ?)]
-        else
+        nil ->
           type_name
-        end
 
-      [type, generated_expr(generated)]
+        expr when is_binary(expr) ->
+          [type_name, " GENERATED ", expr]
+
+        other ->
+          raise ArgumentError,
+                "the `:generated` option only accepts strings, received: #{inspect(other)}"
+      end
     end
 
-    defp column_type(:identity, opts) do
-      start_value = [Keyword.get(opts, :start_value)]
-      increment = [Keyword.get(opts, :increment)]
-      generated = Keyword.get(opts, :generated)
-      type_name = ecto_to_db(:identity)
+    defp column_type_name({:array, type}, opts) do
+      [column_type_name(type, opts), "[]"]
+    end
 
-      if generated do
-        [type_name, generated_expr(generated)]
-      else
-        cleanup = fn v -> is_integer(v) and v > 0 end
-
-        sequence =
-          start_value
-          |> Enum.filter(cleanup)
-          |> Enum.map(&"START WITH #{&1}")
-          |> Kernel.++(
-            increment
-            |> Enum.filter(cleanup)
-            |> Enum.map(&"INCREMENT BY #{&1}")
-          )
+    defp column_type_name(type, _opts) when type in ~w(time utc_datetime naive_datetime)a do
+      [ecto_to_db(type), "(0)"]
+    end
 
-        case sequence do
-          [] -> [type_name, " GENERATED BY DEFAULT AS IDENTITY"]
-          _ -> [type_name, " GENERATED BY DEFAULT AS IDENTITY(", Enum.join(sequence, " "), ") "]
-        end
+    defp column_type_name(type, opts)
+         when type in ~w(time_usec utc_datetime_usec naive_datetime_usec)a do
+      precision = Keyword.get(opts, :precision)
+      type_name = ecto_to_db(type)
+
+      if precision do
+        [type_name, ?(, to_string(precision), ?)]
+      else
+        type_name
       end
     end
 
-    defp column_type(:duration, opts) do
+    defp column_type_name(:duration, opts) do
       precision = Keyword.get(opts, :precision)
       fields = Keyword.get(opts, :fields)
-      generated = Keyword.get(opts, :generated)
       type_name = ecto_to_db(:duration)
 
-      type =
-        cond do
-          fields && precision -> [type_name, " ", fields, ?(, to_string(precision), ?)]
-          precision -> [type_name, ?(, to_string(precision), ?)]
-          fields -> [type_name, " ", fields]
-          true -> [type_name]
-        end
-
-      [type, generated_expr(generated)]
+      cond do
+        fields && precision -> [type_name, " ", fields, ?(, to_string(precision), ?)]
+        precision -> [type_name, ?(, to_string(precision), ?)]
+        fields -> [type_name, " ", fields]
+        true -> [type_name]
+      end
     end
 
-    defp column_type(type, opts) do
+    defp column_type_name(type, opts) do
       size = Keyword.get(opts, :size)
       precision = Keyword.get(opts, :precision)
       scale = Keyword.get(opts, :scale)
-      generated = Keyword.get(opts, :generated)
       type_name = ecto_to_db(type)
 
-      type =
-        cond do
-          size -> [type_name, ?(, to_string(size), ?)]
-          precision -> [type_name, ?(, to_string(precision), ?,, to_string(scale || 0), ?)]
-          type == :string -> [type_name, "(255)"]
-          true -> type_name
-        end
-
-      [type, generated_expr(generated)]
-    end
-
-    defp generated_expr(nil), do: []
-
-    defp generated_expr(expr) when is_binary(expr) do
-      [" GENERATED ", expr]
-    end
-
-    defp generated_expr(other) do
-      raise ArgumentError,
-            "the `:generated` option only accepts strings, received: #{inspect(other)}"
+      cond do
+        size -> [type_name, ?(, to_string(size), ?)]
+        precision -> [type_name, ?(, to_string(precision), ?,, to_string(scale || 0), ?)]
+        type == :string -> [type_name, "(255)"]
+        true -> type_name
+      end
     end
 
     defp reference_expr(%Reference{} = ref, table, name) do