pg_query_ex

# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.Constraint 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__{
          location: integer(),
          old_pktable_oid: non_neg_integer(),
          old_conpfeqop: [PgQuery.Node.t()],
          fk_del_set_cols: [PgQuery.Node.t()],
          fk_del_action: String.t(),
          fk_upd_action: String.t(),
          fk_matchtype: String.t(),
          pk_attrs: [PgQuery.Node.t()],
          fk_attrs: [PgQuery.Node.t()],
          pktable: PgQuery.RangeVar.t() | nil,
          where_clause: PgQuery.Node.t() | nil,
          access_method: String.t(),
          reset_default_tblspc: boolean(),
          indexspace: String.t(),
          indexname: String.t(),
          options: [PgQuery.Node.t()],
          exclusions: [PgQuery.Node.t()],
          including: [PgQuery.Node.t()],
          keys: [PgQuery.Node.t()],
          nulls_not_distinct: boolean(),
          inhcount: integer(),
          generated_when: String.t(),
          cooked_expr: String.t(),
          raw_expr: PgQuery.Node.t() | nil,
          is_no_inherit: boolean(),
          initially_valid: boolean(),
          skip_validation: boolean(),
          initdeferred: boolean(),
          deferrable: boolean(),
          conname: String.t(),
          contype: atom(),
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct location: 0,
            old_pktable_oid: 0,
            old_conpfeqop: [],
            fk_del_set_cols: [],
            fk_del_action: "",
            fk_upd_action: "",
            fk_matchtype: "",
            pk_attrs: [],
            fk_attrs: [],
            pktable: nil,
            where_clause: nil,
            access_method: "",
            reset_default_tblspc: false,
            indexspace: "",
            indexname: "",
            options: [],
            exclusions: [],
            including: [],
            keys: [],
            nulls_not_distinct: false,
            inhcount: 0,
            generated_when: "",
            cooked_expr: "",
            raw_expr: nil,
            is_no_inherit: false,
            initially_valid: false,
            skip_validation: false,
            initdeferred: false,
            deferrable: false,
            conname: "",
            contype: :CONSTR_TYPE_UNDEFINED,
            __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_location(msg)
        |> encode_old_pktable_oid(msg)
        |> encode_old_conpfeqop(msg)
        |> encode_fk_del_set_cols(msg)
        |> encode_fk_del_action(msg)
        |> encode_fk_upd_action(msg)
        |> encode_fk_matchtype(msg)
        |> encode_pk_attrs(msg)
        |> encode_fk_attrs(msg)
        |> encode_pktable(msg)
        |> encode_where_clause(msg)
        |> encode_access_method(msg)
        |> encode_reset_default_tblspc(msg)
        |> encode_indexspace(msg)
        |> encode_indexname(msg)
        |> encode_options(msg)
        |> encode_exclusions(msg)
        |> encode_including(msg)
        |> encode_keys(msg)
        |> encode_nulls_not_distinct(msg)
        |> encode_inhcount(msg)
        |> encode_generated_when(msg)
        |> encode_cooked_expr(msg)
        |> encode_raw_expr(msg)
        |> encode_is_no_inherit(msg)
        |> encode_initially_valid(msg)
        |> encode_skip_validation(msg)
        |> encode_initdeferred(msg)
        |> encode_deferrable(msg)
        |> encode_conname(msg)
        |> encode_contype(msg)
        |> encode_unknown_fields(msg)
      end
    )

    defp encode_location({acc, acc_size}, msg) do
      if msg.location == 0 do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_int32(msg.location)
        {["\xF8\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:location, "invalid field value"), __STACKTRACE__
    end

    defp encode_old_pktable_oid({acc, acc_size}, msg) do
      if msg.old_pktable_oid == 0 do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_uint32(msg.old_pktable_oid)
        {["\xF0\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:old_pktable_oid, "invalid field value"), __STACKTRACE__
    end

    defp encode_old_conpfeqop({acc, acc_size}, msg) do
      case msg.old_conpfeqop 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, "\xEA\x01" | local_acc], local_acc_size + 2 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

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

    defp encode_fk_del_set_cols({acc, acc_size}, msg) do
      case msg.fk_del_set_cols 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, "\xE2\x01" | local_acc], local_acc_size + 2 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

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

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

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

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

    defp encode_pk_attrs({acc, acc_size}, msg) do
      case msg.pk_attrs 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, "\xC2\x01" | local_acc], local_acc_size + 2 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

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

    defp encode_fk_attrs({acc, acc_size}, msg) do
      case msg.fk_attrs 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, "\xBA\x01" | local_acc], local_acc_size + 2 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

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

    defp encode_pktable({acc, acc_size}, msg) do
      if msg.pktable == nil do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_message(msg.pktable)
        {["\xB2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:pktable, "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)
        {["\xAA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:where_clause, "invalid field value"), __STACKTRACE__
    end

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

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

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

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

    defp encode_options({acc, acc_size}, msg) do
      case msg.options 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, "\x82\x01" | local_acc], local_acc_size + 2 + value_bytes_size}
                end)

              {Enum.reverse(value_bytes), value_size}
            )

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

    defp encode_exclusions({acc, acc_size}, msg) do
      case msg.exclusions 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(:exclusions, "invalid field value"), __STACKTRACE__
    end

    defp encode_including({acc, acc_size}, msg) do
      case msg.including 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(:including, "invalid field value"), __STACKTRACE__
    end

    defp encode_keys({acc, acc_size}, msg) do
      case msg.keys 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(:keys, "invalid field value"), __STACKTRACE__
    end

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

    defp encode_inhcount({acc, acc_size}, msg) do
      if msg.inhcount == 0 do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_int32(msg.inhcount)
        {["X", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:inhcount, "invalid field value"), __STACKTRACE__
    end

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

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

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

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

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

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

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

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

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

    defp encode_contype({acc, acc_size}, msg) do
      if msg.contype == :CONSTR_TYPE_UNDEFINED do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} =
          msg.contype |> PgQuery.ConstrType.encode() |> Protox.Encode.encode_enum()

        {["\b", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:contype, "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.Constraint))
        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{}

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

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

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

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

            <<27::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[fk_del_action: Protox.Decode.validate_string!(delimited)], rest}

            <<26::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[fk_upd_action: Protox.Decode.validate_string!(delimited)], rest}

            <<25::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[fk_matchtype: Protox.Decode.validate_string!(delimited)], rest}

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

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

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

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

            <<21::5, _wire_type::3, "\x01", 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}

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

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

            <<18::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[indexspace: Protox.Decode.validate_string!(delimited)], rest}

            <<17::5, _wire_type::3, "\x01", bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[indexname: Protox.Decode.validate_string!(delimited)], rest}

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

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

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

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

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

            <<11::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_int32(bytes)
              {[inhcount: value], rest}

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

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

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

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

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

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

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

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

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

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

            <<1::5, _wire_type::3, bytes::binary>> ->
              {value, rest} = Protox.Decode.parse_enum(bytes, PgQuery.ConstrType)
              {[contype: value], 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(:location) do
      {:ok, 0}
    end

    def default(:old_pktable_oid) do
      {:ok, 0}
    end

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

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

    def default(:fk_del_action) do
      {:ok, ""}
    end

    def default(:fk_upd_action) do
      {:ok, ""}
    end

    def default(:fk_matchtype) do
      {:ok, ""}
    end

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

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

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

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

    def default(:access_method) do
      {:ok, ""}
    end

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

    def default(:indexspace) do
      {:ok, ""}
    end

    def default(:indexname) do
      {:ok, ""}
    end

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

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

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

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

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

    def default(:inhcount) do
      {:ok, 0}
    end

    def default(:generated_when) do
      {:ok, ""}
    end

    def default(:cooked_expr) do
      {:ok, ""}
    end

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

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

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

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

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

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

    def default(:conname) do
      {:ok, ""}
    end

    def default(:contype) do
      {:ok, :CONSTR_TYPE_UNDEFINED}
    end

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

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        access_method: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :access_method,
          tag: 20,
          type: :string
        },
        conname: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :conname,
          tag: 2,
          type: :string
        },
        contype: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: :CONSTR_TYPE_UNDEFINED},
          label: :optional,
          name: :contype,
          tag: 1,
          type: {:enum, PgQuery.ConstrType}
        },
        cooked_expr: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :cooked_expr,
          tag: 9,
          type: :string
        },
        deferrable: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :deferrable,
          tag: 3,
          type: :bool
        },
        exclusions: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :exclusions,
          tag: 15,
          type: {:message, PgQuery.Node}
        },
        fk_attrs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :fk_attrs,
          tag: 23,
          type: {:message, PgQuery.Node}
        },
        fk_del_action: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :fk_del_action,
          tag: 27,
          type: :string
        },
        fk_del_set_cols: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :fk_del_set_cols,
          tag: 28,
          type: {:message, PgQuery.Node}
        },
        fk_matchtype: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :fk_matchtype,
          tag: 25,
          type: :string
        },
        fk_upd_action: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :fk_upd_action,
          tag: 26,
          type: :string
        },
        generated_when: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :generated_when,
          tag: 10,
          type: :string
        },
        including: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :including,
          tag: 14,
          type: {:message, PgQuery.Node}
        },
        indexname: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :indexname,
          tag: 17,
          type: :string
        },
        indexspace: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :indexspace,
          tag: 18,
          type: :string
        },
        inhcount: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :inhcount,
          tag: 11,
          type: :int32
        },
        initdeferred: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :initdeferred,
          tag: 4,
          type: :bool
        },
        initially_valid: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :initially_valid,
          tag: 6,
          type: :bool
        },
        is_no_inherit: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :is_no_inherit,
          tag: 7,
          type: :bool
        },
        keys: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :keys,
          tag: 13,
          type: {:message, PgQuery.Node}
        },
        location: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :location,
          tag: 31,
          type: :int32
        },
        nulls_not_distinct: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :nulls_not_distinct,
          tag: 12,
          type: :bool
        },
        old_conpfeqop: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :old_conpfeqop,
          tag: 29,
          type: {:message, PgQuery.Node}
        },
        old_pktable_oid: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :old_pktable_oid,
          tag: 30,
          type: :uint32
        },
        options: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :options,
          tag: 16,
          type: {:message, PgQuery.Node}
        },
        pk_attrs: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :pk_attrs,
          tag: 24,
          type: {:message, PgQuery.Node}
        },
        pktable: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :pktable,
          tag: 22,
          type: {:message, PgQuery.RangeVar}
        },
        raw_expr: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :raw_expr,
          tag: 8,
          type: {:message, PgQuery.Node}
        },
        reset_default_tblspc: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :reset_default_tblspc,
          tag: 19,
          type: :bool
        },
        skip_validation: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :skip_validation,
          tag: 5,
          type: :bool
        },
        where_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :where_clause,
          tag: 21,
          type: {:message, PgQuery.Node}
        }
      },
      file_options: nil,
      name: PgQuery.Constraint,
      syntax: :proto3
    }
  end
end