Skip to content

Commit 5a65e93

Browse files
adriangbclaudealamb
authored andcommitted
Restore the From / TryFrom proto conversions dropped since 54.1.0 (apache#24205)
## Which issue does this PR close? - Closes apache#24019. - closes apache#23494 ## Rationale for this change `datafusion-proto` 54.1.0 publishes 39 `From` / `TryFrom` impls converting between DataFusion types and their protobuf messages. On `main` all of them were replaced by the crate-local `FromProto` / `TryFromProto` traits introduced in apache#21929, so code written against the released version stops compiling: ```rust let proto = protobuf::PartitionedFile::try_from(&file)?; // no longer resolves on main let frame = WindowFrame::try_from(proto_frame)?; // no longer resolves on main ``` That was collateral damage from the orphan-rule workaround, which was needed during the migration but can now be unwound to result in no breaking change across releases. ## What changes are included in this PR? Each conversion moves to a crate that owns one side of it, and goes back to being a plain `From` / `TryFrom` — the shape 54.1.0 published. Error types are unchanged (`FromProtoError` decoding, `ToProtoError` encoding, `DataFusionError` for the datasource types). | Types | New home | |---|---| | `PartitionedFile`, `FileRange`, `FileGroup`, `JsonSink`, `CsvSink`, `ParquetSink`, `FileSinkConfig` | already moved by apache#24006 / apache#23781 — this PR just deletes the `TryFromProto` shims that delegated to them | | `WindowFrame`, `WindowFrameBound`, `WindowFrameUnits`, `MergeIntoClauseKind`, `NullTreatment` | `datafusion-expr`, behind a new `proto` feature (optional `datafusion-proto-common` / `datafusion-proto-models` deps, mirroring `datafusion-datasource`) | | `UnnestOptions`, `TableReference`, `StringifiedPlan`, `JoinType`, `JoinConstraint`, `NullEquality`, `CsvOptions`, `JsonOptions`, and the parquet options types | `datafusion-proto-models`, on the local proto type — their DataFusion side sits *below* that crate in the graph, the same arrangement `datafusion-proto-common` already uses for `ScalarValue` / `Statistics` | | `CsvFormatFactory`, `JsonFormatFactory`, `ParquetFormatFactory` | `datafusion-datasource-{csv,json,parquet}`, behind each crate's existing `proto` feature | | `Column` <-> `protobuf::PhysicalColumn` | `datafusion-physical-expr`; `Column::try_to_proto` / `try_from_proto` now go through it instead of building the message inline | `TryFrom<&[PartitionedFile]> for protobuf::FileGroup` needed one extra step. `datafusion-datasource` cannot host it — `&T` is `#[fundamental]` but `[T]` is not, so `&[PartitionedFile]` counts as foreign there (`error[E0117]: slices are always foreign`). But in `datafusion-proto-models` the *self* type is local, which is all the orphan rule needs, and staying generic over the element avoids naming `PartitionedFile`, which sits above that crate in the graph: ```rust impl<T> TryFrom<&[T]> for protobuf::FileGroup where for<'a> &'a T: TryInto<protobuf::PartitionedFile, Error = DataFusionError>, { ... } ``` The bound is satisfied by `TryFrom<&PartitionedFile> for protobuf::PartitionedFile` in `datafusion-datasource`, so `protobuf::FileGroup::try_from(&files[..])` resolves for callers exactly as it did in 54.1.0. Two items beyond the issue's checklist, both needed to reach zero implementors: - the parquet options conversions (`ParquetOptions`, `TableParquetOptions`, `ParquetColumnOptions`, `ParquetCdcOptions`) — the issue's table undercounts `file_formats.rs` because they live in a private module, but trait impls are global, so they were public API too. They return as `TryFrom`; `main` had already made them fallible, so an exact restore of 54.1.0's infallible `From` isn't available. - `From<&protobuf::PhysicalColumn> for Column`, which the issue's evidence table counts but no work item names. Not restored, and worth calling out: `From<protobuf::dml_node::Type> for WriteOp` and its reverse. `main` replaced them with `parse_write_op` / `serialize_write_op` because `MergeInto` carries a payload a `From` impl cannot express. That is a separate, deliberate change. Finally, `convert.rs` and `convert_required_proto!` are deleted. apache#21929 introduced `FromProto` / `TryFromProto` so the `datafusion-proto-models` extraction could land without relocating ~39 conversions at the same time, and flagged them there as "a known workaround, not the end state", with dropping them listed under Future work. With every conversion moved they have no implementors and no callers. Neither trait has ever shipped in a release, so they are removed outright rather than deprecated — there is nothing for downstream users to migrate off, and doing it now keeps the workaround out of the released API entirely. ## Are these changes tested? Yes. - New `datafusion/proto/tests/cases/public_conversions.rs` coerces all 45 proto conversions in the touched crates to `fn` pointers (the 39 from 54.1.0 plus the ones added on `main`). This is the regression guard the issue asks for: it fails to compile when an impl is removed, and stays quiet when one merely moves between crates, which is exactly the case `cargo-semver-checks` cannot see. - New round-trip tests next to the moved impls in `datafusion-expr` and `datafusion-proto-models` (window frames, table references, join enums, unnest options, stringified plans). - The `PartitionedFile` tests move from `datafusion-proto` to `datafusion-datasource`, alongside the logic they cover; two that duplicated existing coverage there are dropped. - Existing round-trip suites (`roundtrip_logical_plan`, `roundtrip_physical_plan`) pass unchanged, which is the real wire-format check. - Every moved impl body was diffed against `main`: 22 are byte-identical modulo the trait rename, and the other 9 differ only by `Self::` shorthand, error-type aliasing, and rustfmt reflow. No serialization logic changed. - `./dev/rust_lint.sh`, `cargo machete`, and the extended test suite all pass at HEAD. Also checked: `datafusion-proto` without `parquet`, `datafusion-expr` with `proto` off and `--no-default-features`, the format crates without `proto`, and `json` on both proto crates. ## Are there any user-facing changes? Yes, and they restore rather than break the released API. - The 39 conversions removed since 54.1.0 compile again. Trait impls are global, so `X::try_from(&proto)` / `proto.try_into()` resolve regardless of which crate now hosts the impl — no import changes needed, and no upgrade-guide entry for the moves. - One genuine delta remains: the parquet options conversions are `TryFrom` rather than 54.1.0's infallible `From`. That predates this PR — `main` had already made them fallible — but it is a real 54.1.0 -> 55.0.0 break and was undocumented, so it is now in the 55.0.0 upgrade guide with a migration snippet. - `FromProto` / `TryFromProto` and `convert_required_proto!` are gone. Not a breaking change: they exist only on `main` and appear nowhere in 54.0.0 or 54.1.0. - `datafusion-expr` gains an off-by-default `proto` feature. Additive. - `datafusion-proto-models` gains a direct `datafusion-common` dependency (already present transitively) and two new public modules. Keeping the `api change` label for the parquet options fallibility. --------- Co-authored-by: Claude Opus 5 <[email protected]> Co-authored-by: Andrew Lamb <[email protected]>
1 parent b7b807b commit 5a65e93

28 files changed

Lines changed: 1616 additions & 1403 deletions

File tree

‎Cargo.lock‎

Lines changed: 3 additions & 1 deletion
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎datafusion/datasource-csv/src/file_format.rs‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -926,6 +926,54 @@ impl CsvSink {
926926
}
927927
}
928928

