generate the elixir files to speed up compilation

Author: magnetised

Makefile

@@ -11,9 +11,6 @@ LDFLAGS = -lpthread -lrt
 
 all: priv/libpg_query_ex.so
 
-# libpg_query_ex:
-# 	$(MIX) compile
-
 priv:
 	mkdir -p priv
 
@@ -23,6 +20,9 @@ $(LIBPG_QUERY_PATH)/libpg_query.a:
 priv/libpg_query_ex.so: priv $(LIBPG_QUERY_PATH)/libpg_query.a c_src/libpg_query_ex.c
 	$(CC) $(CFLAGS) -shared $(LDFLAGS) -o $@ c_src/libpg_query_ex.c $(LIBPG_QUERY_PATH)/libpg_query.a
 
+protobuf:
+	MIX_ENV=prod mix protox.generate --output-path=lib/pg_query/proto --multiple-files --keep-unknown-fields=false c_src/libpg_query/protobuf/pg_query.proto
+
 clean:
 	$(MIX) clean
 	$(MAKE) -C $(LIBPG_QUERY_PATH) clean

lib/pg_query.ex

@@ -1,10 +1,4 @@
 defmodule PgQuery do
-  use Protox,
-    files: [
-      "./c_src/libpg_query/protobuf/pg_query.proto"
-    ],
-    keep_unknown_fields: false
-
   defdelegate parse!(stmt), to: PgQuery.Parser
   defdelegate parse(stmt), to: PgQuery.Parser
 end

lib/pg_query/proto/elixir_pg_query_a__array_expr.ex

