Does Hertz Extend Protobuf's FieldOption To Support Field Embedding?

Describe the Question

Does Hertz provide an extension to Protocol Buffers' FieldOption that enables field embedding functionality? This feature would be similar to gogofast's implementation, where the field option ensures the message is generated as an embedded field. Field embedding is a crucial feature in Protocol Buffers, as it allows for more efficient and flexible message representation. By embedding fields, developers can reduce the overhead of message serialization and deserialization, leading to improved performance and scalability.

Background on Protocol Buffers and Field Embedding

Protocol Buffers is a language-agnostic data serialization format developed by Google. It provides a simple and efficient way to encode and decode structured data, making it a popular choice for building scalable and high-performance applications. One of the key features of Protocol Buffers is its ability to support field embedding, which allows developers to embed one message within another. This feature is particularly useful in scenarios where a message needs to be represented as a single unit, rather than as a collection of separate fields.

Reproducible Code

To demonstrate the issue, let's consider the following example code:

message ParentRequest {
  string account = 1 [
    (api.go_tag) = 'json:"account"',
    (google.api.field_behavior) = REQUIRED
  ];
}

message ChildRequest {
  ParentRequest base = 1 [
    (gogoproto.embed) = true,
    (gogoproto.jsontag) = "inline"
  ];
  string project = 2 [
    (api.go_tag) = 'json:"project"',
    (google.api.field_behavior) = REQUIRED
  ];
}

In this example, we define two messages: ParentRequest and ChildRequest. The ChildRequest message embeds the ParentRequest message using the gogoproto.embed field option. We also specify the gogoproto.jsontag field option to indicate that the embedded message should be represented as an inline JSON object.

Expected Behavior

When we generate the code for the ChildRequest message using the Protocol Buffers compiler, we expect the following output:

type ChildRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

        *ParentRequest `protobuf:"bytes,1,opt,name=base,proto3" form:"base" json:",inline" query:"base"`
	Project string                               `protobuf:"bytes,2,opt,name=project,proto3" form:"project" json:"project" query:"project"`
}

As we can see, the generated code represents the ChildRequest message as a struct with two fields: base and project. The base field is an embedded ParentRequest message, represented as an inline JSON object.

Hertz Version and Environment

We are using Hertz version v0.9.1, which is the latest stable release at the time of writing. Our environment is set up as follows:

AR='ar'
CC='clang'
CGO_CFLAGS='-O2 -g'
CGO_CPPFLAGS=''
CGO_CXXFLAGS='-O2 -g'
CGO_ENABLED='1'
CGO_FFLAGS='-O2 -g'
CGO_LDFLAG='-O2 -g'
CXX='clang++'
GCCGO='gccgo'
GO111MODULE='on'
GOARCH='arm64'
GOARM64='v8.0'
GOAUTH='netrc'
GOBIN=''
GOCACHE='/Users/brown/Library/Caches/go-build'
GOCACHEPROG=''
GODEBUG=''
GOENV='/Users/brown/Library/Application Support/go/env'
GOEXE=''
GOEXPERIMENT=''
GOFIPS140='off'
GOFLAGS=''
GOGCCFLAGS='-fPIC -arch arm64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -ffile-prefix-map=/var/folders/6f/wwrgby991pjcq75jr1m_kgdw0000gn/T/go-build2493813573=/tmp/go-build -gno-record-gcc-switches -fno-common'
GOHOSTARCH='arm64'
GOHOSTOS='darwin'
GOINSECURE=''
GOMOD='/Users/brown/sre/_source/cmdb/go.mod'
GOMODCACHE='/Users/brown/go/pkg/mod'
GONOPROXY=''
GONOSUMDB=''
GOOS='darwin'
GOPATH='/Users/baron/go'
GOPRIVATE=''
GOPROXY='https://goproxy.cn,direct'
GOROOT='/usr/local/go'
GOSUMDB='sum.golang.org'
GOTELEMETRY='local'
GOTELEMETRYDIR='/Users/brown/Library/Application Support/go/telemetry'
GOTMPDIR=''
GOTOOLCHAIN='auto'
GOTOOLDIR='/usr/local/go/pkg/tool/darwin_arm64'
GOVCS=''
GOVERSION='go1.24.2'
GOWORK=''
PKG_CONFIG='pkg-config'

Additional Context

I attempted to use the hz command line tool with the --protoc-plugins option to integrate the gogofast plugin. However, it appears that hz takes precedence over gogofast in terms of priority. When I specified a different output folder, the code was generated correctly.

Conclusion

In conclusion, Hertz does not currently extend Protocol Buffers' FieldOption to support field embedding functionality. While the gogofast plugin provides a similar implementation, it is not compatible with the hz command line tool. To achieve field embedding in Hertz, we need to use a different approach, such as specifying a different output folder or using a custom plugin. We hope that this issue will be addressed in future releases of Hertz, allowing developers to take full advantage of field embedding in Protocol Buffers.

Q&A

Q: What is field embedding in Protocol Buffers?

A: Field embedding is a feature in Protocol Buffers that allows one message to be embedded within another. This feature is particularly useful in scenarios where a message needs to be represented as a single unit, rather than as a collection of separate fields.

Q: How does field embedding work in Protocol Buffers?

A: In Protocol Buffers, field embedding is achieved using the gogoproto.embed field option. This option tells the Protocol Buffers compiler to embed one message within another. The embedded message is then represented as an inline JSON object.

Q: What is the difference between field embedding and message nesting?

A: Field embedding and message nesting are two different concepts in Protocol Buffers. Message nesting involves representing one message as a field within another message. Field embedding, on the other hand, involves embedding one message within another, but without representing it as a separate field.

Q: Why is field embedding important in Protocol Buffers?

A: Field embedding is important in Protocol Buffers because it allows for more efficient and flexible message representation. By embedding fields, developers can reduce the overhead of message serialization and deserialization, leading to improved performance and scalability.

Q: How does Hertz handle field embedding?

A: Hertz does not currently extend Protocol Buffers' FieldOption to support field embedding functionality. While the gogofast plugin provides a similar implementation, it is not compatible with the hz command line tool.

Q: What are the implications of Hertz not supporting field embedding?

A: The implications of Hertz not supporting field embedding are that developers may need to use a different approach to achieve field embedding, such as specifying a different output folder or using a custom plugin. This may add complexity to the development process and may not be compatible with all use cases.

Q: Is there a workaround for Hertz not supporting field embedding?

A: Yes, there are workarounds for Hertz not supporting field embedding. One approach is to use a different output folder or to use a custom plugin to achieve field embedding. Another approach is to use a different Protocol Buffers compiler, such as the protoc compiler, which supports field embedding.

Q: When will Hertz support field embedding?

A: We do not have a specific timeline for when Hertz will support field embedding. However, we are working to improve the compatibility of Hertz with the gogofast plugin and other Protocol Buffers features.

Q: How can I get involved in the development of Hertz?

A: We welcome contributions from the community to the development of Hertz. If you are interested in getting involved, please visit our GitHub repository and submit a pull request with your changes.

Q: Where can I find more information about Hertz and Protocol Buffers?

A: You can find more information about Hertz and Protocol Buffers on our website and in the official Protocol Buffers documentation. We also have a community forum where you can ask questions and get help from other developers.