929+
/// Encode a [`CsvFormatFactory`]'s options as their protobuf form.
930+
///
931+
/// The reverse direction is `From<&protobuf::CsvOptions> for CsvOptions` in
932+
/// `datafusion-proto-models`: `CsvOptions` is a `datafusion-common` type, so
933+
/// that half cannot live here.
934+
#[cfg(feature = "proto")]
935+
impl From<&CsvFormatFactory> for datafusion_proto_models::protobuf::CsvOptions {
936+
fn from(factory: &CsvFormatFactory) -> Self {
937+
if let Some(options) = &factory.options {
938+
datafusion_proto_models::protobuf::CsvOptions {
939+
has_header: options.has_header.map_or(vec![], |v| vec![v as u8]),
940+
delimiter: vec![options.delimiter],
941+
quote: vec![options.quote],
942+
terminator: options.terminator.map_or(vec![], |v| vec![v]),
943+
escape: options.escape.map_or(vec![], |v| vec![v]),
944+
double_quote: options.double_quote.map_or(vec![], |v| vec![v as u8]),
945+
compression: options.compression as i32,
946+
schema_infer_max_rec: options.schema_infer_max_rec.map(|v| v as u64),
947+
date_format: options.date_format.clone().unwrap_or_default(),
948+
datetime_format: options.datetime_format.clone().unwrap_or_default(),
949+
timestamp_format: options.timestamp_format.clone().unwrap_or_default(),
950+
timestamp_tz_format: options
951+
.timestamp_tz_format
952+
.clone()
953+
.unwrap_or_default(),
954+
time_format: options.time_format.clone().unwrap_or_default(),
955+
null_value: options.null_value.clone().unwrap_or_default(),
956+
null_regex: options.null_regex.clone().unwrap_or_default(),
957+
comment: options.comment.map_or(vec![], |v| vec![v]),
958+
newlines_in_values: options
959+
.newlines_in_values
960+
.map_or(vec![], |v| vec![v as u8]),
961+
truncated_rows: options.truncated_rows.map_or(vec![], |v| vec![v as u8]),
962+
compression_level: options.compression_level,
963+
quote_style: options.quote_style as i32,
964+
ignore_leading_whitespace: options
965+
.ignore_leading_whitespace
966+
.map_or(vec![], |v| vec![v as u8]),
967+
ignore_trailing_whitespace: options
968+
.ignore_trailing_whitespace
969+
.map_or(vec![], |v| vec![v as u8]),
970+
}
971+
} else {
972+
datafusion_proto_models::protobuf::CsvOptions::default()
973+
}
974+
}
975+
}
976+
929977
#[cfg(test)]
930978
mod tests {
931979
use super::build_schema_helper;

‎datafusion/datasource-json/src/file_format.rs‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -615,3 +615,24 @@ impl Decoder for JsonDecoder {
615615
false
616616
}
617617
}
618+
619+
/// Encode a [`JsonFormatFactory`]'s options as their protobuf form.
620+
///
621+
/// The reverse direction is `From<&protobuf::JsonOptions> for JsonOptions` in
622+
/// `datafusion-proto-models`: `JsonOptions` is a `datafusion-common` type, so
623+
/// that half cannot live here.
624+
#[cfg(feature = "proto")]
625+
impl From<&JsonFormatFactory> for datafusion_proto_models::protobuf::JsonOptions {
626+
fn from(factory: &JsonFormatFactory) -> Self {
627+
if let Some(options) = &factory.options {
628+
datafusion_proto_models::protobuf::JsonOptions {
629+
compression: options.compression as i32,
630+
schema_infer_max_rec: options.schema_infer_max_rec.map(|v| v as u64),
631+
compression_level: options.compression_level,
632+
newline_delimited: Some(options.newline_delimited),
633+
}
634+
} else {
635+
datafusion_proto_models::protobuf::JsonOptions::default()
636+
}
637+
}
638+
}