@@ -0,0 +1,300 @@
+# credo:disable-for-this-file
+defmodule PgQuery.A_ArrayExpr do
+  @moduledoc false
+  defstruct elements: [], location: 0
+
+  (
+    (
+      @spec encode(struct) :: {:ok, iodata} | {:error, any}
+      def encode(msg) do
+        try do
+          {:ok, encode!(msg)}
+        rescue
+          e in [Protox.EncodingError, Protox.RequiredFieldsError] -> {:error, e}
+        end
+      end
+
+      @spec encode!(struct) :: iodata | no_return
+      def encode!(msg) do
+        [] |> encode_elements(msg) |> encode_location(msg)
+      end
+    )
+
+    []
+
+    [
+      defp encode_elements(acc, msg) do
+        try do
+          case msg.elements do
+            [] ->
+              acc
+
+            values ->
+              [
+                acc,
+                Enum.reduce(values, [], fn value, acc ->
+                  [acc, "\n", Protox.Encode.encode_message(value)]
+                end)
+              ]
+          end
+        rescue
+          ArgumentError ->
+            reraise Protox.EncodingError.new(:elements, "invalid field value"), __STACKTRACE__
+        end
+      end,
+      defp encode_location(acc, msg) do
+        try do
+          if msg.location == 0 do
+            acc
+          else
+            [acc, "\x10", Protox.Encode.encode_int32(msg.location)]
+          end
+        rescue
+          ArgumentError ->
+            reraise Protox.EncodingError.new(:location, "invalid field value"), __STACKTRACE__
+        end
+      end
+    ]
+
+    []
+  )
+
+  (
+    (
+      @spec decode(binary) :: {:ok, struct} | {:error, any}
+      def decode(bytes) do
+        try do
+          {:ok, decode!(bytes)}
+        rescue
+          e in [Protox.DecodingError, Protox.IllegalTagError, Protox.RequiredFieldsError] ->
+            {:error, e}
+        end
+      end
+
+      (
+        @spec decode!(binary) :: struct | no_return
+        def decode!(bytes) do
+          parse_key_value(bytes, struct(PgQuery.A_ArrayExpr))
+        end
+      )
+    )
+
+    (
+      @spec parse_key_value(binary, struct) :: struct
+      defp parse_key_value(<<>>, msg) do
+        msg
+      end
+
+      defp parse_key_value(bytes, msg) do
+        {field, rest} =
+          case Protox.Decode.parse_key(bytes) do
+            {0, _, _} ->
+              raise %Protox.IllegalTagError{}
+
+            {1, _, bytes} ->
+              {len, bytes} = Protox.Varint.decode(bytes)
+              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
+              {[elements: msg.elements ++ [PgQuery.Node.decode!(delimited)]], rest}
+
+            {2, _, bytes} ->
+              {value, rest} = Protox.Decode.parse_int32(bytes)
+              {[location: value], rest}
+
+            {tag, wire_type, rest} ->
+              {_, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
+              {[], rest}
+          end
+
+        msg_updated = struct(msg, field)
+        parse_key_value(rest, msg_updated)
+      end
+    )
+
+    []
+  )
+
+  (
+    @spec json_decode(iodata(), keyword()) :: {:ok, struct()} | {:error, any()}
+    def json_decode(input, opts \\ []) do
+      try do
+        {:ok, json_decode!(input, opts)}
+      rescue
+        e in Protox.JsonDecodingError -> {:error, e}
+      end
+    end
+
+    @spec json_decode!(iodata(), keyword()) :: struct() | no_return()
+    def json_decode!(input, opts \\ []) do
+      {json_library_wrapper, json_library} = Protox.JsonLibrary.get_library(opts, :decode)
+
+      Protox.JsonDecode.decode!(
+        input,
+        PgQuery.A_ArrayExpr,
+        &json_library_wrapper.decode!(json_library, &1)
+      )
+    end
+
+    @spec json_encode(struct(), keyword()) :: {:ok, iodata()} | {:error, any()}
+    def json_encode(msg, opts \\ []) do
+      try do
+        {:ok, json_encode!(msg, opts)}
+      rescue
+        e in Protox.JsonEncodingError -> {:error, e}
+      end
+    end
+
+    @spec json_encode!(struct(), keyword()) :: iodata() | no_return()
+    def json_encode!(msg, opts \\ []) do
+      {json_library_wrapper, json_library} = Protox.JsonLibrary.get_library(opts, :encode)
+      Protox.JsonEncode.encode!(msg, &json_library_wrapper.encode!(json_library, &1))
+    end
+  )
+
+  (
+    @deprecated "Use fields_defs()/0 instead"
+    @spec defs() :: %{
+            required(non_neg_integer) => {atom, Protox.Types.kind(), Protox.Types.type()}
+          }
+    def defs() do
+      %{
+        1 => {:elements, :unpacked, {:message, PgQuery.Node}},
+        2 => {:location, {:scalar, 0}, :int32}
+      }
+    end
+
+    @deprecated "Use fields_defs()/0 instead"
+    @spec defs_by_name() :: %{
+            required(atom) => {non_neg_integer, Protox.Types.kind(), Protox.Types.type()}
+          }
+    def defs_by_name() do
+      %{elements: {1, :unpacked, {:message, PgQuery.Node}}, location: {2, {:scalar, 0}, :int32}}
+    end
+  )
+
+  (
+    @spec fields_defs() :: list(Protox.Field.t())
+    def fields_defs() do
+      [
+        %{
+          __struct__: Protox.Field,
+          json_name: "elements",
+          kind: :unpacked,
+          label: :repeated,
+          name: :elements,
+          tag: 1,
+          type: {:message, PgQuery.Node}
+        },
+        %{
+          __struct__: Protox.Field,
+          json_name: "location",
+          kind: {:scalar, 0},
+          label: :optional,
+          name: :location,
+          tag: 2,
+          type: :int32
+        }
+      ]
+    end
+
+    [
+      @spec(field_def(atom) :: {:ok, Protox.Field.t()} | {:error, :no_such_field}),
+      (
+        def field_def(:elements) do
+          {:ok,
+           %{
+             __struct__: Protox.Field,
+             json_name: "elements",
+             kind: :unpacked,
+             label: :repeated,
+             name: :elements,
+             tag: 1,
+             type: {:message, PgQuery.Node}
+           }}
+        end
+
+        def field_def("elements") do
+          {:ok,
+           %{
+             __struct__: Protox.Field,
+             json_name: "elements",
+             kind: :unpacked,
+             label: :repeated,
+             name: :elements,
+             tag: 1,
+             type: {:message, PgQuery.Node}
+           }}
+        end
+
+        []
+      ),
+      (
+        def field_def(:location) do
+          {:ok,
+           %{
+             __struct__: Protox.Field,
+             json_name: "location",
+             kind: {:scalar, 0},
+             label: :optional,
+             name: :location,
+             tag: 2,
+             type: :int32
+           }}
+        end
+
+        def field_def("location") do
+          {:ok,
+           %{
+             __struct__: Protox.Field,
+             json_name: "location",
+             kind: {:scalar, 0},
+             label: :optional,
+             name: :location,
+             tag: 2,
+             type: :int32
+           }}
+        end
+
+        []
+      ),
+      def field_def(_) do
+        {:error, :no_such_field}
+      end
+    ]
+  )
+
+  []
+
+  (
+    @spec required_fields() :: []
+    def required_fields() do
+      []
+    end
+  )
+
+  (
+    @spec syntax() :: atom()
+    def syntax() do
+      :proto3
+    end
+  )
+
+  [
+    @spec(default(atom) :: {:ok, boolean | integer | String.t() | float} | {:error, atom}),
+    def default(:elements) do
+      {:error, :no_default_value}
+    end,
+    def default(:location) do
+      {:ok, 0}
+    end,
+    def default(_) do
+      {:error, :no_such_field}
+    end
+  ]
+
+  (
+    @spec file_options() :: nil
+    def file_options() do
+      nil
+    end
+  )
+end