# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.SelectStmt do
  @moduledoc false
  if function_exported?(Protox, :check_generator_version, 1) do
    Protox.check_generator_version(1)
  else
    raise "This code was generated with protox 2 but the runtime is using an older version of protox."
  end

  @type t :: %__MODULE__{
          rarg: PgQuery.SelectStmt.t() | nil,
          larg: PgQuery.SelectStmt.t() | nil,
          all: boolean(),
          op: atom(),
          with_clause: PgQuery.WithClause.t() | nil,
          locking_clause: [PgQuery.Node.t()],
          limit_option: atom(),
          limit_count: PgQuery.Node.t() | nil,
          limit_offset: PgQuery.Node.t() | nil,
          sort_clause: [PgQuery.Node.t()],
          values_lists: [PgQuery.Node.t()],
          window_clause: [PgQuery.Node.t()],
          having_clause: PgQuery.Node.t() | nil,
          group_distinct: boolean(),
          group_clause: [PgQuery.Node.t()],
          where_clause: PgQuery.Node.t() | nil,
          from_clause: [PgQuery.Node.t()],
          target_list: [PgQuery.Node.t()],
          into_clause: PgQuery.IntoClause.t() | nil,
          distinct_clause: [PgQuery.Node.t()],
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct rarg: nil,
            larg: nil,
            all: false,
            op: :SET_OPERATION_UNDEFINED,
            with_clause: nil,
            locking_clause: [],
            limit_option: :LIMIT_OPTION_UNDEFINED,
            limit_count: nil,
            limit_offset: nil,
            sort_clause: [],
            values_lists: [],
            window_clause: [],
            having_clause: nil,
            group_distinct: false,
            group_clause: [],
            where_clause: nil,
            from_clause: [],
            target_list: [],
            into_clause: nil,
            distinct_clause: [],
            __uf__: []

  (
    (
      @spec encode(t()) :: {:ok, iodata(), non_neg_integer()} | {:error, any()}
      def encode(msg) do
        msg |> encode!() |> Tuple.insert_at(0, :ok)
      rescue
        e in [Protox.EncodingError, Protox.RequiredFieldsError] -> {:error, e}
      end

      @spec encode!(t()) :: {iodata(), non_neg_integer()} | no_return()
      def encode!(msg) do
        {_acc = [], _acc_size = 0}
        |> encode_rarg(msg)
        |> encode_larg(msg)
        |> encode_all(msg)
        |> encode_op(msg)
        |> encode_with_clause(msg)
        |> encode_locking_clause(msg)
        |> encode_limit_option(msg)
        |> encode_limit_count(msg)
        |> encode_limit_offset(msg)
        |> encode_sort_clause(msg)
        |> encode_values_lists(msg)
        |> encode_window_clause(msg)
        |> encode_having_clause(msg)
        |> encode_group_distinct(msg)
        |> encode_group_clause(msg)
        |> encode_where_clause(msg)
        |> encode_from_clause(msg)
        |> encode_target_list(msg)
        |> encode_into_clause(msg)
        |> encode_distinct_clause(msg)
        |> encode_unknown_fields(msg)
      end
    )

    defp encode_rarg({acc, acc_size}, msg) do
      if msg.rarg == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.rarg)
        {["\xA2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:rarg, "invalid field value"), __STACKTRACE__
    end

    defp encode_larg({acc, acc_size}, msg) do
      if msg.larg == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.larg)
        {["\x9A\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:larg, "invalid field value"), __STACKTRACE__
    end

    defp encode_all({acc, acc_size}, msg) do
      if msg.all == false do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_bool(msg.all)
        {["\x90\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:all, "invalid field value"), __STACKTRACE__
    end

    defp encode_op({acc, acc_size}, msg) do
      if msg.op == :SET_OPERATION_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.op |> PgQuery.SetOperation.encode() |> Protox.Encode.encode_enum()

        {["\x88\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:op, "invalid field value"), __STACKTRACE__
    end

    defp encode_with_clause({acc, acc_size}, msg) do
      if msg.with_clause == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.with_clause)
        {["\x82\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:with_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_locking_clause({acc, acc_size}, msg) do
      case msg.locking_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "z" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:locking_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_limit_option({acc, acc_size}, msg) do
      if msg.limit_option == :LIMIT_OPTION_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.limit_option |> PgQuery.LimitOption.encode() |> Protox.Encode.encode_enum()

        {["p", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:limit_option, "invalid field value"), __STACKTRACE__
    end

    defp encode_limit_count({acc, acc_size}, msg) do
      if msg.limit_count == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.limit_count)
        {["j", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:limit_count, "invalid field value"), __STACKTRACE__
    end

    defp encode_limit_offset({acc, acc_size}, msg) do
      if msg.limit_offset == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.limit_offset)
        {["b", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:limit_offset, "invalid field value"), __STACKTRACE__
    end

    defp encode_sort_clause({acc, acc_size}, msg) do
      case msg.sort_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "Z" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:sort_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_values_lists({acc, acc_size}, msg) do
      case msg.values_lists do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "R" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:values_lists, "invalid field value"), __STACKTRACE__
    end

    defp encode_window_clause({acc, acc_size}, msg) do
      case msg.window_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "J" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:window_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_having_clause({acc, acc_size}, msg) do
      if msg.having_clause == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.having_clause)
        {["B", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:having_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_group_distinct({acc, acc_size}, msg) do
      if msg.group_distinct == false do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_bool(msg.group_distinct)
        {["8", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:group_distinct, "invalid field value"), __STACKTRACE__
    end

    defp encode_group_clause({acc, acc_size}, msg) do
      case msg.group_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "2" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:group_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_where_clause({acc, acc_size}, msg) do
      if msg.where_clause == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.where_clause)
        {["*", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:where_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_from_clause({acc, acc_size}, msg) do
      case msg.from_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\"" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:from_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_target_list({acc, acc_size}, msg) do
      case msg.target_list do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\x1A" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:target_list, "invalid field value"), __STACKTRACE__
    end

    defp encode_into_clause({acc, acc_size}, msg) do
      if msg.into_clause == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.into_clause)
        {["\x12", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:into_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_distinct_clause({acc, acc_size}, msg) do
      case msg.distinct_clause do
        [] ->
          {acc, acc_size}

        values ->
          {value_bytes, value_size} =
            (
              {value_bytes, value_size} =
                Enum.reduce(values, {_local_acc = [], _local_acc_size = 0}, fn value,
                                                                               {local_acc,
                                                                                local_acc_size} ->
                  {value_bytes, value_bytes_size} = Protox.Encode.encode_message(value)
                  {[value_bytes, "\n" | local_acc], local_acc_size + 1 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

          {[value_bytes | acc], acc_size + value_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:distinct_clause, "invalid field value"), __STACKTRACE__
    end

    defp encode_unknown_fields({acc, acc_size}, msg) do
      Enum.reduce(msg.__uf__, {acc, acc_size}, fn {tag, wire_type, bytes}, {acc, acc_size} ->
        case wire_type do
          0 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :int32)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          1 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :double)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}

          2 ->
            {len_bytes, len_size} = bytes |> byte_size() |> Protox.Varint.encode()
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :packed)

            {[acc, <<key_bytes::binary, len_bytes::binary, bytes::binary>>],
             acc_size + key_size + len_size + byte_size(bytes)}

          5 ->
            {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :float)
            {[acc, <<key_bytes::binary, bytes::binary>>], acc_size + key_size + byte_size(bytes)}
        end
      end)
    end
  )

  (
    (
      @spec decode(binary()) :: {:ok, t()} | {:error, any()}
      def decode(bytes) do
        {:ok, decode!(bytes)}
      rescue
        e in [Protox.DecodingError, Protox.IllegalTagError, Protox.RequiredFieldsError] ->
          {:error, e}
      end

      (
        @spec decode!(binary()) :: t() | no_return()
        def decode!(bytes) do
          parse_key_value(bytes, struct(PgQuery.SelectStmt))
        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 bytes do
            <<_::5, 3::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 3")

            <<_::5, 4::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 4")

            <<_::5, 6::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 6")

            <<_::5, 7::3, _rest::binary>> ->
              raise Protox.DecodingError.new(bytes, "invalid wire type 7")

            <<0::5, _::3, _rest::binary>> ->
              raise %Protox.IllegalTagError{}

            <<20::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[rarg: Protox.MergeMessage.merge(msg.rarg, PgQuery.SelectStmt.decode!(delimited))],
               rest}

            <<19::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[larg: Protox.MergeMessage.merge(msg.larg, PgQuery.SelectStmt.decode!(delimited))],
               rest}

            <<18::5, _wire_type::3, "\x01", bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_bool(bytes)
              {[all: value], rest}

            <<17::5, _wire_type::3, "\x01", bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.SetOperation)
              {[op: value], rest}

            <<16::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 with_clause:
                   Protox.MergeMessage.merge(
                     msg.with_clause,
                     PgQuery.WithClause.decode!(delimited)
                   )
               ], rest}

            <<15::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[locking_clause: msg.locking_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<14::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.LimitOption)
              {[limit_option: value], rest}

            <<13::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 limit_count:
                   Protox.MergeMessage.merge(msg.limit_count, PgQuery.Node.decode!(delimited))
               ], rest}

            <<12::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 limit_offset:
                   Protox.MergeMessage.merge(msg.limit_offset, PgQuery.Node.decode!(delimited))
               ], rest}

            <<11::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[sort_clause: msg.sort_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<10::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[values_lists: msg.values_lists ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<9::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[window_clause: msg.window_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<8::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 having_clause:
                   Protox.MergeMessage.merge(msg.having_clause, PgQuery.Node.decode!(delimited))
               ], rest}

            <<7::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_bool(bytes)
              {[group_distinct: value], rest}

            <<6::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[group_clause: msg.group_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<5::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 where_clause:
                   Protox.MergeMessage.merge(msg.where_clause, PgQuery.Node.decode!(delimited))
               ], rest}

            <<4::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[from_clause: msg.from_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<3::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[target_list: msg.target_list ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<2::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)

              {[
                 into_clause:
                   Protox.MergeMessage.merge(
                     msg.into_clause,
                     PgQuery.IntoClause.decode!(delimited)
                   )
               ], rest}

            <<1::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[distinct_clause: msg.distinct_clause ++ [PgQuery.Node.decode!(delimited)]], rest}

            <<bytes::binary>> ->
              {tag, wire_type, rest} = Protox.Decode.parse_key(bytes)
              {value, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest)
              {[__uf__: msg.__uf__ ++ [value]], rest}
          end

        msg_updated = struct(msg, field)
        parse_key_value(rest, msg_updated)
      end
    )
  )

  (
    @spec unknown_fields(struct()) :: [{non_neg_integer(), Protox.Types.tag(), binary()}]
    def unknown_fields(msg) do
      msg.__uf__
    end

    @spec unknown_fields_name() :: :__uf__
    def unknown_fields_name() do
      :__uf__
    end

    @spec clear_unknown_fields(struct) :: struct
    def clear_unknown_fields(msg) do
      struct!(msg, __uf__: [])
    end
  )

  (
    @spec default(atom()) ::
            {:ok, boolean() | integer() | String.t() | float()}
            | {:error, :no_such_field | :no_default_value}
    def default(:rarg) do
      {:ok, nil}
    end

    def default(:larg) do
      {:ok, nil}
    end

    def default(:all) do
      {:ok, false}
    end

    def default(:op) do
      {:ok, :SET_OPERATION_UNDEFINED}
    end

    def default(:with_clause) do
      {:ok, nil}
    end

    def default(:locking_clause) do
      {:error, :no_default_value}
    end

    def default(:limit_option) do
      {:ok, :LIMIT_OPTION_UNDEFINED}
    end

    def default(:limit_count) do
      {:ok, nil}
    end

    def default(:limit_offset) do
      {:ok, nil}
    end

    def default(:sort_clause) do
      {:error, :no_default_value}
    end

    def default(:values_lists) do
      {:error, :no_default_value}
    end

    def default(:window_clause) do
      {:error, :no_default_value}
    end

    def default(:having_clause) do
      {:ok, nil}
    end

    def default(:group_distinct) do
      {:ok, false}
    end

    def default(:group_clause) do
      {:error, :no_default_value}
    end

    def default(:where_clause) do
      {:ok, nil}
    end

    def default(:from_clause) do
      {:error, :no_default_value}
    end

    def default(:target_list) do
      {:error, :no_default_value}
    end

    def default(:into_clause) do
      {:ok, nil}
    end

    def default(:distinct_clause) do
      {:error, :no_default_value}
    end

    def default(_) do
      {:error, :no_such_field}
    end
  )

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        all: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :all,
          tag: 18,
          type: :bool
        },
        distinct_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :distinct_clause,
          tag: 1,
          type: {:message, PgQuery.Node}
        },
        from_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :from_clause,
          tag: 4,
          type: {:message, PgQuery.Node}
        },
        group_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :group_clause,
          tag: 6,
          type: {:message, PgQuery.Node}
        },
        group_distinct: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :group_distinct,
          tag: 7,
          type: :bool
        },
        having_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :having_clause,
          tag: 8,
          type: {:message, PgQuery.Node}
        },
        into_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :into_clause,
          tag: 2,
          type: {:message, PgQuery.IntoClause}
        },
        larg: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :larg,
          tag: 19,
          type: {:message, PgQuery.SelectStmt}
        },
        limit_count: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :limit_count,
          tag: 13,
          type: {:message, PgQuery.Node}
        },
        limit_offset: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :limit_offset,
          tag: 12,
          type: {:message, PgQuery.Node}
        },
        limit_option: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :LIMIT_OPTION_UNDEFINED},
          label: :optional,
          name: :limit_option,
          tag: 14,
          type: {:enum, PgQuery.LimitOption}
        },
        locking_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :locking_clause,
          tag: 15,
          type: {:message, PgQuery.Node}
        },
        op: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :SET_OPERATION_UNDEFINED},
          label: :optional,
          name: :op,
          tag: 17,
          type: {:enum, PgQuery.SetOperation}
        },
        rarg: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :rarg,
          tag: 20,
          type: {:message, PgQuery.SelectStmt}
        },
        sort_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :sort_clause,
          tag: 11,
          type: {:message, PgQuery.Node}
        },
        target_list: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :target_list,
          tag: 3,
          type: {:message, PgQuery.Node}
        },
        values_lists: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :values_lists,
          tag: 10,
          type: {:message, PgQuery.Node}
        },
        where_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :where_clause,
          tag: 5,
          type: {:message, PgQuery.Node}
        },
        window_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :window_clause,
          tag: 9,
          type: {:message, PgQuery.Node}
        },
        with_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :with_clause,
          tag: 16,
          type: {:message, PgQuery.WithClause}
        }
      },
      file_options: nil,
      name: PgQuery.SelectStmt,
      syntax: :proto3
    }
  end
end