‎datafusion/datasource-parquet/src/file_format.rs‎

Lines changed: 126 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -688,3 +688,129 @@ pub fn statistics_from_parquet_meta_calc(
688688
) -> Result<Statistics> {
689689
DFParquetMetadata::statistics_from_parquet_metadata(metadata, &table_schema)
690690
}
691+
692+
#[cfg(feature = "proto")]
693+
use datafusion_proto_models::protobuf::{self, parquet_column_options, parquet_options};
694+
695+
/// Encode a [`ParquetFormatFactory`]'s options as their protobuf form.
696+
///
697+
/// The reverse direction is `TryFrom<&protobuf::TableParquetOptions> for
698+
/// TableParquetOptions` in `datafusion-proto-models`: `TableParquetOptions` is
699+
/// a `datafusion-common` type, so that half cannot live here.
700+
#[cfg(feature = "proto")]
701+
impl From<&ParquetFormatFactory> for protobuf::TableParquetOptions {
702+
fn from(factory: &ParquetFormatFactory) -> Self {
703+
let global_options = if let Some(ref options) = factory.options {
704+
options.clone()
705+
} else {
706+
return protobuf::TableParquetOptions::default();
707+
};
708+
709+
let column_specific_options = global_options.column_specific_options;
710+
protobuf::TableParquetOptions {
711+
global: Some(protobuf::ParquetOptions {
712+
enable_page_index: global_options.global.enable_page_index,
713+
pruning: global_options.global.pruning,
714+
skip_metadata: global_options.global.skip_metadata,
715+
metadata_size_hint_opt: global_options.global.metadata_size_hint.map(|size| {
716+
parquet_options::MetadataSizeHintOpt::MetadataSizeHint(size as u64)
717+
}),
718+
pushdown_filters: global_options.global.pushdown_filters,
719+
reorder_filters: global_options.global.reorder_filters,
720+
force_filter_selections: global_options.global.force_filter_selections,
721+
data_pagesize_limit: global_options.global.data_pagesize_limit as u64,
722+
write_batch_size: global_options.global.write_batch_size as u64,
723+
writer_version: global_options.global.writer_version.to_string(),
724+
compression_opt: global_options.global.compression.map(|compression| {
725+
parquet_options::CompressionOpt::Compression(compression)
726+
}),
727+
dictionary_enabled_opt: global_options.global.dictionary_enabled.map(|enabled| {
728+
parquet_options::DictionaryEnabledOpt::DictionaryEnabled(enabled)
729+
}),
730+
dictionary_page_size_limit: global_options.global.dictionary_page_size_limit as u64,
731+
statistics_enabled_opt: global_options.global.statistics_enabled.map(|enabled| {
732+
parquet_options::StatisticsEnabledOpt::StatisticsEnabled(enabled)
733+
}),
734+
max_row_group_size: global_options.global.max_row_group_size as u64,
735+
max_in_list_size: global_options.global.max_in_list_size as u64,
736+
created_by: global_options.global.created_by.clone(),
737+
column_index_truncate_length_opt: global_options.global.column_index_truncate_length.map(|length| {
738+
parquet_options::ColumnIndexTruncateLengthOpt::ColumnIndexTruncateLength(length as u64)
739+
}),
740+
statistics_truncate_length_opt: global_options.global.statistics_truncate_length.map(|length| {
741+
parquet_options::StatisticsTruncateLengthOpt::StatisticsTruncateLength(length as u64)
742+
}),
743+
data_page_row_count_limit: global_options.global.data_page_row_count_limit as u64,
744+
encoding_opt: global_options.global.encoding.map(|encoding| {
745+
parquet_options::EncodingOpt::Encoding(encoding)
746+
}),
747+
bloom_filter_on_read: global_options.global.bloom_filter_on_read,
748+
bloom_filter_on_write: global_options.global.bloom_filter_on_write,
749+
bloom_filter_fpp_opt: global_options.global.bloom_filter_fpp.map(|fpp| {
750+
parquet_options::BloomFilterFppOpt::BloomFilterFpp(fpp)
751+
}),
752+
bloom_filter_ndv_opt: global_options.global.bloom_filter_ndv.map(|ndv| {
753+
parquet_options::BloomFilterNdvOpt::BloomFilterNdv(ndv)
754+
}),
755+
allow_single_file_parallelism: global_options.global.allow_single_file_parallelism,
756+
maximum_parallel_row_group_writers: global_options.global.maximum_parallel_row_group_writers as u64,
757+
maximum_buffered_record_batches_per_stream: global_options.global.maximum_buffered_record_batches_per_stream as u64,
758+
schema_force_view_types: global_options.global.schema_force_view_types,
759+
binary_as_string: global_options.global.binary_as_string,
760+
skip_arrow_metadata: global_options.global.skip_arrow_metadata,
761+
coerce_int96_opt: global_options.global.coerce_int96.map(|compression| {
762+
parquet_options::CoerceInt96Opt::CoerceInt96(compression)
763+
}),
764+
coerce_int96_tz_opt: global_options.global.coerce_int96_tz.map(|tz| {
765+
parquet_options::CoerceInt96TzOpt::CoerceInt96Tz(tz)
766+
}),
767+
max_predicate_cache_size_opt: global_options.global.max_predicate_cache_size.map(|size| {
768+
parquet_options::MaxPredicateCacheSizeOpt::MaxPredicateCacheSize(size as u64)
769+
}),
770+
max_row_group_bytes_opt: global_options.global.max_row_group_bytes.map(|size| {
771+
parquet_options::MaxRowGroupBytesOpt::MaxRowGroupBytes(size.get() as u64)
772+
}),
773+
content_defined_chunking: Some(protobuf::ParquetCdcOptions {
774+
enabled: global_options.global.content_defined_chunking.enabled,
775+
min_chunk_size: global_options.global.content_defined_chunking.min_chunk_size as u64,
776+
max_chunk_size: global_options.global.content_defined_chunking.max_chunk_size as u64,
777+
norm_level: global_options.global.content_defined_chunking.norm_level,
778+
}),
779+
}),
780+
column_specific_options: column_specific_options.into_iter().map(|(column_name, options)| {
781+
protobuf::ParquetColumnSpecificOptions {
782+
column_name,
783+
options: Some(protobuf::ParquetColumnOptions {
784+
bloom_filter_enabled_opt: options.bloom_filter_enabled.map(|enabled| {
785+
parquet_column_options::BloomFilterEnabledOpt::BloomFilterEnabled(enabled)
786+
}),
787+
encoding_opt: options.encoding.map(|encoding| {
788+
parquet_column_options::EncodingOpt::Encoding(encoding)
789+
}),
790+
dictionary_enabled_opt: options.dictionary_enabled.map(|enabled| {
791+
parquet_column_options::DictionaryEnabledOpt::DictionaryEnabled(enabled)
792+
}),
793+
compression_opt: options.compression.map(|compression| {
794+
parquet_column_options::CompressionOpt::Compression(compression)
795+
}),
796+
statistics_enabled_opt: options.statistics_enabled.map(|enabled| {
797+
parquet_column_options::StatisticsEnabledOpt::StatisticsEnabled(enabled)
798+
}),
799+
bloom_filter_fpp_opt: options.bloom_filter_fpp.map(|fpp| {
800+
parquet_column_options::BloomFilterFppOpt::BloomFilterFpp(fpp)
801+
}),
802+
bloom_filter_ndv_opt: options.bloom_filter_ndv.map(|ndv| {
803+
parquet_column_options::BloomFilterNdvOpt::BloomFilterNdv(ndv)
804+
}),
805+
})
806+
}
807+
}).collect(),
808+
key_value_metadata: global_options.key_value_metadata
809+
.iter()
810+
.filter_map(|(key, value)| {
811+
value.as_ref().map(|v| (key.clone(), v.clone()))
812+
})
813+
.collect(),
814+
}
815+
}
816+
}

