pg_query_ex

# Code generated by protox. Don't edit.
# credo:disable-for-this-file
defmodule PgQuery.ColumnDef 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(),
          fdwoptions: [PgQuery.Node.t()],
          constraints: [PgQuery.Node.t()],
          coll_oid: non_neg_integer(),
          coll_clause: PgQuery.CollateClause.t() | nil,
          generated: String.t(),
          identity_sequence: PgQuery.RangeVar.t() | nil,
          identity: String.t(),
          cooked_default: PgQuery.Node.t() | nil,
          raw_default: PgQuery.Node.t() | nil,
          storage_name: String.t(),
          storage: String.t(),
          is_from_type: boolean(),
          is_not_null: boolean(),
          is_local: boolean(),
          inhcount: integer(),
          compression: String.t(),
          type_name: PgQuery.TypeName.t() | nil,
          colname: String.t(),
          __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}]
        }
  defstruct location: 0,
            fdwoptions: [],
            constraints: [],
            coll_oid: 0,
            coll_clause: nil,
            generated: "",
            identity_sequence: nil,
            identity: "",
            cooked_default: nil,
            raw_default: nil,
            storage_name: "",
            storage: "",
            is_from_type: false,
            is_not_null: false,
            is_local: false,
            inhcount: 0,
            compression: "",
            type_name: nil,
            colname: "",
            __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_fdwoptions(msg)
        |> encode_constraints(msg)
        |> encode_coll_oid(msg)
        |> encode_coll_clause(msg)
        |> encode_generated(msg)
        |> encode_identity_sequence(msg)
        |> encode_identity(msg)
        |> encode_cooked_default(msg)
        |> encode_raw_default(msg)
        |> encode_storage_name(msg)
        |> encode_storage(msg)
        |> encode_is_from_type(msg)
        |> encode_is_not_null(msg)
        |> encode_is_local(msg)
        |> encode_inhcount(msg)
        |> encode_compression(msg)
        |> encode_type_name(msg)
        |> encode_colname(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)
        {["\x98\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_fdwoptions({acc, acc_size}, msg) do
      case msg.fdwoptions 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, "\x92\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(:fdwoptions, "invalid field value"), __STACKTRACE__
    end

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

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

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

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

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

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

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

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

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

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

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

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

    defp encode_is_local({acc, acc_size}, msg) do
      if msg.is_local == false do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_bool(msg.is_local)
        {["(", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:is_local, "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)
        {[" ", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:inhcount, "invalid field value"), __STACKTRACE__
    end

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

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

    defp encode_colname({acc, acc_size}, msg) do
      if msg.colname == "" do
        {acc, acc_size}
      else
        {value_bytes, value_bytes_size} = Protox.Encode.encode_string(msg.colname)
        {["\n", value_bytes | acc], acc_size + 1 + value_bytes_size}
      end
    rescue
      ArgumentError ->
        reraise Protox.EncodingError.new(:colname, "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.ColumnDef))
        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{}

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

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

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

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

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

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

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

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

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

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

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

              {[
                 cooked_default:
                   Protox.MergeMessage.merge(msg.cooked_default, 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)

              {[
                 raw_default:
                   Protox.MergeMessage.merge(msg.raw_default, 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)
              {[storage_name: 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)
              {[storage: Protox.Decode.validate_string!(delimited)], rest}

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

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

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

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

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

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

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

            <<1::5, _wire_type::3, bytes::binary>> ->
              {len, bytes} = Protox.Varint.decode(bytes)
              {delimited, rest} = Protox.Decode.parse_delimited(bytes, len)
              {[colname: Protox.Decode.validate_string!(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(:location) do
      {:ok, 0}
    end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  @spec schema() :: Protox.MessageSchema.t()
  def schema() do
    %{
      __struct__: Protox.MessageSchema,
      fields: %{
        coll_clause: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :coll_clause,
          tag: 15,
          type: {:message, PgQuery.CollateClause}
        },
        coll_oid: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :coll_oid,
          tag: 16,
          type: :uint32
        },
        colname: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :colname,
          tag: 1,
          type: :string
        },
        compression: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :compression,
          tag: 3,
          type: :string
        },
        constraints: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :constraints,
          tag: 17,
          type: {:message, PgQuery.Node}
        },
        cooked_default: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :cooked_default,
          tag: 11,
          type: {:message, PgQuery.Node}
        },
        fdwoptions: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: :unpacked,
          label: :repeated,
          name: :fdwoptions,
          tag: 18,
          type: {:message, PgQuery.Node}
        },
        generated: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :generated,
          tag: 14,
          type: :string
        },
        identity: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :identity,
          tag: 12,
          type: :string
        },
        identity_sequence: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :identity_sequence,
          tag: 13,
          type: {:message, PgQuery.RangeVar}
        },
        inhcount: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :inhcount,
          tag: 4,
          type: :int32
        },
        is_from_type: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :is_from_type,
          tag: 7,
          type: :bool
        },
        is_local: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :is_local,
          tag: 5,
          type: :bool
        },
        is_not_null: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: false},
          label: :optional,
          name: :is_not_null,
          tag: 6,
          type: :bool
        },
        location: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: 0},
          label: :optional,
          name: :location,
          tag: 19,
          type: :int32
        },
        raw_default: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :raw_default,
          tag: 10,
          type: {:message, PgQuery.Node}
        },
        storage: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :storage,
          tag: 8,
          type: :string
        },
        storage_name: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: ""},
          label: :optional,
          name: :storage_name,
          tag: 9,
          type: :string
        },
        type_name: %{
          __struct__: Protox.Field,
          extender: nil,
          kind: %{__struct__: Protox.Scalar, default_value: nil},
          label: :optional,
          name: :type_name,
          tag: 2,
          type: {:message, PgQuery.TypeName}
        }
      },
      file_options: nil,
      name: PgQuery.ColumnDef,
      syntax: :proto3
    }
  end
end