‎datafusion/datasource/src/proto.rs‎

Lines changed: 69 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,10 +18,9 @@
1818
//! Protobuf conversions for the file-scan leaf types owned by this crate:
1919
//! [`FileRange`], [`PartitionedFile`] and [`FileGroup`].
2020
//!
21-
//! These are the single copy of that wire logic. `datafusion-proto`'s
22-
//! `TryFromProto` implementations for the same types are thin shims that
23-
//! delegate here, so the format cannot drift between the central serializer and
24-
//! the per-source `try_to_proto` hooks.
21+
//! These are the single copy of that wire logic, used both by the central
22+
//! serializer in `datafusion-proto` and by the per-source `try_to_proto` hooks,
23+
//! so the format cannot drift between them.
2524
//!
2625
//! None of these conversions need a codec or an encode/decode context: every
2726
//! field is plain data or goes through `datafusion-proto-common`. That is why
@@ -204,6 +203,53 @@ mod tests {
204203
Ok(())
205204
}
206205

206+
#[test]
207+
fn partitioned_file_path_roundtrip_percent_encoded() -> Result<()> {
208+
// The wire format carries the *encoded* path, so a location that already
209+
// contains percent escapes must survive without a second round of
210+
// encoding or decoding.
211+
let path_str = "foo/foo%2Fbar/baz%252Fqux";
212+
let pf = PartitionedFile::new_from_meta(ObjectMeta {
213+
location: Path::parse(path_str)?,
214+
last_modified: Utc.timestamp_nanos(1_000),
215+
size: 42,
216+
e_tag: None,
217+
version: None,
218+
});
219+
220+
let encoded = protobuf::PartitionedFile::try_from(&pf)?;
221+
assert_eq!(encoded.path, path_str);
222+
223+
let decoded = PartitionedFile::try_from(&encoded)?;
224+
assert_eq!(decoded.object_meta.location.as_ref(), path_str);
225+
assert_eq!(decoded.object_meta.location, pf.object_meta.location);
226+
Ok(())
227+
}
228+
229+
#[test]
230+
fn partitioned_file_arrow_schema_roundtrip_preserves_metadata() -> Result<()> {
231+
use std::collections::HashMap;
232+
233+
let arrow_schema = Arc::new(Schema::new_with_metadata(
234+
vec![
235+
Field::new("id", DataType::Int64, false),
236+
Field::new("value", DataType::Utf8, true).with_metadata(HashMap::from([
237+
("field_meta".to_string(), "field_value".to_string()),
238+
])),
239+
],
240+
HashMap::from([("schema_meta".to_string(), "schema_value".to_string())]),
241+
));
242+
let pf = PartitionedFile::new("foo/bar.parquet", 10)
243+
.with_arrow_schema(Arc::clone(&arrow_schema));
244+
245+
let encoded = protobuf::PartitionedFile::try_from(&pf)?;
246+
assert!(encoded.arrow_schema.is_some());
247+
248+
let decoded = PartitionedFile::try_from(&encoded)?;
249+
assert_eq!(decoded.arrow_schema.as_deref(), Some(arrow_schema.as_ref()));
250+
Ok(())
251+
}
252+
207253
#[test]
208254
fn partitioned_file_from_proto_rejects_invalid_path() {
209255
let proto = protobuf::PartitionedFile {
@@ -218,6 +264,25 @@ mod tests {
218264
);
219265
}
220266

267+
#[test]
268+
fn file_group_from_slice_matches_file_group() -> Result<()> {
269+
// `protobuf::FileGroup: TryFrom<&[T]>` lives in `datafusion-proto-models`,
270+
// generic over the element so that crate never names `PartitionedFile`.
271+
// This is the caller-visible half: the bound resolves via
272+
// `TryFrom<&PartitionedFile> for protobuf::PartitionedFile` above.
273+
let files = vec![
274+
PartitionedFile::new("a.parquet", 1),
275+
PartitionedFile::new("b.parquet", 2),
276+
];
277+
278+
let from_slice = protobuf::FileGroup::try_from(&files[..])?;
279+
let from_group = protobuf::FileGroup::try_from(&FileGroup::new(files))?;
280+
281+
assert_eq!(from_slice, from_group);
282+
assert_eq!(from_slice.files.len(), 2);
283+
Ok(())
284+
}
285+
221286
#[test]
222287
fn file_group_roundtrip() -> Result<()> {
223288
let group = FileGroup::new(vec![

‎datafusion/expr/Cargo.toml‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,10 @@ name = "datafusion_expr"
4242

4343
[features]
4444
default = ["sql"]
45+
# Enables protobuf conversions for the expression types owned by this crate.
46+
# Off by default so consumers that never serialize plans pay nothing. Mirrors
47+
# the `proto` feature on `datafusion-datasource` and friends.
48+
proto = ["dep:datafusion-proto-common", "dep:datafusion-proto-models"]
4549
recursive_protection = ["dep:recursive"]
4650
sql = ["sqlparser"]
4751

@@ -56,6 +60,8 @@ datafusion-expr-common = { workspace = true }
5660
datafusion-functions-aggregate-common = { workspace = true }
5761
datafusion-functions-window-common = { workspace = true }
5862
datafusion-physical-expr-common = { workspace = true }
63+
datafusion-proto-common = { workspace = true, optional = true }
64+
datafusion-proto-models = { workspace = true, optional = true }
5965
indexmap = { workspace = true }
6066
itertools = { workspace = true }
6167
recursive = { workspace = true, optional = true }

‎datafusion/expr/src/lib.rs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,11 @@ pub mod dml {
6969
pub use crate::logical_plan::dml::*;
7070
}
7171
pub mod planner;
72+
/// Protobuf conversions for [`WindowFrame`], [`WindowFrameBound`],
73+
/// [`WindowFrameUnits`], [`MergeIntoClauseKind`](dml::MergeIntoClauseKind) and
74+
/// [`NullTreatment`](expr::NullTreatment), gated on the `proto` feature.
75+
#[cfg(feature = "proto")]
76+
mod proto;
7277
pub mod registry;
7378
pub mod simplify;
7479
pub mod sort_properties {

0 commit comments

Comments
 (0)